Java 8 - Guide rapide

Java 8 - Présentation

JAVA 8 est une version majeure du développement du langage de programmation JAVA. Sa version initiale a été publiée le 18 mars 2014. Avec la version Java 8, Java a fourni des supports pour la programmation fonctionnelle, un nouveau moteur JavaScript, de nouvelles API pour la manipulation de la date et de l'heure, une nouvelle API de streaming, etc.

Nouvelles fonctionnalités

• Expression lambda − Ajoute une capacité de traitement fonctionnel à Java.

• Références des méthodes − Référencer les fonctions par leurs noms au lieu de les invoquer directement. Utiliser des fonctions comme paramètre.

• Méthode par défaut − Interface pour avoir l'implémentation de la méthode par défaut.

• Nouveaux outils − De nouveaux outils et utilitaires de compilation sont ajoutés comme "jdeps" pour comprendre les dépendances.

• API de flux − Nouvelle API de flux pour faciliter le traitement du pipeline.

• API de date et heure − API date-heure améliorée.

• Facultatif − Accent mis sur les meilleures pratiques pour gérer correctement les valeurs nulles.

• Nashorn, moteur JavaScript − Un moteur basé sur Java pour exécuter du code JavaScript.

Considérez l'extrait de code suivant.

import java.util.Collections;
import java.util.List;
import java.util.ArrayList;
import java.util.Comparator;

public class Java8Tester {

   public static void main(String args[]) {
   
      List<String> names1 = new ArrayList<String>();
      names1.add("Mahesh ");
      names1.add("Suresh ");
      names1.add("Ramesh ");
      names1.add("Naresh ");
      names1.add("Kalpesh ");
		
      List<String> names2 = new ArrayList<String>();
      names2.add("Mahesh ");
      names2.add("Suresh ");
      names2.add("Ramesh ");
      names2.add("Naresh ");
      names2.add("Kalpesh ");
		
      Java8Tester tester = new Java8Tester();
      System.out.println("Sort using Java 7 syntax: ");
		
      tester.sortUsingJava7(names1);
      System.out.println(names1);
      System.out.println("Sort using Java 8 syntax: ");
		
      tester.sortUsingJava8(names2);
      System.out.println(names2);
   }
   
   //sort using java 7
   private void sortUsingJava7(List<String> names) {   
      Collections.sort(names, new Comparator<String>() {
         @Override
         public int compare(String s1, String s2) {
            return s1.compareTo(s2);
         }
      });
   }
   
   //sort using java 8
   private void sortUsingJava8(List<String> names) {
      Collections.sort(names, (s1, s2) -> s1.compareTo(s2));
   }
}

Exécutez le programme pour obtenir le résultat suivant.

Sort using Java 7 syntax:
[ Kalpesh Mahesh Naresh Ramesh Suresh ]
Sort using Java 8 syntax:
[ Kalpesh Mahesh Naresh Ramesh Suresh ]

Ici le sortUsingJava8() La méthode utilise la fonction de tri avec une expression lambda comme paramètre pour obtenir les critères de tri.

Java 8 - Configuration de l'environnement

Configuration de l'environnement local

Si vous souhaitez configurer votre propre environnement pour le langage de programmation Java, cette section vous guide tout au long du processus. Veuillez suivre les étapes ci-dessous pour configurer votre environnement Java.

Java SE peut être téléchargé gratuitement à partir du lien suivant −

https://www.oracle.com/technetwork/java/javase/downloads/index-jsp-138363.html

Vous téléchargez une version basée sur votre système d'exploitation.

Suivez les instructions pour télécharger Java et exécutez le .exe pour installer Java sur votre machine. Une fois que vous avez installé Java sur votre machine, vous devez définir des variables d'environnement pour qu'elles pointent vers les répertoires d'installation corrects.

Configuration du chemin pour Windows 2000/XP

En supposant que vous avez installé Java dans le répertoire c:\Program Files\java\jdk −

• Faites un clic droit sur 'Poste de travail' et sélectionnez 'Propriétés'.

• Cliquez sur le bouton 'Variables d'environnement' sous l'onglet 'Avancé'.

• Maintenant, modifiez la variable 'Path' afin qu'elle contienne également le chemin vers l'exécutable Java. Par exemple, si le chemin est actuellement défini sur 'C:\WINDOWS\SYSTEM32', modifiez votre chemin pour lire 'C:\WINDOWS\SYSTEM32;c:\Program Files\java\jdk\bin'.

Configuration du chemin pour Windows 95/98/ME

En supposant que vous avez installé Java dans le répertoire c:\Program Files\java\jdk −

• Editez le fichier 'C:\autoexec.bat' et ajoutez la ligne suivante à la fin −

  SET PATH=%PATH%;C:\Program Files\java\jdk\bin

Configuration du chemin pour Linux, UNIX, Solaris, FreeBSD

La variable d'environnement PATH doit être définie pour pointer vers l'endroit où les binaires Java ont été installés. Reportez-vous à la documentation de votre shell si vous rencontrez des difficultés pour effectuer cette opération.

Par exemple, si vous utilisez bash comme shell, vous ajouterez la ligne suivante à la fin de votre '.bashrc :export PATH=/path/to/java:$PATH'

Éditeurs Java populaires

Pour écrire des programmes Java, vous avez besoin d'un éditeur de texte. Il existe des IDE encore plus sophistiqués disponibles sur le marché. Mais pour l'instant, vous pouvez envisager l'une des options suivantes −

