A la découverte de Java 8

Sun, 04 May 2014 17:58:00 +0200

Java 8 est maintenant disponible depuis plusieurs semaines, voici un “petit” résumé des fonctionalités de Java 8 que j’ai testé à travers tous les articles sur lesquels je suis tombé.

Default methods sur les Interfaces
#

Java 8 utilise le mot clef default pour définir une implémentation par défaut au sein d’une interface.
C’est utile pour les développeurs d’API, c’était même indispensable pour la plupart des nouveautés du langage sinon comment enrichir les interfaces comme java.util.Collection sans briser toutes les implémentations existantes ?

public interface A {
 default void printSomething() {
 System.out.println("something");
 }
}

public class Implementation implements A {}

La classe Implementation n’a pas besoin de définir la méthode printSomething.

public class Examples {
 public static void main(String[] args) {
 new Implementation().printSomething();
 }
}

Que ce passe t-il si deux interfaces implémentent la même méthode par défaut et qu’une classe implémente ces deux interfaces ?

public interface B {
 default void printSomething() {
 System.out.println("something else");
 }
}

public class DoesNotCompile implements A,B {}

Et bien le code précédent ne compile pas:

class DoesNotCompile inherits unrelated defaults for printSomething() from types A and B

On est obligé de surcharger la méthode dans l’implémentation pour résoudre le conflit,

public class ItCompiles implements A,B {

 @Override
 public void printSomething() {
 System.out.printf("I can print what I want !");
 }
}

Pour faire référence à une des méthodes par défaut :

public class ItCompilesToo implements A,B {

 @Override
 public void printSomething() {
 B.super.printSomething();
 }
}

Je pense que cette fonctionalité va être très utile pour les développeurs de librairies, on va pouvoir oublier les fameuses classes abstraites dont il fallait hériter pour ne pas risquer de tout casser lors de mises à jour d’interfaces.

Expressions Lambda
#

Surement une des évolutions les plus attendues, une expression lambda est une sorte de méthode “anonyme”. Jusqu’à aujourd’hui en Java pour simuler ce comportement on utilisait une classe anonyme qui implémentait une interface avec une seule méthode abstraite (SAM).

List<Integer> numbers = asList(10, 1, 1000, 100);

Collections.sort(numbers, new Comparator<Integer>() {
 @Override
 public int compare(Integer a, Integer b) {
 return a.compareTo(b);
 }
});

peut-etre remplacé par :

Collections.sort(numbers, (a, b) -> a.compareTo(b));

Le compilateur est capable de trouver les types des paramètres, pas besoin de les préciser et la méthode tenant sur une ligne, on peut également omettre les {} et le return.

Accès variable locale
#

Contrairement à une classe anonyme, une expression lambda peut accéder aux variables locales même si celles ci ne sont pas déclarées comme étant final.

Integer n = 4;
Function<Integer, Integer> modulo = (Integer a) -> a % n;

assert modulo.apply(8) == 0;

mais en fait il faut qu’elles le soient, le code suivant ne compile pas :

Integer n = 4;
Function<Integer, Integer> modulo = (Integer a) -> a % n;
n = 8;

avec comme erreur :

local variables referenced from a lambda expression must be final or effectively final

Membre et variable static
#

Contrairement aux variables locales, les membres de classe sont accessibles en écriture.

public class Lambda {

 private static int staticNumber;
 private int number;

 public void write() {
 Function<Integer, Integer> function = (Integer a) -> staticNumber = a;
 Function<Integer, Integer> function2 = (Integer a) -> number = a;
 }
}

Functional Interfaces
#

Les expressions lambda ne sont en fait pas si “anonymes” que ça. Elles correspondent en fait à des types spécifiés par des interfaces avec exactement une méthode abstraite. C’est pour ça que les classes anonymes implémentant une interface de type SAM peuvent être remplacées par des expressions lambda.
Java 8 propose l’annotation @FunctionalInterface pour s’assurer qu’une interface ne déclare qu’une seule méthode abstraite.

@FunctionalInterface
public interface Function<T, R> {

 R apply(T t);
}

Si une deuxième méthode abstraite est ajoutée la compilation échoue :

Function is not a functional interface, multiple non-overriding abstract methods found in interface

Lambda
#

On peut ajouter des méthodes par defaut sur une @FunctionalInterface.

@FunctionalInterface
public interface A {

 default void printSomething() {
 System.out.println("something");
 }

 void print();
}

mais on ne peut pas accéder à ces méthodes depuis une lambda.

A doesNotCompile = () -> printSomething();

Function, Predicate, etc
#

De nombreuses @FunctionalInterface sont disponibles par défaut. D’anciennes interfaces de l’API ont été migrées, Comparable et Runnable par exemple. Si vous connaissez déjà Guava vous ne serez pas complètement perdu.

Function
#

Une Function prend un argument et retourne un résultat.

Function<Integer, String> toString = n -> String.valueOf(n);
Function<String, Integer> toInteger = s -> Integer.valueOf(s);

