Tutoriel Java 8
"Java est toujours vivant et les gens commencent à le comprendre."
Bienvenue dans mon introduction à Java 8. Cet article vous guidera étape par étape à travers toutes les nouvelles fonctionnalités de Java 7 à Java 8. Avec des exemples de code simples et rapides, nous pouvons apprendre à utiliser les interfaces par défaut, les références de
méthodes et Annotations répétables . À la fin de l'article, nous nous familiariserons avec l'API Stream.
Pas de bavardage inutile - juste du code et des commentaires ! Avant!
Méthodes par défaut pour les interfaces
Java 8 nous permet d'ajouter des méthodes non abstraites (qui sont implémentées) aux interfaces en ajoutant le
default. Cette fonctionnalité est également connue sous le nom
de méthodes d'extension . Ci-dessous le premier exemple :
interface Formula {
double calculate(int a);
default double sqrt(int a) {
return Math.sqrt(a);
}
}
En plus de la méthode abstraite
calculate, l'interface
Formuladéfinit également une méthode par défaut
sqrt. Les classes qui implémentent cette interface doivent uniquement implémenter le
calculate. La méthode par défaut
sqrtpeut être utilisée immédiatement.
Formula formula = new Formula() {
@Override
public double calculate(int a) {
return sqrt(a * 100);
}
};
formula.calculate(100);
formula.sqrt(16);
L'interface
Formulaest implémentée comme une classe anonyme. Le code est redondant : 6 lignes pour l'implémentation
sqrt(a * 100). Comme nous le verrons dans la section suivante, il existe une façon plus jolie d'implémenter une seule méthode dans Java 8.
Expressions lambda
Commençons par un exemple simple de tri d'une liste de chaînes dans les versions précédentes de Java :
List<String> names = Arrays.asList("peter", "anna", "mike", "xenia");
Collections.sort(names, new Comparator<String>() {
@Override
public int compare(String a, String b) {
return b.compareTo(a);
}
});
La méthode statique
Collections.sortaccepte une liste et un comparateur dans l'ordre dans lequel la liste doit être triée. Vous pouvez toujours créer une classe de comparaison anonyme et la transmettre. Au lieu de créer une classe anonyme, dans Java 8, vous pouvez créer une notation plus courte, une expression lambda.
Collections.sort(names, (String a, String b) -> {
return b.compareTo(a);
});
Comme vous pouvez le constater, le code est beaucoup plus court et plus facile à lire. Mais cela peut être encore plus court :
Collections.sort(names, (String a, String b) -> b.compareTo(a));
Pour un corps comportant une seule ligne, vous pouvez sauter
{}le mot
return. Mais vous pouvez le rendre encore plus court :
Collections.sort(names, (a, b) -> b.compareTo(a));
Le compilateur Java connaît les types d'arguments, vous pouvez donc également les ignorer. Approfondissons les expressions lambda et comprenons comment elles peuvent être utilisées.
Interfaces fonctionnelles
Comment les expressions lambda s’intègrent-elles dans le système de types Java ? Chaque lambda correspond à un type décrit dans l'interface. Par conséquent, une interface fonctionnelle ne doit contenir qu’une seule méthode abstraite. Chaque expression lambda de ce type correspondra à cette méthode abstraite. Étant donné que les méthodes par défaut ne sont pas abstraites, vous êtes libre de créer des méthodes par défaut dans les interfaces fonctionnelles selon vos besoins. Nous pouvons également utiliser des interfaces arbitraires comme expressions lambda s'il n'y a qu'une seule méthode abstraite dans cette interface. Pour répondre à ces exigences, vous devez ajouter
@FucntionalInterfaceune annotation. Le compilateur le sait et lèvera une exception si vous souhaitez fournir plusieurs méthodes abstraites. Exemple:
@FunctionalInterface
interface Converter<F, T> {
T convert(F from);
}
Converter<String, Integer> converter = (from) -> Integer.valueOf(from);
Integer converted = converter.convert("123");
System.out.println(converted);
Gardez à l'esprit que le code sera également compilé si
@FunctionalInterfacel'annotation est omise.
Références de méthodes et de constructeurs
L'exemple ci-dessus peut également être encore plus petit en utilisant des références de méthodes :
Converter<String, Integer> converter = Integer::valueOf;
Integer converted = converter.convert("123");
System.out.println(converted);
Java 8 vous permet de transmettre des références à une méthode ou un constructeur en ajoutant
::. L'exemple ci-dessus montre comment nous pouvons référencer une méthode statique, bien que nous puissions également référencer des méthodes non statiques :
class Something {
String startsWith(String s) {
return String.valueOf(s.charAt(0));
}
}
Something something = new Something();
Converter<String, String> converter = something::startsWith;
String converted = converter.convert("Java");
System.out.println(converted);
Voyons comment
::cela fonctionne avec les constructeurs. Pour commencer, nous allons définir un exemple de classe avec différents constructeurs :
class Person {
String firstName;
String lastName;
Person() {}
Person(String firstName, String lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
}
Ensuite, nous définirons une interface pour créer de nouveaux objets :
interface PersonFactory<P extends Person> {
P create(String firstName, String lastName);
}
Au lieu d'implémenter une usine de création, nous allons tout relier avec
::l'aide du constructeur :
PersonFactory<Person> personFactory = Person::new;
Person person = personFactory.create("Peter", "Parker");
Nous avons créé un lien vers le constructeur via
Person::new. Le compilateur Java sélectionnera automatiquement le constructeur correct qui correspond à la signature de la méthode
PersonFactory.create. ... À suivre. Malheureusement, je n'ai pas trouvé de moyen de sauvegarder un brouillon de l'article, ce qui est vraiment étrange, et le temps de traduction est terminé - je le terminerai donc plus tard. Pour tous ceux qui connaissent et comprennent l’anglais –
Article original . Si vous avez des suggestions pour corriger la traduction, écrivez de toute manière à votre disposition.
Mon compte Github 
GO TO FULL VERSION