• Bloc-notes − Sur une machine Windows, vous pouvez utiliser n'importe quel éditeur de texte simple comme le Bloc-notes (recommandé pour ce tutoriel) ou TextPad.

• Netbeans − Il s'agit d'un IDE Java open-source et gratuit. Il peut être téléchargé à partir de https://netbeans.org/index.html.

• Éclipse − Il s'agit également d'un IDE Java développé par la communauté open source Eclipse et peut être téléchargé à partir de https://www.eclipse.org/.

Java 8 - Expressions lambda

Les expressions lambda sont introduites dans Java 8 et sont présentées comme la plus grande fonctionnalité de Java 8. L'expression lambda facilite la programmation fonctionnelle et simplifie beaucoup le développement.

Syntaxe

Une expression lambda est caractérisée par la syntaxe suivante.

parameter -> expression body

Voici les caractéristiques importantes d'une expression lambda.

• Déclaration de type facultative − Inutile de déclarer le type d'un paramètre. Le compilateur peut déduire la même chose à partir de la valeur du paramètre.

• Parenthèse facultative autour du paramètre − Inutile de déclarer un seul paramètre entre parenthèses. Pour plusieurs paramètres, des parenthèses sont requises.

• Accolades facultatives − Pas besoin d'utiliser des accolades dans le corps de l'expression si le corps contient une seule instruction.

• Mot clé de retour facultatif − Le compilateur renvoie automatiquement la valeur si le corps a une seule expression pour renvoyer la valeur. Des accolades sont nécessaires pour indiquer que l'expression renvoie une valeur.

Exemple d'expression Lambda

Créez le programme Java suivant à l'aide de l'éditeur de votre choix dans, par exemple, C:\> JAVA.

Java8Tester.java

public class Java8Tester {

   public static void main(String args[]) {
      Java8Tester tester = new Java8Tester();
		
      //with type declaration
      MathOperation addition = (int a, int b) -> a + b;
		
      //with out type declaration
      MathOperation subtraction = (a, b) -> a - b;
		
      //with return statement along with curly braces
      MathOperation multiplication = (int a, int b) -> { return a * b; };
		
      //without return statement and without curly braces
      MathOperation division = (int a, int b) -> a / b;
		
      System.out.println("10 + 5 = " + tester.operate(10, 5, addition));
      System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction));
      System.out.println("10 x 5 = " + tester.operate(10, 5, multiplication));
      System.out.println("10 / 5 = " + tester.operate(10, 5, division));
		
      //without parenthesis
      GreetingService greetService1 = message ->
      System.out.println("Hello " + message);
		
      //with parenthesis
      GreetingService greetService2 = (message) ->
      System.out.println("Hello " + message);
		
      greetService1.sayMessage("Mahesh");
      greetService2.sayMessage("Suresh");
   }
	
   interface MathOperation {
      int operation(int a, int b);
   }
	
   interface GreetingService {
      void sayMessage(String message);
   }
	
   private int operate(int a, int b, MathOperation mathOperation) {
      return mathOperation.operation(a, b);
   }
}

Vérifier le résultat

Compilez la classe en utilisant javac compilateur comme suit −

C:\JAVA>javac Java8Tester.java

Exécutez maintenant le Java8Tester comme suit −

C:\JAVA>java Java8Tester

Il devrait produire la sortie suivante −

10 + 5 = 15
10 - 5 = 5
10 x 5 = 50
10 / 5 = 2
Hello Mahesh
Hello Suresh

Voici les points importants à prendre en compte dans l'exemple ci-dessus.

• Les expressions lambda sont principalement utilisées pour définir l'implémentation en ligne d'une interface fonctionnelle, c'est-à-dire une interface avec une seule méthode. Dans l'exemple ci-dessus, nous avons utilisé différents types d'expressions lambda pour définir la méthode d'opération de l'interface MathOperation. Ensuite, nous avons défini l'implémentation de sayMessage de GreetingService.

• L'expression Lambda élimine le besoin d'une classe anonyme et donne une capacité de programmation fonctionnelle très simple mais puissante à Java.

Portée

À l'aide de l'expression lambda, vous pouvez faire référence à n'importe quelle variable finale ou à une variable effectivement finale (qui n'est affectée qu'une seule fois). L'expression Lambda génère une erreur de compilation, si une variable se voit attribuer une valeur la deuxième fois.

Exemple de portée

Créez le programme Java suivant à l'aide de l'éditeur de votre choix dans, par exemple, C:\> JAVA.

Java8Tester.java

public class Java8Tester {

   final static String salutation = "Hello! ";
   
   public static void main(String args[]) {
      GreetingService greetService1 = message -> 
      System.out.println(salutation + message);
      greetService1.sayMessage("Mahesh");
   }
	
   interface GreetingService {
      void sayMessage(String message);
   }
}

Vérifier le résultat

Compilez la classe en utilisant javac compilateur comme suit −

C:\JAVA>javac Java8Tester.java

Exécutez maintenant le Java8Tester comme suit −

C:\JAVA>java Java8Tester

Il devrait produire la sortie suivante −

Hello! Mahesh

Java 8 - Références des méthodes

Les références de méthode aident à pointer vers les méthodes par leurs noms. Une référence de méthode est décrite à l'aide du symbole " ::". Une référence de méthode peut être utilisée pour pointer les types de méthodes suivants −