assert "4".equals(toString.apply(4));
assert toInteger.apply("4") == 4;

assert "4".equals(toString.compose(toInteger).apply("4"));
assert toString.andThen(toInteger).apply(4) == 4;

La méthode compose applique la fonction toInteger puis la fonction toString alors que la méthode andThen applique toString puis toInteger.

BiFunction
#

C’est un spécialisation d’une Function qui prend deux arguments et retourne un résultat.

BiFunction<Integer, String, String> concat = (Integer i, String s) -> s + ": " + i;

assert "un: 1".equals(concat.apply(1, "un"));

UnaryOperator
#

C’est une Function qui prend un argument et retourne un résultat du même type. Par exemple la fonction identity retourne toujours la valeur passée en argument.

assert UnaryOperator.identity().apply("un").equals("un");

BinaryOperator
#

Un BinaryOperator est une spécialisation d’une BiFunction dont les paramètres et le résultat partagent le même type.

BinaryOperator<String> concatString = (s1, s2) -> s1.concat(": ").concat(s2);

assert "un: 1".equals(concatString.apply("un", "1"));

Predicate
#

Un Predicate prend un argument et retourne un booléen.

Predicate<String> isEmpty = s -> s == null || s.isEmpty();
Predicate<String> isTrimmed = s -> s.equals(s.trim());
 
assert isEmpty.test(null) == true;
assert isEmpty.test("") == true;
assert isEmpty.test("not empty") == false;

assert isEmpty.negate().and(isTrimmed).test("not empty") == true;
assert isEmpty.negate().and(isTrimmed).test(" not empty ") == false;

assert isEmpty.or(isTrimmed).test("") == true;
assert isEmpty.or(isTrimmed).test("not empty") == true;

assert Predicate.isEqual("hello").test("hello") == true;

negate inverse un prédicat,
and et or permettent de chaîner des prédicats selon l’opérateur logique,
La méthode statique isEqual teste l’égalité de deux objets selon Object#equals

BiPredicate
#

Un BiPredicate prend deux arguments et retourne un booléen.

Supplier
#

Un Supplier ne prend pas d’argument et produit un résultat.

Supplier<String> emptyString = () -> "";

assert "".equals(emptyString.get());

Consumer
#

Un Consumer prend un argument mais ne retourne pas de résultat.

Consumer<String> print = s -> System.out.println(s);
Consumer<String> hello = s -> System.out.printf("Hello %s !", s);

print.accept("something"); // something
print.andThen(hello).accept("JC"); // JC Hello JC !

La méthode andThen permet de chaîner les consommateurs.

Comparator
#

Les Comparator sont devenus des FunctionalInterface.

Comparator<Integer> ascending = (a, b) -> a.compareTo(b);

assert ascending.compare(10, 1) > 0;
assert ascending.reversed().compare(10, 1) < 0;

Sans grande surprise reversed inverse la comparaison.
Il existe des méthodes par défaut pour appliquer une Function avant le Comparator dans les différents thenComparating.

A retenir
#

Ça fait beaucoup d’interfaces fonctionnelles (et je n’ai même pas lister les versions spécifiques pour les types primitifs), ce qu’il faut retenir :

s’il n’y a pas de retour, on utilise un Consumer,
s’il faut retourner un booléen, on utilise un Predicate,
s’il faut produire un numérique primitif (int, double, long), on utilise un (Type)ToIntFunction, (Type)ToDoubleFunction, (Type)ToLongFunction,
s’il faut retourner une valeur sans prendre d’argument, c’est un Supplier,
si le seul argument de la fonction est un int, double, long on utilise un Int(something), Double(something), Long(Something),
si la fonction prend deux arguments, c’est une Bi(something),
si la fonction prend deux arguments de même type, c’est un BinaryOperator,
si une fonction retourne une valeur de même type que son unique argument, c’est un UnaryOperator,
si une fonction prend en argument un type primitif et un autre type sans retourner de valeur, c’est un Obj(Int|Double|Long)Consumer,
sinon c’est une Function.

Surcharge de méthode
#

On peut surcharger une méthode utilisant une FunctionalInterface en paramètre par une autre plus spécifique (la manière classique d’overloading).

Par exemple, un BinaryOperator est une spécialisation d’une BiFunction,

public class A {

 public void is(BiFunction<Boolean, Boolean, Boolean> function) {
 System.out.println("bifunction");
 }

 public void is(BinaryOperator<Boolean> function) {
 System.out.println("binaryoperator");
 }
}

le code suivant affichera "binaryoperator"

new A().is((a, b) -> true);

Par contre le compilateur ne peut pas toujours trouvé “un type le plus spécifique”. Dans le cas où les types en questions n’ont pas de relation, seul le nombre d’arguments de la FunctionalInterface permet de différencier les méthodes surchargées.

@FunctionalInterface
public interface StringPredicate {
 boolean test(String string);
}

