Je n'ai écrit aucun code en java8 sur le terrain, j'ai donc ressenti un sentiment de crise et l'ai appris, donc je vais le résumer ici.
Ceci est un exemple qui convertit le contenu de la liste en nombres et le produit. Tout d'abord, un exemple avant java8.
Pas java8.java
List<String> suuzies = Arrays.asList("1", "2", null, "3");
for (String suuzi : suuzies) {
if (suuzi == null) {
continue;
}
System.out.println(Integer.parseInt(suuzi));
}
// 1 2 3
Vient ensuite java8.
java8.java
List<String> suuzies = Arrays.asList("1", "2", null, "3");
suuzies.stream().filter(s -> Objects.nonNull(s)).map(s -> Integer.parseInt(s))
.forEach(s -> System.out.println(s));
// 1 2 3
Génial! Il tient dans une ligne et améliore la lisibilité! Quand je l'ai vu pour la première fois, je ne l'ai pas compris du tout et j'ai pensé à ce qui améliorerait la lisibilité. Ce sera rafraîchissant à comprendre.
L'ordre de traitement des flux
Considérant que vous pouvez écrire le processus comme s'il était connecté par une flèche comme décrit ci-dessus, Je pense certainement que la lisibilité s'est améliorée. Au niveau du terrain, si et pour souvent rendre le nid chaotique, Cela semble très facile à lire.
À propos, le code java8.java peut également être écrit comme suit.
java8(2).java
List<String> suuzies = Arrays.asList("1", "2", null, "3");
suuzies.stream().filter(Objects::nonNull).map(Integer::parseInt)
.forEach(System.out::println);
// 1 2 3
Il utilise des références de méthode, ce qui rend le code encore plus court, Je vais omettre l'explication ici.
Maintenant que vous comprenez stream, je vais écrire un peu sur les expressions lambda.
L'API Stream fournit plusieurs méthodes utilisées pour le traitement intermédiaire et le traitement final. Par exemple, la méthode de filtrage illustrée ci-dessus ressemble à ceci.
Stream.class
Stream<T> filter(Predicate<? super T> predicate);
J'étais allergique quand je l'ai vu pour la première fois. Il a fermé immédiatement.
Jetons également un œil à (Predicate <? Super T>) dans l'argument de filtre.
Predicate.class
@FunctionalInterface
public interface Predicate<T> {
boolean test(T t);
default Predicate<T> and(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) && other.test(t);
}
default Predicate<T> negate() {
return (t) -> !test(t);
}
default Predicate<T> or(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) || other.test(t);
}
static <T> Predicate<T> isEqual(Object targetRef) {
return (null == targetRef)
? Objects::isNull
: object -> targetRef.equals(object);
}
}
Ceci est une interface fonctionnelle. Une expression lambda est une expression qui peut implémenter une interface fonctionnelle avec une brève description.
À propos, une interface fonctionnelle est une interface dans laquelle une seule méthode abstraite est définie. Il est acceptable d'inclure des méthodes statiques et par défaut autres que des méthodes abstraites, mais elles sont ignorées en tant que condition. La classe Predicate ne cible que le «test booléen (T t)», les autres sont ignorés.
Comme vous pouvez le voir, cette interface prend un argument de type T et renvoie une valeur de retour de type booléen. Répétez la partie filtre du code précédent (java8.java).
java8.java
filter(s -> Objects.nonNull(s))
Il implémente l'argument de filtre de Stream.class. Cette pièce est de type lambda!
Il existe plusieurs autres interfaces fonctionnelles disponibles. Avec la carte utilisée dans java8.class,
Stream.class
<R> Stream<R> map(Function<? super T, ? extends R> mapper);
Regardons également le contenu de l'argument Function.
Function.class
@FunctionalInterface
public interface Function<T, R> {
R apply(T t);
// and more
}
Une méthode qui prend un type T comme argument et renvoie un type R! En d'autres termes, il traite l'argument reçu et le renvoie sous une autre forme!
Répétez la partie map de java8.java plus tôt.
java8.java
map(s -> Integer.parseInt(s))
Vous prenez un caractère comme argument, vous le convertissez en nombre et vous le retournez!
La syntaxe de l'expression lambda ressemble à ceci.
(Argument) -> {Traitement}
C'est une manière d'écrire car il n'y a qu'une seule méthode abstraite ♪ Il y a d'autres consommateurs qui n'ont aucune valeur de retour et des fournisseurs qui n'acceptent aucun argument!
Je pense que l'expression lambda a été faite pour Stream! Au début de l'étude, je me demande s'il existe une interface pour une méthode abstraite. J'ai pensé, mais nous, les développeurs, mettrons en œuvre les éléments préparés dans un style lambda J'ai pensé que ce serait pratique si je l'utilisais!
J'ai encore beaucoup à faire, je vais donc approfondir ma compréhension à partir de maintenant!
Recommended Posts