• Méthodes statiques
• Méthodes d'instance
• Constructeurs utilisant un nouvel opérateur (TreeSet ::new)

Exemple de référence de méthode

Créez le programme Java suivant à l'aide de l'éditeur de votre choix dans, par exemple, C:\> JAVA.

Java8Tester.java

import java.util.List;
import java.util.ArrayList;

public class Java8Tester {

   public static void main(String args[]) {
      List names = new ArrayList();
		
      names.add("Mahesh");
      names.add("Suresh");
      names.add("Ramesh");
      names.add("Naresh");
      names.add("Kalpesh");
		
      names.forEach(System.out::println);
   }
}

Ici, nous avons passé la méthode System.out ::println comme référence de méthode statique.

Vérifier le résultat

Compilez la classe en utilisant javac compilateur comme suit −

C:\JAVA>javac Java8Tester.java

Exécutez maintenant le Java8Tester comme suit −

C:\JAVA>java Java8Tester

Il devrait produire la sortie suivante −

Mahesh
Suresh
Ramesh
Naresh
Kalpesh

Java 8 - Interfaces fonctionnelles

Les interfaces fonctionnelles ont une seule fonctionnalité à présenter. Par exemple, une interface Comparable avec une seule méthode « compareTo » est utilisée à des fins de comparaison. Java 8 a défini de nombreuses interfaces fonctionnelles à utiliser de manière intensive dans les expressions lambda. Voici la liste des interfaces fonctionnelles définies dans le package java.util.Function.

Exemple d'interface fonctionnelle

L'interface de prédicat est une interface fonctionnelle avec une méthode test(Object) pour renvoyer une valeur booléenne. Cette interface signifie qu'un objet est testé pour être vrai ou faux.

Créez le programme Java suivant à l'aide de l'éditeur de votre choix dans, par exemple, C:\> JAVA.

Java8Tester.java

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

public class Java8Tester {

   public static void main(String args[]) {
      List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
		
      // Predicate<Integer> predicate = n -> true
      // n is passed as parameter to test method of Predicate interface
      // test method will always return true no matter what value n has.
		
      System.out.println("Print all numbers:");
		
      //pass n as parameter
      eval(list, n->true);
		
      // Predicate<Integer> predicate1 = n -> n%2 == 0
      // n is passed as parameter to test method of Predicate interface
      // test method will return true if n%2 comes to be zero
		
      System.out.println("Print even numbers:");
      eval(list, n-> n%2 == 0 );
		
      // Predicate<Integer> predicate2 = n -> n > 3
      // n is passed as parameter to test method of Predicate interface
      // test method will return true if n is greater than 3.
		
      System.out.println("Print numbers greater than 3:");
      eval(list, n-> n > 3 );
   }
	
   public static void eval(List<Integer> list, Predicate<Integer> predicate) {

      for(Integer n: list) {

         if(predicate.test(n)) {
            System.out.println(n + " ");
         }
      }
   }
}

Ici, nous avons passé l'interface Predicate, qui prend une seule entrée et renvoie un booléen.

Vérifier le résultat

Compilez la classe en utilisant javac compilateur comme suit −

C:\JAVA>javac Java8Tester.java

Exécutez maintenant le Java8Tester comme suit −

C:\JAVA>java Java8Tester

Il devrait produire la sortie suivante −

Print all numbers:
1
2
3
4
5
6
7
8
9
Print even numbers:
2
4
6
8
Print numbers greater than 3:
4
5
6
7
8
9

Java 8 - Méthodes par défaut

Java 8 introduit un nouveau concept d'implémentation de méthode par défaut dans les interfaces. Cette capacité est ajoutée pour la compatibilité descendante afin que les anciennes interfaces puissent être utilisées pour tirer parti de la capacité d'expression lambda de Java 8.

Par exemple, les interfaces "List" ou "Collection" n'ont pas de déclaration de méthode "forEach". Ainsi, l'ajout d'une telle méthode cassera simplement les implémentations du framework de collecte. Java 8 introduit la méthode par défaut afin que l'interface List/Collection puisse avoir une implémentation par défaut de la méthode forEach, et la classe implémentant ces interfaces n'a pas besoin d'implémenter la même chose.

Syntaxe

public interface vehicle {

   default void print() {
      System.out.println("I am a vehicle!");
   }
}

Plusieurs valeurs par défaut

Avec les fonctions par défaut dans les interfaces, il est possible qu'une classe implémente deux interfaces avec les mêmes méthodes par défaut. Le code suivant explique comment cette ambiguïté peut être résolue.

public interface vehicle {

   default void print() {
      System.out.println("I am a vehicle!");
   }
}

public interface fourWheeler {

   default void print() {
      System.out.println("I am a four wheeler!");
   }
}

La première solution consiste à créer une méthode propre qui remplace l'implémentation par défaut.

public class car implements vehicle, fourWheeler {

   public void print() {
      System.out.println("I am a four wheeler car vehicle!");
   }
}

La deuxième solution consiste à appeler la méthode par défaut de l'interface spécifiée à l'aide de super.

public class car implements vehicle, fourWheeler {

   public void print() {
      vehicle.super.print();
   }
}

Méthodes statiques par défaut

Une interface peut également avoir des méthodes d'assistance statiques à partir de Java 8.

public interface vehicle {

   default void print() {
      System.out.println("I am a vehicle!");
   }
	