public class A {

 public void anotherMethod(Predicate<String> predicate) {
 System.out.println("predicate");
 }

 public void anotherMethod(StringPredicate predicate) {
 System.out.println("string predicate");
 }
}

Le code suivant ne compile pas

new A().anotherMethod(input -> true);

reference to anotherMethod is ambiguous
both method anotherMethod(java.util.function.Predicate<java.lang.String>) in fr.jcgay.example.java.overload.A and method anotherMethod(fr.jcgay.example.java.overload.StringPredicate) in fr.jcgay.example.java.overload.A match

Même si c’est techniquement possible, je ne suis pas sûr que ce soit une super idée de surcharger de telles méthodes, dans le premier cas par exemple la résolution est bien moins claire lors de la manipulation de l’expression lambda que lors de cas classiques de surcharge où l’on manipule directement des types.

Références de méthodes
#

Java 8 introduit le mot clef :: pour extraire des références de méthodes. C’est utile pour remplacer des expressions lambda qui se contentent de faire appel à une méthode qui existe déjà.

On peut remplacer :

Function<Integer, String> toString = n -> String.valueOf(n);

par :

Function<Integer, String> toString = String::valueOf;

On peut faire référence à des méthodes statiques mais aussi directement depuis une instance,

String hello = new String("hello");
Predicate<String> startsWith = hello::startsWith;

assert startsWith.test("he") == true;

et aux constructeurs,

Supplier<String> newString = String::new;

et aussi aux méthodes d’instance sans référence d’objet en particulier :

List<String> names = Arrays.asList("Barbara", "James", "Mary", "John");
Collections.sort(names, String::compareToIgnoreCase);

Fonctionnement
#

C’est bien magique mais comment on détermine qu’une méthode existante est compatible avec une FunctionalInterface ?

statique
#

La plus simple à se représenter, il suffit que la dite méthode ait bien la même signature que la méthode unique de l’interface désirée.

Par exemple, on peut écrire notre Function toString précédente,

Function<Integer, String> toString = new Function<Integer, String>() {
 @Override
 public String apply(Integer integer) {
 return String.valueOf(integer);
 }
};

String#valueOf(Integer) est bien utilisable pour implémenter Function<Integer, String>#apply(Integer), et remplacer une expression lambda par une référence de méthode statique.

instance
#

Ce type de référence permet de capturer une instance qui sera utilisée lors de l’évaluation de l’expression lambda.

Ainsi notre exemple du début revient à écrire :

String hello = new String("hello");
Predicate<String> startsWith = new Predicate<String>() {
 @Override
 public boolean test(String s) {
 return hello.startsWith(s);
 }
};

instance arbitraire
#

Ce sont les plus difficiles à se représenter au début. Ces références permettent de pointer des méthodes sur des instances qui seront découvertes à l’exécution. En fait celà veut dire que l’instance en question sera le premier argument de l’expression lambda et le reste des paramètres seront ceux passés à la méthode en référence.

Reprenons l’exemple de la comparaison de chaînes de caractères,

BiFunction<String, String, Integer> concat = new BiFunction<String, String, Integer>() {
 @Override
 public Integer apply(String self, String argument) {
 return self.compareToIgnoreCase(argument);
 }
};

Optional
#

C’est un conteneur pour une valeur qui peut être null. Ce conteneur possède deux états, contenant une valeur ou ne contenant rien.
Retourner un Optional à la place d’un null permet d’obliger le traitement du cas “pas de valeur de retour”.

Optional<String> hello = Optional.of("hello");

assert hello.isPresent() == true;
assert "hello".equals(hello.get());

Si la valeur contenu est null,

Optional<Object> absent = Optional.ofNullable(null);

assert absent.isPresent() == false;
absent.get() // throws java.util.NoSuchElementException: No value present

La classe Optional regorge de méthodes utilitaires pour transformer/filtrer la valeur qu’il contient, pour retourner une valeur par défaut et également un orElseThrow qui pour le coup n’existe pas dans Guava.

Stream
#

Un Stream est une séquence d’éléments sur laquelle on peut effectuer des opérations. Un Stream se compose d’une source (un tableau, une collection, etc), de zéro ou plusieurs opérations intermédiaires (transformation du Stream en un autre via filter par exemple) et d’une opération terminale (qui produit le résultat).
Les calculs ne sont effectués qu’à l’initialisation de l’opération finale et la source est consommée que si c’est nécessaire.

On peut créer un Stream à partir d’une collection en utilisant la méthode stream(),

List<Person> persons = asList(
 new Person("John", "Doe", 30),
 new Person("Jane", "Doe", 20),
 new Person("Jim", "Smith", 15)
 );

assert persons.stream().count() == 3;

En utilisant IntStream, DoubleStream, LongStream pour créer des Stream numériques,

assert IntStream.range(0, 10).sum() == 45;

Ou encore avec différentes méthodes utilitaires sur la classe Stream,

