Les quelques améliorations apportées par Java 9 pour les développeurs
Java 9 est sortie en septembre 2017, on peut regrouper les améliorations apportées par cette version en 3 groupes
-
Changements et améliorations
-
Des ajouts de fonctionnalités
-
Des avancées pour les versions futures
Dans cet article je vais aborder les améliorations apportées pour les développeurs.
Amélioration des Streams :
Quelques améliorations ont été apportées pour compléter des manquements de java 8 dans le cadre d'utilisation des Streams ...
Méthode takeWhile()
Permet de parcourir une collection en utilisant un prédicat, contrairement à la méthode limit() takeWhile fonctionne comme une porte d'entrée ouverte qui va se fermer dès la condition est validée... après la porte est définitivement fermée.
Méthode dropWhile() :
Permet de parcourir une collection en utilisant un prédicat, contrairement à la méthode skip()
dropWhile() fonctionne comme une porte d’entrée fermée qui va s'ouvrir dès que la condition est validée... après la porte reste définitivement ouverte.
// Exemples :
public class TakeWhile
public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(1, 6, 67, 89 , 45, 81, 100);
System.out.println("limit");
numbers.stream().limit(3).forEach(System.out::println);
System.out.println("takeWhile");
numbers.stream().takeWhile(e -> e < 89 ).forEach(System.out::println);
}
Méthodes iterate()
Permet d'itérer sur une collection, en précisant la valeur de départ, un prédicat, et une fonction d'incrémentation. Le prédicat permet de fixer les limites de l’itération
public static void main(String[] args)
// boucle normal
for (int i = 0; i < 10; i = i + 2) {
System.out.println(i);
// avec java 8, cette itération va s'exécuter jusqu'à l'infini.
Stream.iterate(0, i -> i + 2)
.forEach(e -> System.out.println(" first iterate : " + e));
// avec java 9, on peut utiliser un prédicat pour arrêter l'itération
Stream.iterate(0, i -> i < 10, i -> i + 1)
.forEach(e -> System.out.println(" second iterate : " + e));
}
Méthode OfNullable()
Permet de renvoyer une interface Optionnal lorsque la value est nulle... cette méthode permet d'éviter les NullPointer et éviter d'avoir à écrire du code pour vérifier les nulles et ainsi avoir un code plus concis.
Exemple :
import java.util.stream.Stream;
public class OfNullableSample
public static void main(String[] args) {
//
Stream.ofNullable(10).count();
//
Stream.ofNullable(null).count(); // pas de nullpointer
User user = new User();
System.out.println(" count " + Stream.ofNullable(user.getRoles()).count());
// java 8
if (user.getRoles() != null) {
System.out.println(user.getRoles().size());
else
System.out.println("count java 8 " + 0);
}
}
Amélioration de la classe Optional
Méthode isPresent()
Permet d’utiliser une classe Consumer pour implémenter l'action à exécuter si la valeur est présente.
Méthode ifPresentOrElse(Consumer action, Runnable emptyAction)
Similaire à ifPresent mais permet d’implémenter l'action à exécuter si l'optional est vide.
Méthode or(Supplier supplier)
Permet de s'assurer d'avoir un optional en retour, cette méthode retourne toujours un Optional avec ou sans valeur (plus simple à manupiler que un objet Null).
Méthode stream()
Retourne un Stream vide ou avec un seul élément si l'optional est vide ou non.
public class OptionalSample
public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(1, 6, 67, 89, 45, 81, 100);
Optional<Integer> findFirst = numbers.stream().filter(e -> e == 67).findFirst();
if (findFirst.isPresent()) {
System.out.println("found");
else
System.out.println("Not found");
findFirst.ifPresent(e ->
System.out.println("element " + e);
);
numbers.stream().filter(e -> e == 67).findFirst().ifPresentOrElse(e ->
System.out.println("element " + e);
, () ->
System.out.println("element not found ");
);
//
System.out.println(findFirst.stream());
}
}
Amélioration des collections
Méthode List.of()
Permet de créer de manière concise une liste immuable.
Exemple :
public static void main(String[] args)
// avec java 8
List<Point> pointsWithjava8 = new ArrayList<>();
pointsWithjava8.add(new Point(1, 1));
pointsWithjava8.add(new Point(2, 2));
pointsWithjava8.add(new Point(3, 3));
pointsWithjava8.add(new Point(4, 4));
// liste immuable
pointsWithjava8 = Collections.unmodifiableList(pointsWithjava8);
// with java 9
List<Point> pointsWithjava9 = List.of(new Point(1, 1), new Point(2, 2), new Point(3, 3), new Point(4, 4));
Pour plus d'infos :
https://www.oracle.com/corporate/features/jdk9-new-developer-features.html