   static void blowHorn() {
      System.out.println("Blowing horn!!!");
   }
}

Exemple de méthode par défaut

Créez le programme Java suivant à l'aide de l'éditeur de votre choix dans, par exemple, C:\> JAVA.

Java8Tester.java

public class Java8Tester {

   public static void main(String args[]) {
      Vehicle vehicle = new Car();
      vehicle.print();
   }
}

interface Vehicle {

   default void print() {
      System.out.println("I am a vehicle!");
   }
	
   static void blowHorn() {
      System.out.println("Blowing horn!!!");
   }
}

interface FourWheeler {

   default void print() {
      System.out.println("I am a four wheeler!");
   }
}

class Car implements Vehicle, FourWheeler {

   public void print() {
      Vehicle.super.print();
      FourWheeler.super.print();
      Vehicle.blowHorn();
      System.out.println("I am a car!");
   }
}

Vérifier le résultat

Compilez la classe en utilisant javac compilateur comme suit −

C:\JAVA>javac Java8Tester.java

Exécutez maintenant le Java8Tester comme suit −

C:\JAVA>java Java8Tester

Il devrait produire la sortie suivante −

I am a vehicle!
I am a four wheeler!
Blowing horn!!!
I am a car!

Java 8 - Flux

Stream est une nouvelle couche abstraite introduite dans Java 8. En utilisant Stream, vous pouvez traiter les données de manière déclarative similaire aux instructions SQL. Par exemple, considérez l'instruction SQL suivante.

SELECT max(salary), employee_id, employee_name FROM Employee

L'expression SQL ci-dessus renvoie automatiquement les détails de l'employé salarié maximum, sans effectuer de calcul du côté du développeur. En utilisant le framework de collections en Java, un développeur doit utiliser des boucles et effectuer des vérifications répétées. Une autre préoccupation est l'efficacité; comme les processeurs multicœurs sont facilement disponibles, un développeur Java doit écrire un traitement de code parallèle qui peut être assez sujet aux erreurs.

Pour résoudre ces problèmes, Java 8 a introduit le concept de flux qui permet au développeur de traiter les données de manière déclarative et de tirer parti de l'architecture multicœur sans avoir à écrire de code spécifique pour celle-ci.

Qu'est-ce que le flux ?

Stream représente une séquence d'objets à partir d'une source, qui prend en charge les opérations d'agrégation. Voici les caractéristiques d'un Stream −

• Séquence d'éléments − Un flux fournit un ensemble d'éléments d'un type spécifique de manière séquentielle. Un flux obtient/calcule des éléments à la demande. Il ne stocke jamais les éléments.

• Source − Stream prend des collections, des tableaux ou des ressources d'E/S comme source d'entrée.

• Opérations agrégées − Stream prend en charge les opérations agrégées telles que filtrer, mapper, limiter, réduire, rechercher, faire correspondre, etc.

• Pipeline − La plupart des opérations de flux renvoient le flux lui-même afin que leur résultat puisse être pipeliné. Ces opérations sont appelées opérations intermédiaires et leur fonction est de prendre des entrées, de les traiter et de renvoyer la sortie à la cible. La méthode collect() est une opération terminale qui est normalement présente à la fin de l'opération de pipelining pour marquer la fin du flux.

• Itérations automatiques − Les opérations de flux effectuent les itérations en interne sur les éléments source fournis, contrairement aux collections où une itération explicite est requise.

Générer des flux

Avec Java 8, l'interface Collection dispose de deux méthodes pour générer un flux.

• flux() − Renvoie un flux séquentiel en considérant la collection comme sa source.

• flux parallèle() − Renvoie un Stream parallèle en considérant la collection comme sa source.

List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());

pour chaque

Stream a fourni une nouvelle méthode ‘forEach’ pour itérer chaque élément du flux. Le segment de code suivant montre comment imprimer 10 nombres aléatoires à l'aide de forEach.

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

carte

La méthode ‘map’ est utilisée pour mapper chaque élément à son résultat correspondant. Le segment de code suivant imprime des carrés uniques de nombres à l'aide de map.

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);

//get list of unique squares
List<Integer> squaresList = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList());

filtrer

La méthode « filtre » est utilisée pour éliminer des éléments en fonction d'un critère. Le segment de code suivant imprime un nombre de chaînes vides à l'aide du filtre.

List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");

//get count of empty string
int count = strings.stream().filter(string -> string.isEmpty()).count();

limite

La méthode ‘limit’ est utilisée pour réduire la taille du flux. Le segment de code suivant montre comment imprimer 10 nombres aléatoires en utilisant limit.

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

trié

La méthode ‘sorted’ est utilisée pour trier le flux. Le segment de code suivant montre comment imprimer 10 nombres aléatoires dans un ordre trié.

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

Traitement parallèle

parallelStream est l'alternative de stream pour le traitement parallèle. Jetez un œil au segment de code suivant qui imprime un nombre de chaînes vides à l'aide de parallelStream.

List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");

//get count of empty string
long count = strings.parallelStream().filter(string -> string.isEmpty()).count();

Il est très facile de basculer entre les flux séquentiels et parallèles.

Collectionneurs

Les collecteurs permettent de combiner le résultat d'un traitement sur les éléments d'un flux. Les collecteurs peuvent être utilisés pour renvoyer une liste ou une chaîne.

List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());

System.out.println("Filtered List: " + filtered);
String mergedString = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.joining(", "));
System.out.println("Merged String: " + mergedString);