Stream.of("a", "b", "c").forEach(System.out::println);

Stream.builder().add("a").add("b").add("c")
 .build()
 .forEach(System.out::println);

Un Stream peut-être infini, dans ce cas il faut avoir une opération stoppante,

Random random = new Random();
Stream.generate(() -> random.nextInt())
 .limit(10)
 .forEach(System.out::println);

new Random().ints()
 .limit(10)
 .forEach(System.out::println);

En gros il y a des Stream un peu partout :)

forEach
#

Effectue une opération sur chacun des éléments en utilisant un Consumer. C’est une opération terminale qui consomme le Stream. On ne peut pas appeler d’autres opérations après un forEach.

persons.stream()
 .forEach(p -> System.out.println(p.getLastName() + " " + p.getFirstName()));

// Doe John
// Doe Jane
// Smith Jim

filter
#

Accepte un Predicate pour filtrer les éléments. C’est une opération intermédiaire qui nous permet donc de chaîner d’autres opérations à sa suite.

persons.stream()
 .filter(p -> p.getLastName().startsWith("D"))
 .forEach(System.out::println);

// Person{firstName='John', lastName='Doe', age=30}
// Person{firstName='Jane', lastName='Doe', age=20}

sorted
#

Une opération intermédiaire qui permet de trier les éléments à l’aide d’un Comparable.

persons.stream()
 .sorted((p1, p2) -> p1.getFirstName().compareTo(p2.getFirstName()))
 .forEach(System.out::println);

// Person{firstName='Jane', lastName='Doe', age=20}
// Person{firstName='Jim', lastName='Smith', age=15}
// Person{firstName='John', lastName='Doe', age=30}

map
#

Applique une Function sur les éléments, c’est également une opération intermédiaire.

persons.stream()
 .map(Person::getAge)
 .sorted()
 .forEach(System.out::println);
 
// 15
// 20
// 30

allMatch, anyMatch, noneMatch
#

Plusieurs méthodes permettant de vérifier que zéro/un/des éléments vérifient un Predicate. Toutes ces opérations sont terminales.

assert persons.stream()
 .allMatch(p -> p.getFirstName().startsWith("J"))
 == true;

assert persons.stream()
 .noneMatch(p -> p.getAge() == 35)
 == true;
 
assert persons.stream()
 .anyMatch(p -> "Doe".equals(p.getLastName()))
 == true;

count
#

Une opération terminale qui retourne le nombre d’élément dans un Stream.

assert persons.stream()
 .filter(p -> p.getAge() >= 20)
 .count()
 == 2;

sum
#

Retourne la somme de tous les éléments.

assert IntStream.rangeClosed(1, 10).sum() == 55;

reduce
#

C’est une opération terminale qui réduit les éléments du Stream avec un BinaryOperator.
On obtient au final le résultat sous la forme d’un Optional,

On va créer un monstre en fusionnant nos personnes,

persons.stream()
 .reduce((p1, p2) -> new Person(p1.getFirstName(), p2.getLastName(), p1.getAge() + p2.getAge()))
 .ifPresent(System.out::println);

// Person{firstName='John', lastName='Smith', age=65}

On peut additionner les âges de nos personnes,

assert persons.stream()
 .map(Person::getAge)
 .reduce(0, Integer::sum)
 == 65;

L’argument idendity est l’élément identité de la réduction, il ne doit avoir aucun effet sur la fonction d’accumulation (accumulator dans la signature de reduce). C’est le cas ici puisque x + 0 = x.

Et on peut encore écrire le reduce sous la forme

assert persons.stream()
 .reduce(0,
 (result, person) -> result + person.getAge(),
 (a, b) -> a + b
 )
 == 65;

L’accumulator définit l’opération effectué sur chacun des éléments et retient ce résultat tandis que le combiner décrit l’opération effectuée pour combiner deux résultats de la fonction accumulator.
Cette fois ci identity ne doit pas avoir d’effet sur le combiner.
La fonction combiner doit être associative pour assurer la cohérence du résultat lors du traitement du Stream en parallèle.

collect
#

Permet de réunir tous les éléments en utilisant un Collector. C’est bien entendu une opération terminale.

persons.stream()
 .map(Person::getLastName)
 .collect(Collectors.toList());

// [Doe, Doe, Smith]

La classe Collectors regorge d’implémentations de Collector pour faciliter l’opération.
On peut en avoir un très bon aperçu dans la présentation de José Paumard : Java 8 Streams & Collectors : patterns, performances, parallélisation

concat
#

On peut concaténer des Stream.

IntStream.concat(
 IntStream.range(0, 4),
 IntStream.range(4, 6)
).forEach(System.out::print);

// 012345

findFirst, findAny
#

Des opérations terminales qui permettent de retourner le premier élément du Stream s’il existe en tant qu’Optional,

persons.stream()
 .findFirst()
 .ifPresent(System.out::print);

// Person{firstName='John', lastName='Doe', age=30}

