Les quelques améliorations apportées par Java 9 pour les développeurs

plus de 4 an(s)

Description

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 

https://www.youtube.com/watch?v=Yacu1yUktjY