Menu

Principales fonctionnalités de Java 8 avec des exemples de code

  • Principal
  • Autre
  • Principales fonctionnalités de Java 8 avec des exemples de code

prominent java 8 features with code examples

Essayez Notre Instrument Pour Éliminer Les Problèmes

Une liste complète et une explication de toutes les fonctionnalités importantes introduites dans la version Java 8 avec des exemples:

La version Java 8 d'Oracle était une version révolutionnaire de la plate-forme de développement n ° 1 au monde. Il comprenait une énorme mise à niveau du modèle de programmation Java dans son ensemble, ainsi que l'évolution de la JVM, du langage Java et des bibliothèques de manière coordonnée.

Cette version comprenait plusieurs fonctionnalités pour la facilité d'utilisation, la productivité, l'amélioration de la programmation Polyglot, la sécurité et l'amélioration globale des performances.

Fonctionnalités Java 8

Ce que vous apprendrez:

Fonctionnalités ajoutées à la version Java 8

Parmi les changements majeurs, voici les fonctionnalités notables qui ont été ajoutées à cette version.

  • Interfaces fonctionnelles et expressions Lambda
  • Méthode forEach () dans l'interface Iterable
  • Classe facultative,
  • méthodes par défaut et statiques dans les interfaces
  • Références de méthode
  • API Java Stream pour les opérations de données en masse sur les collections
  • API Java Date Time
  • Améliorations de l'API de collecte
  • Améliorations de l'API de concurrence
  • Améliorations de Java IO
  • Moteur JavaScript Rhinoceros
  • Décodage encodage base64
  • Diverses améliorations de l'API Core

Dans ce didacticiel, nous discuterons brièvement de chacune de ces fonctionnalités et tenterons d'expliquer chacune d'elles à l'aide d'exemples simples et faciles.

Interfaces fonctionnelles et expressions Lambda

Java 8 introduit une annotation connue sous le nom de @FunctionalInterface qui est généralement destinée aux erreurs au niveau du compilateur. Il est généralement utilisé lorsque l'interface que vous utilisez viole les contrats d'interface fonctionnelle.

Vous pouvez également appeler une interface fonctionnelle en tant qu'interface SAM ou interface de méthode abstraite unique. Une interface fonctionnelle autorise exactement une «méthode abstraite» comme membre.

Ci-dessous, un exemple d'interface fonctionnelle:

@FunctionalInterface public interface MyFirstFunctionalInterface { public void firstWork(); }

Vous pouvez omettre l'annotation, @FunctionalInterface et votre interface fonctionnelle sera toujours valide. Nous utilisons cette annotation uniquement pour informer le compilateur que l'interface aura une seule méthode abstraite.

Noter: Par définition, les méthodes par défaut sont non abstraites et vous pouvez ajouter autant de méthodes par défaut dans l'interface fonctionnelle que vous le souhaitez.

Deuxièmement, si une interface a une méthode abstraite qui remplace l’une des méthodes publiques de «java.lang.object», elle n’est pas considérée comme la méthode abstraite de l’interface.

Voici un exemple d'interface fonctionnelle valide.