ou encore n’importe quel élément,

persons.stream()
 .parallel()
 .findAny()
 .ifPresent(System.out::print);

Le résultat de findAny n’est pas constant, le résultat peut varier.

flatMap
#

C’est une opération intermédiraire qui permet de mettre à plat un Stream.
On peut par exemple transformer un Stream<List<Person>> en Stream<Person> via une Function<List<Person>, Stream<Person>> :

Stream.<List<Person>>builder()
 .add(asList(new Person("John", "Doe", 30), new Person("Jane", "Doe", 20)))
 .add(asList(new Person("Jim", "Smith", 15)))
 .build()
 .flatMap(persons -> persons.stream())
 .filter(person -> "Doe".equals(person.getLastName()))
 .forEach(System.out::println);
 
// Person{firstName='John', lastName='Doe', age=30}
// Person{firstName='Jane', lastName='Doe', age=20}

limit, skip
#

Permet de se déplacer ou de bloquer le nombre d’éléments d’un Stream. Ce sont des opérations intermédiaires.

persons.stream()
 .limit(2)
 .skip(1)
 .findFirst()
 .ifPresent(System.out::print);

// 	Person{firstName='Jane', lastName='Doe', age=20}

min, max
#

Des opérations terminales pour trouver le minimum ou le maximum (en tant qu’Optional) d’un Stream s’ils existent à l’aide d’un Comparator.

assert IntStream.rangeClosed(1, 10)
 .min()
 .getAsInt()
 == 1;

assert IntStream.rangeClosed(1, 10)
 .max()
 .getAsInt()
 == 10;

peek
#

Une méthode utile pour débugger entre les opérations efféctuées sur un Stream. C’est une opération intermédiaire qui exécute un Consumer sur chacun des éléments.

persons.stream()
 .filter(p -> "Doe".equals(p.getLastName()))
 .peek(System.out::println)
 .filter(p -> p.getAge() < 25)
 .peek(System.out::println)
 .collect(Collectors.toSet());

// Person{firstName='John', lastName='Doe', age=30}
// Person{firstName='Jane', lastName='Doe', age=20}

// Person{firstName='Jane', lastName='Doe', age=20}

Parallel Stream
#

Par défaut les opérations effectuées sur un Stream sont séquentielles. Pour paralléliser les processus il suffit d’utiliser la méthode parallel.
On peut changer l’état d’un Stream au cours de son utilisation en utilisant sequential et parallel.
Bien ententu il ne s’agit pas d’utiliser parallel sur chaque Stream en espèrant un temps de traitement moins long (ça peut même être le contraire). Il conviendra donc de s’assurer de la pertinence de son utilisation.

Map
#

Les Map ne sont pas compatibles avec les Stream. Elles ont quand même le droit à leur lot de nouvelles fonctionalités.

putIfAbsent
#

Associe une valeur avec une clef seulement si la clef n’existe pas encore ou si la valeur associée à la clef vaut null.

Map<String, String> map = new HashMap<>();

assert map.putIfAbsent("key", null) == null;
assert map.get("key") == null;

assert map.putIfAbsent("key", "value") == null;
assert map.get("key").equals("value");

assert map.putIfAbsent("key", "new-value").equals("value");
assert map.get("key").equals("value");

forEach
#

Utilise un BiConsumer pour consommer tous les couples d’une Map.

Map<String, Integer> map = new HashMap<>();
map.put("un", 1);
map.put("deux", 2);
map.put("trois", 3);

map.forEach((key, value) -> System.out.printf("%s(%d) ", key, value));

// trois(3) un(1) deux(2)

computeIf
#

Permet d’appliquer une BiFunction sur les valeurs de la map.

compute
#

Si la Function retourne null, le couple est supprimé de la map.

assert map.compute("un", (key, value) -> null) == null;
assert map.compute("deux", (key, value) -> value == null ? null : value + 2) == 4;

// trois(3) deux(4) 

computeIfAbsent
#

Tente la création d’une valeur pour une clef si celle-ci n’est associée à aucune valeur (ou si elle est null) en utilisant une Function.

assert map.computeIfAbsent("un", key -> null) == 1;
assert map.computeIfAbsent("quatre", key -> 4) == 4;

// trois(3) quatre(4) un(1) deux(2)

computeIfPresent
#

Tente de mettre à jour la valeur associée à une clef si la valeur en question est non-null avec une BiFunction. Si la Function retourne null, le couple est supprimé de la Map.

Map<String, Integer> map = new HashMap<>();
map.put("un", 1);
map.put("deux", 2);
map.put("trois", 3);
map.put("quatre", null);

assert map.computeIfPresent("trois", (key, value) -> value + 5) == 8;
assert map.computeIfPresent("un", (key, value) -> null) == null;
assert map.computeIfPresent("quatre", (key, value) -> value + 5) == null;

// trois(8) quatre(null) deux(2)

remove
#

Supprime l’Entry pour la clef en argument si et seulement si la valeur associée à cette clef est égale à celle en argument.