Statistiques

Avec Java 8, des collecteurs de statistiques sont introduits pour calculer toutes les statistiques lorsque le traitement de flux est en cours.

List numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);

IntSummaryStatistics stats = numbers.stream().mapToInt((x) -> x).summaryStatistics();

System.out.println("Highest number in List : " + stats.getMax());
System.out.println("Lowest number in List : " + stats.getMin());
System.out.println("Sum of all numbers : " + stats.getSum());
System.out.println("Average of all numbers : " + stats.getAverage());

Exemple de flux

Créez le programme Java suivant à l'aide de l'éditeur de votre choix dans, par exemple, C:\> JAVA.

Java8Tester.java

import java.util.ArrayList;
import java.util.Arrays;
import java.util.IntSummaryStatistics;
import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;
import java.util.Map;

public class Java8Tester {

   public static void main(String args[]) {
      System.out.println("Using Java 7: ");
		
      // Count empty strings
      List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
      System.out.println("List: " +strings);
      long count = getCountEmptyStringUsingJava7(strings);
		
      System.out.println("Empty Strings: " + count);
      count = getCountLength3UsingJava7(strings);
		
      System.out.println("Strings of length 3: " + count);
		
      //Eliminate empty string
      List<String> filtered = deleteEmptyStringsUsingJava7(strings);
      System.out.println("Filtered List: " + filtered);
		
      //Eliminate empty string and join using comma.
      String mergedString = getMergedStringUsingJava7(strings,", ");
      System.out.println("Merged String: " + mergedString);
      List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
		
      //get list of square of distinct numbers
      List<Integer> squaresList = getSquares(numbers);
      System.out.println("Squares List: " + squaresList);
      List<Integer> integers = Arrays.asList(1,2,13,4,15,6,17,8,19);
		
      System.out.println("List: " +integers);
      System.out.println("Highest number in List : " + getMax(integers));
      System.out.println("Lowest number in List : " + getMin(integers));
      System.out.println("Sum of all numbers : " + getSum(integers));
      System.out.println("Average of all numbers : " + getAverage(integers));
      System.out.println("Random Numbers: ");
		
      //print ten random numbers
      Random random = new Random();
		
      for(int i = 0; i < 10; i++) {
         System.out.println(random.nextInt());
      }
		
      System.out.println("Using Java 8: ");
      System.out.println("List: " +strings);
		
      count = strings.stream().filter(string->string.isEmpty()).count();
      System.out.println("Empty Strings: " + count);
		
      count = strings.stream().filter(string -> string.length() == 3).count();
      System.out.println("Strings of length 3: " + count);
		
      filtered = strings.stream().filter(string ->!string.isEmpty()).collect(Collectors.toList());
      System.out.println("Filtered List: " + filtered);
		
      mergedString = strings.stream().filter(string ->!string.isEmpty()).collect(Collectors.joining(", "));
      System.out.println("Merged String: " + mergedString);
		
      squaresList = numbers.stream().map( i ->i*i).distinct().collect(Collectors.toList());
      System.out.println("Squares List: " + squaresList);
      System.out.println("List: " +integers);
		
      IntSummaryStatistics stats = integers.stream().mapToInt((x) ->x).summaryStatistics();
		
      System.out.println("Highest number in List : " + stats.getMax());
      System.out.println("Lowest number in List : " + stats.getMin());
      System.out.println("Sum of all numbers : " + stats.getSum());
      System.out.println("Average of all numbers : " + stats.getAverage());
      System.out.println("Random Numbers: ");
		
      random.ints().limit(10).sorted().forEach(System.out::println);
		
      //parallel processing
      count = strings.parallelStream().filter(string -> string.isEmpty()).count();
      System.out.println("Empty Strings: " + count);
   }
	
   private static int getCountEmptyStringUsingJava7(List<String> strings) {
      int count = 0;

      for(String string: strings) {
		
         if(string.isEmpty()) {
            count++;
         }
      }
      return count;
   }
	
   private static int getCountLength3UsingJava7(List<String> strings) {
      int count = 0;
		
      for(String string: strings) {
		
         if(string.length() == 3) {
            count++;
         }
      }
      return count;
   }
	
   private static List<String> deleteEmptyStringsUsingJava7(List<String> strings) {
      List<String> filteredList = new ArrayList<String>();
		
      for(String string: strings) {
		
         if(!string.isEmpty()) {
             filteredList.add(string);
         }
      }
      return filteredList;
   }
	
   private static String getMergedStringUsingJava7(List<String> strings, String separator) {
      StringBuilder stringBuilder = new StringBuilder();
		
      for(String string: strings) {
		
         if(!string.isEmpty()) {
            stringBuilder.append(string);
            stringBuilder.append(separator);
         }
      }
      String mergedString = stringBuilder.toString();
      return mergedString.substring(0, mergedString.length()-2);
   }
	
   private static List<Integer> getSquares(List<Integer> numbers) {
      List<Integer> squaresList = new ArrayList<Integer>();
		
      for(Integer number: numbers) {
         Integer square = new Integer(number.intValue() * number.intValue());
			
         if(!squaresList.contains(square)) {
            squaresList.add(square);
         }
      }
      return squaresList;
   }
	
   private static int getMax(List<Integer> numbers) {
      int max = numbers.get(0);
		
      for(int i = 1;i < numbers.size();i++) {
		
         Integer number = numbers.get(i);
			
         if(number.intValue() > max) {
            max = number.intValue();
         }
      }
      return max;
   }
	