@FunctionalInterface public interface FunctionalInterface_one { public void firstInt_method(); @Override public String toString(); //Overridden from Object class @Override public boolean equals(Object obj); //Overridden from Object class }

Une expression (ou fonction) Lambda peut être définie comme une fonction anonyme, (une fonction sans nom et sans identifiant). Les expressions Lambda sont définies exactement à l'endroit où elles sont nécessaires, généralement en tant que paramètre d'une autre fonction.

Dans une perspective différente, les expressions Lambda expriment des instances de Interfaces fonctionnelles (décrit ci-dessus). Les expressions Lambda implémentent la seule fonction abstraite présente dans l'interface fonctionnelle et implémentent ainsi des interfaces fonctionnelles.

La syntaxe de base d'une expression Lambda est:

le meilleur téléchargeur mp3 pour android

syntaxe d

Un exemple de base de l'expression Lambda est:

exemple d

L'expression ci-dessus prend deux paramètres x et y et renvoie sa somme x + y. En fonction du type de données x et y, la méthode peut être utilisée plusieurs fois à divers endroits. Ainsi, les paramètres x et y correspondront à int ou Integer et string, et en fonction du contexte, il ajoutera deux entiers (lorsque les paramètres sont int) ou concatteront les deux chaînes (lorsque les paramètres sont une chaîne).

Implémentons un programme qui présente les expressions Lambda.

interface MyInterface { void abstract_func(int x,int y); default void default_Fun() { System.out.println('This is default method'); } } class Main { public static void main(String args()) { //lambda expression MyInterface fobj = (int x, int y)->System.out.println(x+y); System.out.print('The result = '); fobj.abstract_func(5,5); fobj.default_Fun(); } }

Production:

expression lambda - sortie

Le programme ci-dessus montre l'utilisation de l'expression Lambda pour ajouter des paramètres et affiche leur somme. Ensuite, nous utilisons ceci pour implémenter la méthode abstraite «abstract_fun» que nous avons déclarée dans la définition de l'interface. Le résultat de l'appel de la fonction «abstract_fun» est la somme des deux entiers passés en paramètres lors de l'appel de la fonction.

Nous en apprendrons plus sur les expressions Lambda plus tard dans le didacticiel.

forEach (), méthode dans l'interface Iterable

Java 8 a introduit une méthode «forEach» dans l'interface java.lang.Iterable qui peut itérer sur les éléments de la collection. «ForEach» est une méthode par défaut définie dans l'interface Iterable. Il est utilisé par les classes Collection qui étendent l'interface Iterable pour itérer des éléments.

La méthode «forEach» prend l'interface fonctionnelle comme un paramètre unique, c'est-à-dire que vous pouvez passer l'expression Lambda en tant qu'argument.

Exemple de la méthode forEach ().

importjava.util.ArrayList; importjava.util.List; public class Main { public static void main(String() args) { List subList = new ArrayList(); subList.add('Maths'); subList.add('English'); subList.add('French'); subList.add('Sanskrit'); subList.add('Abacus'); System.out.println('------------Subject List--------------'); subList.forEach(sub -> System.out.println(sub)); } }

Production:

Sortie de la méthode forEach

Nous avons donc une collection de sujets, c'est-à-dire subList. Nous affichons le contenu de la sous-liste à l'aide de la méthode forEach qui utilise l'expression Lambda pour imprimer chaque élément.

Classe facultative

Java 8 a introduit une classe facultative dans le package «java.util». «Facultatif» est une classe finale publique et est utilisé pour traiter NullPointerException dans l'application Java. En utilisant Facultatif, vous pouvez spécifier un autre code ou des valeurs à exécuter. En utilisant Optional, vous n’avez pas à utiliser trop de vérifications nulles pour éviter l’exception nullPointerException.

Vous pouvez utiliser la classe Optional pour éviter une interruption anormale du programme et empêcher le programme de planter. La classe facultative fournit des méthodes utilisées pour vérifier la présence de valeur pour une variable particulière.

Le programme suivant illustre l'utilisation de la classe facultative.

import java.util.Optional; public class Main{ public static void main(String() args) { String() str = new String(10); OptionalcheckNull = Optional.ofNullable(str(5)); if (checkNull.isPresent()) { String word = str(5).toLowerCase(); System.out.print(str); } else System.out.println('string is null'); } }

Production:

Sortie de classe facultative

Dans ce programme, nous utilisons la propriété «ofNullable» de la classe Optional pour vérifier si la chaîne est nulle. Si tel est le cas, le message approprié est imprimé à l'utilisateur.

Méthodes par défaut et statiques dans les interfaces

Dans Java 8, vous pouvez ajouter des méthodes dans l'interface qui ne sont pas abstraites, c'est-à-dire que vous pouvez avoir des interfaces avec l'implémentation de méthode. Vous pouvez utiliser le mot clé Default et Static pour créer des interfaces avec l'implémentation de méthode. Les méthodes par défaut activent principalement la fonctionnalité d'expression Lambda.

En utilisant les méthodes par défaut, vous pouvez ajouter de nouvelles fonctionnalités à vos interfaces dans vos bibliothèques. Cela garantira que le code écrit pour les anciennes versions est compatible avec ces interfaces (compatibilité binaire).

Voyons la méthode par défaut avec un exemple:

import java.util.Optional; interface interface_default { default void default_method(){ System.out.println('I am default method of interface'); } } class derived_class implements interface_default{ } class Main{ public static void main(String() args){ derived_class obj1 = new derived_class(); obj1.default_method(); } }

Production:

Méthode par défaut - sortie

webservices en java interview questions et réponses

Nous avons une interface nommée «interface_default» avec la méthode default_method () avec une implémentation par défaut. Ensuite, nous définissons une classe «dérivée_classe» qui implémente l'interface «interface_default».

Notez que nous n'avons implémenté aucune méthode d'interface dans cette classe. Puis dans la fonction principale, nous créons un objet de classe «classe_ dérivée» et appelons directement la méthode par défaut de l'interface sans avoir à le définir dans la classe.

Il s'agit de l'utilisation des méthodes par défaut et statiques dans l'interface. Cependant, si une classe souhaite personnaliser la méthode par défaut, vous pouvez fournir sa propre implémentation en remplaçant la méthode.

Références de méthode

La fonctionnalité de référence de méthode introduite dans Java 8 est une notation abrégée permettant aux expressions Lambda d'appeler une méthode d'interface fonctionnelle. Ainsi, chaque fois que vous utilisez une expression Lambda pour faire référence à une méthode, vous pouvez remplacer votre expression Lambda par une référence de méthode.

Exemple de référence de méthode.

import java.util.Optional; interface interface_default { void display(); } class derived_class{ public void classMethod(){ System.out.println('Derived class Method'); } } class Main{ public static void main(String() args){ derived_class obj1 = new derived_class(); interface_default ref = obj1::classMethod; ref.display(); } }

Production:

Sortie de référence de méthode

Dans ce programme, nous avons une interface «interface_default» avec une méthode abstraite «display ()». Ensuite, il y a une classe «classe_ dérivée» qui a une méthode publique «classMethod» qui imprime un message.

Dans la fonction principale, nous avons un objet pour la classe, puis nous avons une référence à l'interface qui référence une méthode de classe «classMethod» à travers obj1 (objet de classe). Désormais, lorsque l'affichage de la méthode abstraite est appelé par référence d'interface, le contenu de classMethod est affiché.

API Java Stream pour les opérations de données en masse sur les collections

L'API Stream est un autre changement majeur introduit dans Java 8. L'API Stream est utilisée pour traiter la collection d'objets et prend en charge un type d'itération différent. Un Stream est une séquence d'objets (éléments) qui vous permet de canaliser différentes méthodes pour produire les résultats souhaités.

Un Stream n'est pas une structure de données et il reçoit son entrée de collections, de tableaux ou d'autres canaux. Nous pouvons pipeline diverses opérations intermédiaires à l'aide de Streams et les opérations du terminal retournent le résultat. Nous aborderons l'API de flux plus en détail dans un didacticiel Java distinct.

API Java Date Time

Java 8 introduit une nouvelle API date-heure sous le package java.time.

Les classes les plus importantes parmi elles sont:

  • Local: API date-heure simplifiée sans complexité de gestion des fuseaux horaires.
  • Zoné: API de date-heure spécialisée pour gérer différents fuseaux horaires.

Rendez-vous

La classe de date est devenue obsolète dans Java 8.

Voici les nouvelles classes introduites:

qu'est-ce qu'un fichier bin?
  • La classe LocalDate définit une date. Il n'a aucune représentation pour l'heure ou le fuseau horaire.
  • Le LocalTime classer définit un temps. Il n'a aucune représentation pour la date ou le fuseau horaire.
  • La classe LocalDateTime définit une date-heure. Il n'a aucune représentation d'un fuseau horaire.

Pour inclure des informations de fuseau horaire avec la fonctionnalité de date, vous pouvez utiliser Lambda qui fournit 3 classes, à savoir OffsetDate, OffsetTime et OffsetDateTime. Ici, le décalage du fuseau horaire est représenté en utilisant une autre classe - «ZoneId». Nous couvrirons ce sujet en détail dans les dernières parties de cette série Java.

Moteur JavaScript Rhinoceros

Java 8 a introduit un moteur beaucoup amélioré pour JavaScript, c'est-à-dire Nashorn, qui remplace le Rhino existant. Nashorn compile directement le code en mémoire, puis transmet le bytecode à JVM, améliorant ainsi les performances de 10 fois.

Nashorn introduit un nouvel outil de ligne de commande - jjs qui exécute le code JavaScript sur la console.

Créons un fichier JavaScript «sample.js» contenant le code suivant.

print (‘Hello, World!!’);

Donnez la commande suivante dans la console:

C: Java jjs sample.js

Production: Bonjour le monde!!

Nous pouvons également exécuter des programmes JavaScript en mode interactif et également fournir des arguments aux programmes.

Décodage encodage base64

Dans Java 8, il existe un encodage et un décodage intégrés pour l'encodage Base64. La classe pour l'encodage Base64 est java.util.Base64.

Cette classe fournit trois encodages et décodeurs Base64:

  • De base: En cela, la sortie est mappée à un jeu de caractères entre A-Za-z0-9 + /. Aucun saut de ligne n'est ajouté à la sortie par le codeur et le décodeur rejette tout caractère autre que celui ci-dessus.
  • URL: Ici, la sortie est l'URL et le nom de fichier sécurisé est mappé au jeu de caractères entre A-Za-z0-9 + /.
  • MIME: Dans ce type d'encodeur, la sortie est mappée à un format compatible MIME.

Améliorations de l'API de collecte

Java 8 a ajouté les nouvelles méthodes suivantes à l'API Collection:

  • forEachRemaining (Action du consommateur): Il s'agit d'une méthode par défaut et elle est destinée à l'itérateur. Il exécute «l'action» pour chacun des éléments restants jusqu'à ce que tous les éléments soient traités ou «action» lève une exception.
  • La méthode par défaut pour la collection removeIf (Predicate filter): Cela supprime tous les éléments de la collection qui satisfont le «filtre» donné.
  • Spliterator (): Il s'agit d'une méthode de collecte et renvoie une instance de spliterator que vous pouvez utiliser pour parcourir les éléments de manière séquentielle ou parallèle.
  • La collection de cartes a les méthodes replaceAll (), compute () et merge ().
  • La classe HashMap avec des collisions de clés a été améliorée pour améliorer les performances.

Modifications / améliorations de l'API de concurrence

Voici les améliorations importantes de l'API simultanée:

  • ConcurrentHashMap est amélioré avec les méthodes suivantes:
    1. calculer (),
    2. pour chaque (),
    3. forEachEntry (),
    4. forEachKey (),
    5. forEachValue (),
    6. aller (),
    7. réduire () et
    8. chercher ()
  • La méthode «newWorkStealingPool ()» pour les exécuteurs crée un pool de threads voleur de travail. Il utilise les processeurs disponibles comme niveau de parallélisme cible.
  • La méthode «completableFuture» est celle que nous pouvons compléter explicitement (en définissant sa valeur et son statut).

Améliorations d'E / S Java

Les améliorations d'E / S effectuées dans Java 8 incluent:

  • Files.list (répertoire du chemin): Cela renvoie un flux rempli par jlazily, dont chaque élément est l'entrée dans le répertoire.
  • Files.lines (chemin d'accès): Lit toutes les lignes d'un flux.
  • Files.find (): Recherchez des fichiers dans l'arborescence de fichiers enracinés dans un fichier de départ donné et renvoie un flux rempli par un chemin.
  • BufferedReader.lines (): Renvoie un flux avec chaque élément comme les lignes lues à partir de BufferedReader.

Améliorations diverses de l'API principale

Nous avons les diverses améliorations de l'API suivantes:

  • Méthode statique withInitial (Fournisseur fournisseur) de ThreadLocal pour créer facilement une instance.
  • L'interface «Comparateur» est étendue avec les méthodes par défaut et statiques pour l'ordre inverse de l'ordre naturel, etc.
  • Les classes wrapper Integer, Long et Double ont des méthodes min (), max () et sum ().
  • La classe booléenne est améliorée avec les méthodes logicAnd (), logicalOr () et logicalXor ().
  • Plusieurs méthodes utilitaires sont introduites dans la classe Math.
  • Le pont JDBC-ODBC est supprimé.
  • L'espace mémoire PermGen est supprimé.

Conclusion

Dans ce didacticiel, nous avons présenté les principales fonctionnalités ajoutées à la version Java 8. Comme Java 8 est une version majeure de Java, il est important que vous connaissiez toutes les fonctionnalités et améliorations apportées dans le cadre de cette version.

Bien que la dernière version de Java soit 13, c'est toujours une bonne idée de se familiariser avec les fonctionnalités de Java 8. Toutes les fonctionnalités abordées dans ce didacticiel sont toujours présentes dans la dernière version de Java et nous les aborderons individuellement plus tard dans cette série.

Nous espérons que ce didacticiel vous a aidé à découvrir diverses fonctionnalités de Java 8 !!

lecture recommandée

^