assert map.remove("un", 1) == true;
assert map.remove("deux", 3) == false;

// trois(3) deux(2) 

getOrDefault
#

Retourne une valeur par défaut si aucune valeur n’est associée à la clef en argument.

assert map.getOrDefault("un", -1) == 1;
assert map.getOrDefault("six", -1) == -1;

merge
#

Associe la valeur non-null en argument à une clef si cette clef n’est pas déjà associée à une valeur (ou si la valeur est null), sinon applique la BiFunction sur la valeur existante.

Map<Integer, String> map = new HashMap<>();
map.put(1, "un");
map.put(2, "deux");

assert map.merge(1, " exemple", String::concat).equals("un exemple");
assert map.merge(2, "exemples", (key, value) -> null) == null;

// 1(un exemple) 

replace, replaceAll
#

Remplace une valeur associée à une clef si cette valeur est égale à celle en argument.

Map<String, Integer> map = new HashMap<>();
map.put("un", 1);
map.put("deux", 2);

assert map.replace("un", 1, 5) == true;
assert map.replace("deux", 3, 5) == false;

// un(5) deux(2)

Remplace toutes les valeurs en appliquant la BiFunction en paramètre

Map<String, Integer> map = new HashMap<>();
map.put("un", 1);
map.put("deux", 2);

map.replaceAll((key, value) -> "un".equals(key) ? value + 1 : value + 2);

assert map.get("un") == 2;
assert map.get("deux") == 4;

Date
#

Une toute nouvelle API pour les dates est disponible dans le package java.time. Elle s’inspire de Joda-Time et toutes les classes de cette API sont enfin immuables et threadsafe !

LocalTime
#

Cette classe représente une heure au sein d’une journée sans information de timezone, c’est l’heure qu’on affiche sur une horloge.

LocalTime time1 = LocalTime.of(13, 37, 26);
LocalTime time2 = LocalTime.of(15, 47, 54);

assert time1.isBefore(time2) == true;

LocalTime time3 = time1.plusMinutes(5);

assert ChronoUnit.HOURS.between(time1, time2) == 2;
assert ChronoUnit.MINUTES.between(time1, time3) == 5;

time1.format(DateTimeFormatter.ISO_LOCAL_TIME); // 13:37:26
time3.format(DateTimeFormatter.ofPattern("Ha")); // 13PM

DateTimeFormatter formatter = DateTimeFormatter
 .ofLocalizedTime(FormatStyle.SHORT)
 .withLocale(Locale.FRANCE);
LocalTime time4 = LocalTime.parse("17:17", formatter);

assert time4.getHour() == 17;
assert time4.getMinute() == 17;

LocalDate
#

Représente une date sans information d’heures, c’est ce qu’on utilise pour une date de naissance.

LocalDate today = LocalDate.now();
LocalDate tomorrow = today.plus(1, ChronoUnit.DAYS);
LocalDate yesterday = today.minusDays(1);

LocalDate birthday = LocalDate.of(2014, Month.DECEMBER, 18);
assert birthday.getDayOfWeek() == DayOfWeek.THURSDAY;

DateTimeFormatter formatter = DateTimeFormatter
 .ofLocalizedDate(FormatStyle.LONG)
 .withLocale(Locale.FRANCE);
LocalDate date = LocalDate.parse("14 juillet 2014", formatter);

assert date.getDayOfMonth() == 14;
assert date.getMonth() == Month.JULY;
assert date.getYear() == 2014;

LocalDateTime
#

Et voilà une date avec des heures mais toujours sans timezone. L’API reste toujours très similaire aux Local* précédents.

LocalDateTime time = LocalDateTime.of(2014, Month.DECEMBER, 25, 12, 10);
assert time.get(ChronoField.YEAR) == 2014;