   private static int getMin(List<Integer> numbers) {
      int min = numbers.get(0);
		
      for(int i= 1;i < numbers.size();i++) {
         Integer number = numbers.get(i);
		
         if(number.intValue() < min) {
            min = number.intValue();
         }
      }
      return min;
   }
	
   private static int getSum(List numbers) {
      int sum = (int)(numbers.get(0));
		
      for(int i = 1;i < numbers.size();i++) {
         sum += (int)numbers.get(i);
      }
      return sum;
   }
	
   private static int getAverage(List<Integer> numbers) {
      return getSum(numbers) / numbers.size();
   }
}

Vérifier le résultat

Compilez la classe en utilisant javac compilateur comme suit −

C:\JAVA>javac Java8Tester.java

Exécutez maintenant le Java8Tester comme suit −

C:\JAVA>java Java8Tester

Cela devrait produire le résultat suivant −

Using Java 7:
List: [abc, , bc, efg, abcd, , jkl]
Empty Strings: 2
Strings of length 3: 3
Filtered List: [abc, bc, efg, abcd, jkl]
Merged String: abc, bc, efg, abcd, jkl
Squares List: [9, 4, 49, 25]
List: [1, 2, 13, 4, 15, 6, 17, 8, 19]
Highest number in List : 19
Lowest number in List : 1
Sum of all numbers : 85
Average of all numbers : 9
Random Numbers:
-1279735475
903418352
-1133928044
-1571118911
628530462
18407523
-881538250
-718932165
270259229
421676854
Using Java 8:
List: [abc, , bc, efg, abcd, , jkl]
Empty Strings: 2
Strings of length 3: 3
Filtered List: [abc, bc, efg, abcd, jkl]
Merged String: abc, bc, efg, abcd, jkl
Squares List: [9, 4, 49, 25]
List: [1, 2, 13, 4, 15, 6, 17, 8, 19]
Highest number in List : 19
Lowest number in List : 1
Sum of all numbers : 85
Average of all numbers : 9.444444444444445
Random Numbers:
-1009474951
-551240647
-2484714
181614550
933444268
1227850416
1579250773
1627454872
1683033687
1798939493
Empty Strings: 2

Java 8 - Classe facultative

Facultatif est un objet conteneur utilisé pour contenir des objets non nuls. L'objet facultatif est utilisé pour représenter null avec une valeur absente. Cette classe a diverses méthodes utilitaires pour permettre au code de gérer les valeurs comme « disponibles » ou « non disponibles » au lieu de vérifier les valeurs nulles. Il est introduit dans Java 8 et est similaire à ce qu'est Optional dans Guava.

Déclaration de classe

Voici la déclaration pour java.util.Optional classe −

public final class Optional<T> extends Object

Méthode de classe

import java.util.Optional;

public class Java8Tester {

   public static void main(String args[]) {
      Java8Tester java8Tester = new Java8Tester();
      Integer value1 = null;
      Integer value2 = new Integer(10);
		
      //Optional.ofNullable - allows passed parameter to be null.
      Optional<Integer> a = Optional.ofNullable(value1);
		
      //Optional.of - throws NullPointerException if passed parameter is null
      Optional<Integer> b = Optional.of(value2);
      System.out.println(java8Tester.sum(a,b));
   }
	
   public Integer sum(Optional<Integer> a, Optional<Integer> b) {
      //Optional.isPresent - checks the value is present or not
		
      System.out.println("First parameter is present: " + a.isPresent());
      System.out.println("Second parameter is present: " + b.isPresent());
		
      //Optional.orElse - returns the value if present otherwise returns
      //the default value passed.
      Integer value1 = a.orElse(new Integer(0));
		
      //Optional.get - gets the value, value should be present
      Integer value2 = b.get();
      return value1 + value2;
   }
}

C:\JAVA>javac Java8Tester.java

C:\JAVA>java Java8Tester

First parameter is present: false
Second parameter is present: true
10

print('Hello World!');

C:\JAVA>jjs sample.js

Hello World!

C:\JAVA>jjs
jjs> print("Hello, World!")
Hello, World!
jjs> quit()
>>

C:\JAVA> jjs -- a b c
jjs> print('letters: ' +arguments.join(", "))
letters: a, b, c
jjs>

import javax.script.ScriptEngineManager;
import javax.script.ScriptEngine;
import javax.script.ScriptException;

public class Java8Tester {

   public static void main(String args[]) {
      ScriptEngineManager scriptEngineManager = new ScriptEngineManager();
      ScriptEngine nashorn = scriptEngineManager.getEngineByName("nashorn");
		
      String name = "Mahesh";
      Integer result = null;
      
      try {
         nashorn.eval("print('" + name + "')");
         result = (Integer) nashorn.eval("10 + 2");
         
      } catch(ScriptException e) {
         System.out.println("Error executing script: "+ e.getMessage());
      }
      System.out.println(result.toString());
   }
}

C:\JAVA>javac Java8Tester.java

C:\JAVA>java Java8Tester

Mahesh
12

var BigDecimal = Java.type('java.math.BigDecimal');

function calculate(amount, percentage) {

   var result = new BigDecimal(amount).multiply(new BigDecimal(percentage)).divide(
      new BigDecimal("100"), 2, BigDecimal.ROUND_HALF_EVEN);
   
   return result.toPlainString();
}
var result = calculate(568000000000000000023,13.9);
print(result);

C:\JAVA>jjs sample.js

78952000000000000003.20

import java.time.LocalDate;
import java.time.LocalTime;
import java.time.LocalDateTime;
import java.time.Month;

public class Java8Tester {

   public static void main(String args[]) {
      Java8Tester java8tester = new Java8Tester();
      java8tester.testLocalDateTime();
   }
	
   public void testLocalDateTime() {
      // Get the current date and time
      LocalDateTime currentTime = LocalDateTime.now();
      System.out.println("Current DateTime: " + currentTime);
		
      LocalDate date1 = currentTime.toLocalDate();
      System.out.println("date1: " + date1);
		
      Month month = currentTime.getMonth();
      int day = currentTime.getDayOfMonth();
      int seconds = currentTime.getSecond();
		
      System.out.println("Month: " + month +"day: " + day +"seconds: " + seconds);
		
      LocalDateTime date2 = currentTime.withDayOfMonth(10).withYear(2012);
      System.out.println("date2: " + date2);
		
      //12 december 2014
      LocalDate date3 = LocalDate.of(2014, Month.DECEMBER, 12);
      System.out.println("date3: " + date3);
		
      //22 hour 15 minutes
      LocalTime date4 = LocalTime.of(22, 15);
      System.out.println("date4: " + date4);
		
      //parse a string
      LocalTime date5 = LocalTime.parse("20:15:30");
      System.out.println("date5: " + date5);
   }
}

C:\JAVA>javac Java8Tester.java

C:\JAVA>java Java8Tester

Current DateTime: 2014-12-09T11:00:45.457
date1: 2014-12-09
Month: DECEMBERday: 9seconds: 45
date2: 2012-12-10T11:00:45.457
date3: 2014-12-12
date4: 22:15
date5: 20:15:30

import java.time.ZonedDateTime;
import java.time.ZoneId;

public class Java8Tester {

   public static void main(String args[]) {
      Java8Tester java8tester = new Java8Tester();
      java8tester.testZonedDateTime();
   }
	
   public void testZonedDateTime() {
      // Get the current date and time
      ZonedDateTime date1 = ZonedDateTime.parse("2007-12-03T10:15:30+05:30[Asia/Karachi]");
      System.out.println("date1: " + date1);
		
      ZoneId id = ZoneId.of("Europe/Paris");
      System.out.println("ZoneId: " + id);
		
      ZoneId currentZone = ZoneId.systemDefault();
      System.out.println("CurrentZone: " + currentZone);
   }
}

C:\JAVA>javac Java8Tester.java

C:\JAVA>java Java8Tester

date1: 2007-12-03T10:15:30+05:00[Asia/Karachi]
ZoneId: Europe/Paris
CurrentZone: Etc/UTC

import java.time.LocalDate;
import java.time.temporal.ChronoUnit;

public class Java8Tester {

   public static void main(String args[]) {
      Java8Tester java8tester = new Java8Tester();
      java8tester.testChromoUnits();
   }
	
   public void testChromoUnits() {
      //Get the current date
      LocalDate today = LocalDate.now();
      System.out.println("Current date: " + today);
		
      //add 1 week to the current date
      LocalDate nextWeek = today.plus(1, ChronoUnit.WEEKS);
      System.out.println("Next week: " + nextWeek);
		
      //add 1 month to the current date
      LocalDate nextMonth = today.plus(1, ChronoUnit.MONTHS);
      System.out.println("Next month: " + nextMonth);
		
      //add 1 year to the current date
      LocalDate nextYear = today.plus(1, ChronoUnit.YEARS);
      System.out.println("Next year: " + nextYear);
		
      //add 10 years to the current date
      LocalDate nextDecade = today.plus(1, ChronoUnit.DECADES);
      System.out.println("Date after ten year: " + nextDecade);
   }
}

C:\JAVA>javac Java8Tester.java

C:\JAVA>java Java8Tester

Current date: 2014-12-10
Next week: 2014-12-17
Next month: 2015-01-10
Next year: 2015-12-10
Date after ten year: 2024-12-10

import java.time.temporal.ChronoUnit;

import java.time.LocalDate;
import java.time.LocalTime;
import java.time.Duration;
import java.time.Period;

public class Java8Tester {

   public static void main(String args[]) {
      Java8Tester java8tester = new Java8Tester();
      java8tester.testPeriod();
      java8tester.testDuration();
   }
	
   public void testPeriod() {
      //Get the current date
      LocalDate date1 = LocalDate.now();
      System.out.println("Current date: " + date1);
		
      //add 1 month to the current date
      LocalDate date2 = date1.plus(1, ChronoUnit.MONTHS);
      System.out.println("Next month: " + date2);
      
      Period period = Period.between(date2, date1);
      System.out.println("Period: " + period);
   }
	
   public void testDuration() {
      LocalTime time1 = LocalTime.now();
      Duration twoHours = Duration.ofHours(2);
		
      LocalTime time2 = time1.plus(twoHours);
      Duration duration = Duration.between(time1, time2);
		
      System.out.println("Duration: " + duration);
   }
}

C:\JAVA>javac Java8Tester.java

C:\JAVA>java Java8Tester

Current date: 2014-12-10
Next month: 2015-01-10
Period: P-1M
Duration: PT2H