time.format(DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm")); // 25/12/2014 12:10

ZonedDateTime
#

La version ultime avec une timezone en plus.

ZonedDateTime today = ZonedDateTime.now(ZoneId.of("Europe/Paris"));
System.out.println(today.format(DateTimeFormatter.ISO_ZONED_DATE_TIME)); 

// 2014-04-21T20:26:53.275+02:00[Europe/Paris]

ZoneId
#

Cette classe représente les timezone manipulables dans l’API.

ZoneId.getAvailableZoneIds();
// [Asia/Aden, America/Cuiaba, Etc/GMT+9, Etc/GMT+8, Africa/Nairobi, America/Marigot...

ZoneId paris = ZoneId.of("Europe/Paris");
paris.getDisplayName(TextStyle.FULL, Locale.FRENCH); // Heure d'Europe centrale
paris.getDisplayName(TextStyle.SHORT, Locale.FRENCH); // CET

Instant
#

Représente un instant au cours du temps.

Instant.parse("2007-12-03T10:15:30.00Z");

On peut récupérer cet objet un peu partout depuis l’API, par exemple

Instant now = LocalDateTime.now().atZone(ZoneId.systemDefault()).toInstant();
// 2014-04-21T19:27:26.759Z

Et il permet de créer un bon vieux java.util.Date pour la compatibilité.

Date.from(now)

Clock
#

Permet l’accès à l’Instant courant.

Instant now = Clock.system(ZoneId.of("Europe/Paris")).instant();
// 2014-04-21T19:36:37.786Z

long millis = Clock.systemDefaultZone().millis();
// 1398109144935

Duration
#

Représente une quantité de temps comme 42 secondes.

Duration twentySeconds = Duration.parse("PT20S");
assert twentySeconds.getSeconds() == 20;

Duration oneMinuteTwentySeconds = Duration.ofMinutes(1).plus(twentySeconds);
assert oneMinuteTwentySeconds.getSeconds() == 80;

LocalTime time1 = LocalTime.of(21, 30, 17);
LocalTime time2 = LocalTime.of(22, 40, 37);
Duration duration = Duration.between(time1, time2); // PT1H10M20S
assert duration.get(ChronoUnit.SECONDS) == 3600 + 600 + 20; 

Du sucre
#

StringJoiner
#

On peut enfin concaténer des String séparées par un délimiteur sans utiliser de librairies.

String join = new StringJoiner(",")
 .add("a")
 .add("b")
 .add("c")
 .toString();
assert join.equals("a,b,c");

String join = String.join(",", asList("a", "b", "c"));
assert join.equals("a,b,c");

Calendar.Builder
#

La mise en place du pattern Builder pour la classe Calendar.
Des exemples sont disponibles dans l’article http://marxsoftware.blogspot.fr/2013/05/jdk-8-calendar-builder.html.

Base64
#

Plus besoin non plus d’utiliser une librairie pour encoder des données en Base64.

Base64.getEncoder().encode("JC".getBytes()); //SkM=

Annotations
#

Les annotations peuvent être déclarées sur les utilisations des types.

Instantiation d’une classe :

new @Interned MyObject();

Cast :

myString = (@NonNull String) str;

Implémentation d’une interface :

class UnmodifiableList<T> implements
 @Readonly List<@Readonly T> { ... }

Déclaration des Exceptions:

void monitorTemperature() throws
 @Critical TemperatureException { ... }

Java 8 introduit la possibilité de rendre une annotation @Repeatable.

Vous avez déjà certainement vu le schéma d’utilisation suivant :

une annotation d’un certain type, au hasard @JoinColumn,
une seconde prenant comme paramètre un tableau d’éléments du premier type, @JoinColumns.

Et on écrivait ensuite

@JoinColumns({
 @JoinColumn(name="ADDR_ID", referencedColumnName="ID"),
 @JoinColumn(name="ADDR_ZIP", referencedColumnName="ZIP")
})
public Address getAddress() { return address; }

On peut maintenant se contenter de

@JoinColumn(name="ADDR_ID", referencedColumnName="ID"),
@JoinColumn(name="ADDR_ZIP", referencedColumnName="ZIP")
public Address getAddress() { return address; }


si l'annotation `@JoinColumn` est annotée avec `@Repeatable(JoinColumns.class)`.

Création
#

Il faut continuer de créer deux types.

public @interface Descriptions {
 Description[] value();
}

@Repeatable(Descriptions.class)
public @interface Description {
 String value();
}

@Description pourra être répétée dans utiliser @Descriptions.

@Description("toto")
@Description("tata")
public class Repeat {}

En fait c’est le compilateur qui utilisera @Descriptions de manière transparente pour l’utilisateur.

Lecture
#

Description[] byType = Repeat.class.getAnnotationsByType(Description.class);
assert byType.length == 2;

Description withoutType = Repeat.class.getAnnotation(Description.class);
assert withoutType == null;

Descriptions byContainer = Repeat.class.getAnnotation(Descriptions.class);
assert byContainer != null;
assert byContainer.value().length == 2;

On voit qu’il faut utiliser Class#getAnnotationsByType pour lire une annotation @Repeatable et que le compilateur a bien ajouté une annotation @Descriptions pour englober les @Description.

Nashorn
#

C’est un moteur Javascript executé au sein de la JVM ! Jusque là était disponible Rhino mais Nashorn est une nouvelle implémentation basée sur invokedynamic.

Il est possible d’interpréter du js en ligne de commande avec l’utilitaire jjs disponible dans le jdk.

jjs 
jjs> print("hello");
hello

Mais on peut surtout embarquer le moteur dans ses programmes Java.

ScriptEngineManager engineManager = new ScriptEngineManager();
ScriptEngine engine = engineManager.getEngineByName("nashorn");
engine.eval("function sum(a, b) { return a + b; }");

assert (int) engine.eval("sum(1, 2);") == 3;

Il existe de nombreuses possibilités d’intéraction entre votre code Java et le js évalué. L’article Oracle Nashorn: A next-generation JavaScript engine for the JVM présente toutes ces fonctionalités.

jdeps
#

Un analyseur de dépendances fait son apparition dans les outils du JDK.

jdeps -v Examples.class 
Examples.class -> /Library/Java/JavaVirtualMachines/jdk1.8.0_05.jdk/Contents/Home/jre/lib/rt.jar
 fr.jcgay.example.java.Strings.Examples -> java.lang.AssertionError
 fr.jcgay.example.java.Strings.Examples -> java.lang.CharSequence
 fr.jcgay.example.java.Strings.Examples -> java.lang.Class
 fr.jcgay.example.java.Strings.Examples -> java.lang.Iterable
 fr.jcgay.example.java.Strings.Examples -> java.lang.Object
 fr.jcgay.example.java.Strings.Examples -> java.lang.String
 fr.jcgay.example.java.Strings.Examples -> java.util.Arrays
 fr.jcgay.example.java.Strings.Examples -> java.util.List
 fr.jcgay.example.java.Strings.Examples -> java.util.StringJoiner

Direction l’article http://marxsoftware.blogspot.fr/2014/03/jdeps.html pour en savoir plus.

Profils
#

Des sous-ensembles de l’API ont été définis et permettent de réduire la taille de la JVM : guide.

Javadoc
#

La section “Method Summary” a évoluée légèrement en regroupant maintenant les méthodes par type (Exemple).

Javadoc method summary

Un outil de validation a fait son apparition, doclint, malheureusement activé par défaut. Il y a peu de chance que votre documentation soit valide… Tout est très bien expliqué ici

Metaspace
#

La suppression de la Permanent Generation (PermGen) laisse place au Metaspace.
Java 8 from PermGen to Metaspace
Metaspace in Java 8

Sources, pour aller plus loin
#

Understanding Method References
Java 8 tutorial
10 features in Java 8 you haven’t heard of
Annotations Basics
50 nouvelles choses que l’on peut faire avec Java 8
Java time
Java 8 features

Java on Jean-Christophe Gay

Ecrire une migration Liquibase en Java

Implémenter un CustomChange #

Configurer son changeset #

A la découverte de Java 8

Default methods sur les Interfaces #

Expressions Lambda #

Accès variable locale #

Membre et variable static #

Functional Interfaces #

Lambda #

Function, Predicate, etc #

Function #

BiFunction #

UnaryOperator #

BinaryOperator #

Predicate #

BiPredicate #

Supplier #

Consumer #

Comparator #

A retenir #

Surcharge de méthode #

Références de méthodes #

Fonctionnement #

statique #

instance #

instance arbitraire #

Optional #

Stream #

forEach #

filter #

sorted #

map #

allMatch, anyMatch, noneMatch #

count #

sum #

reduce #

collect #

concat #

findFirst, findAny #

flatMap #

limit, skip #

min, max #

peek #

Parallel Stream #

Map #

putIfAbsent #

forEach #

computeIf #

compute #

computeIfAbsent #

computeIfPresent #

remove #

getOrDefault #

merge #

replace, replaceAll #

Date #

LocalTime #

LocalDate #

LocalDateTime #

ZonedDateTime #

ZoneId #

Instant #

Clock #

Duration #

Du sucre #

StringJoiner #

Calendar.Builder #

Base64 #

Annotations #

Création #

Lecture #

Nashorn #

jdeps #

Profils #

Javadoc #

Metaspace #

Sources, pour aller plus loin #

Implémenter un CustomChange
#

Configurer son changeset
#

Default methods sur les Interfaces
#

Expressions Lambda
#

Accès variable locale
#

Membre et variable static
#

Functional Interfaces
#

Lambda
#

Function, Predicate, etc
#

Function
#

BiFunction
#

UnaryOperator
#

BinaryOperator
#

Predicate
#

BiPredicate
#

Supplier
#

Consumer
#

Comparator
#

A retenir
#

Surcharge de méthode
#

Références de méthodes
#

Fonctionnement
#

statique
#

instance
#

instance arbitraire
#

Optional
#

Stream
#

forEach
#

filter
#

sorted
#

map
#

allMatch, anyMatch, noneMatch
#

count
#

sum
#

reduce
#

collect
#

concat
#

findFirst, findAny
#

flatMap
#

limit, skip
#

min, max
#

peek
#

Parallel Stream
#

Map
#

putIfAbsent
#

forEach
#

computeIf
#

compute
#

computeIfAbsent
#

computeIfPresent
#

remove
#

getOrDefault
#

merge
#

replace, replaceAll
#

Date
#

LocalTime
#

LocalDate
#

LocalDateTime
#

ZonedDateTime
#

ZoneId
#

Instant
#

Clock
#

Duration
#

Du sucre
#

StringJoiner
#

Calendar.Builder
#

Base64
#

Annotations
#

Création
#

Lecture
#

Nashorn
#

jdeps
#

Profils
#

Javadoc
#

Metaspace
#

Sources, pour aller plus loin
#