import java.time.LocalDate;
import java.time.temporal.TemporalAdjusters;
import java.time.DayOfWeek;

public class Java8Tester {

   public static void main(String args[]) {
      Java8Tester java8tester = new Java8Tester();
      java8tester.testAdjusters();
   }
	
   public void testAdjusters() {
      //Get the current date
      LocalDate date1 = LocalDate.now();
      System.out.println("Current date: " + date1);
		
      //get the next tuesday
      LocalDate nextTuesday = date1.with(TemporalAdjusters.next(DayOfWeek.TUESDAY));
      System.out.println("Next Tuesday on : " + nextTuesday);
		
      //get the second saturday of next month
      LocalDate firstInYear = LocalDate.of(date1.getYear(),date1.getMonth(), 1);
      LocalDate secondSaturday = firstInYear.with(TemporalAdjusters.nextOrSame(
         DayOfWeek.SATURDAY)).with(TemporalAdjusters.next(DayOfWeek.SATURDAY));
      System.out.println("Second Saturday on : " + secondSaturday);
   }
}

C:\JAVA>javac Java8Tester.java

C:\JAVA>java Java8Tester

Current date: 2014-12-10
Next Tuesday on : 2014-12-16
Second Saturday on : 2014-12-13

import java.time.LocalDateTime;
import java.time.ZonedDateTime;

import java.util.Date;

import java.time.Instant;
import java.time.ZoneId;

public class Java8Tester {

   public static void main(String args[]) {
      Java8Tester java8tester = new Java8Tester();
      java8tester.testBackwardCompatability();
   }
	
   public void testBackwardCompatability() {
      //Get the current date
      Date currentDate = new Date();
      System.out.println("Current date: " + currentDate);
		
      //Get the instant of current date in terms of milliseconds
      Instant now = currentDate.toInstant();
      ZoneId currentZone = ZoneId.systemDefault();
		
      LocalDateTime localDateTime = LocalDateTime.ofInstant(now, currentZone);
      System.out.println("Local date: " + localDateTime);
		
      ZonedDateTime zonedDateTime = ZonedDateTime.ofInstant(now, currentZone);
      System.out.println("Zoned date: " + zonedDateTime);
   }
}

C:\JAVA>javac Java8Tester.java

C:\JAVA>java Java8Tester

Current date: Wed Dec 10 05:44:06 UTC 2014
Local date: 2014-12-10T05:44:06.635
Zoned date: 2014-12-10T05:44:06.635Z[Etc/UTC]

import java.util.Base64;
import java.util.UUID;
import java.io.UnsupportedEncodingException;

public class HelloWorld {

   public static void main(String args[]) {

      try {
		
         // Encode using basic encoder
         String base64encodedString = Base64.getEncoder().encodeToString(
            "TutorialsPoint?java8".getBytes("utf-8"));
         System.out.println("Base64 Encoded String (Basic) :" + base64encodedString);
		
         // Decode
         byte[] base64decodedBytes = Base64.getDecoder().decode(base64encodedString);
		
         System.out.println("Original String: " + new String(base64decodedBytes, "utf-8"));
         base64encodedString = Base64.getUrlEncoder().encodeToString(
            "TutorialsPoint?java8".getBytes("utf-8"));
         System.out.println("Base64 Encoded String (URL) :" + base64encodedString);
		
         StringBuilder stringBuilder = new StringBuilder();
		
         for (int i = 0; i < 10; ++i) {
            stringBuilder.append(UUID.randomUUID().toString());
         }
		
         byte[] mimeBytes = stringBuilder.toString().getBytes("utf-8");
         String mimeEncodedString = Base64.getMimeEncoder().encodeToString(mimeBytes);
         System.out.println("Base64 Encoded String (MIME) :" + mimeEncodedString);

      } catch(UnsupportedEncodingException e) {
         System.out.println("Error :" + e.getMessage());
      }
   }
}

C:\JAVA>javac Java8Tester.java

C:\JAVA>java Java8Tester

Base64 Encoded String (Basic) :VHV0b3JpYWxzUG9pbnQ/amF2YTg=
Original String: TutorialsPoint?java8
Base64 Encoded String (URL) :VHV0b3JpYWxzUG9pbnQ_amF2YTg=
Base64 Encoded String (MIME) :YmU3NWY2ODktNGM5YS00ODlmLWI2MTUtZTVkOTk2YzQ1Njk1Y2EwZTg2OTEtMmRiZC00YTQ1LWJl
NTctMTI1MWUwMTk0ZWQyNDE0NDAwYjgtYTYxOS00NDY5LTllYTctNjc1YzE3YWJhZTk1MTQ2MDQz
NDItOTAyOC00ZWI0LThlOTYtZWU5YzcwNWQyYzVhMTQxMWRjYTMtY2MwNi00MzU0LTg0MTgtNGQ1
MDkwYjdiMzg2ZTY0OWU5MmUtZmNkYS00YWEwLTg0MjQtYThiOTQxNDQ2YzhhNTVhYWExZjItNjU2
Mi00YmM4LTk2ZGYtMDE4YmY5ZDZhMjkwMzM3MWUzNDMtMmQ3MS00MDczLWI0Y2UtMTQxODE0MGU5
YjdmYTVlODUxYzItN2NmOS00N2UyLWIyODQtMThlMWVkYTY4M2Q1YjE3YTMyYmItZjllMS00MTFk
LWJiM2UtM2JhYzUxYzI5OWI4