Pour ceux qui viennent de commencer à apprendre la programmation, y compris le langage Java, et ceux qui l'ont déjà appris, pour examen Cette fois, j'écris pour en savoir plus sur ** Stream API **.
Une fonction introduite à partir de Java8, c'est une API qui permet d'opérer sur les éléments de la collection.
Collecte en continu → Opération intermédiaire (traitement des données) → Opération de terminaison (obtention des données traitées)
Ce sera le flux du traitement.
Puisqu'il est possible de décrire plusieurs opérations intermédiaires de l'API Stream, il est possible de décrire clairement les processus qui semblent compliqués.
Dans certains cas, une interface fonctionnelle est reçue comme argument de chaque méthode, et une expression lambda y est utilisée, mais l'explication y est omise. Veuillez consulter ** À propos de l'expression Lambda **.
Comparons avec un exemple simple comment le gérer.
Tout d'abord, implémentez sans utiliser l'API Stream.
python
List<String> names = Arrays.asList("Ryo Ose", "Samura Kawachi", "Kikuchi", "crête", "Nagano", "Jonouchi");
for (int i = 0; i < names.size(); i++) {
if (names.get(i).length() >= 3) {
if (names.get(i).contains("À l'intérieur")) {
System.out.println(names.get(i)); //Samura Kawachi Jonouchi
}
}
}
Utilisez ensuite l'API `Stream pour implémenter un processus similaire.
Implémentation à l'aide de l'API Stream
List<String> names = Arrays.asList("Ryo Ose", "Samura Kawachi", "Kikuchi", "crête", "Nagano", "Jonouchi");
names.stream()
.filter(name -> name.length() >= 3)
.filter(name -> name.contains("À l'intérieur"))
.forEach(name -> System.out.println(name)); //Samura Kawachi Jonouchi
L'imbrication n'est pas profonde, elle est facile à lire et simple à mettre en œuvre.
Extraire uniquement les éléments qui satisfont aux conditions avec la méthode de filtrage de l'opération intermédiaire, Les éléments sont sortis un par un avec la méthode forEach de l'opération de terminaison.
Plus tôt, j'ai introduit le filtre comme méthode d'opération intermédiaire, mais je présenterai également d'autres méthodes.
1.map
Cette méthode effectue le traitement spécifié pour chaque élément.
méthode de carte
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
numbers.stream()
.map(num -> num * 2) //Double chaque élément
.forEach(num -> System.out.print(num + " ")); // 2 4 6 8 10
2.limit
Cette méthode renvoie uniquement le nombre d'éléments spécifié (maxSize).
méthode limite
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
numbers.stream()
.limit(3) //Sortez seulement 3
.forEach(num -> System.out.print(num + " ")); // 1 2 3
3.distinct
Cette méthode renvoie les éléments sans duplication.
méthode distincte
List<String> names = Arrays.asList("Kubo", "Endo", "rouleau", "Kubo", "Okazaki", "Honda", "rouleau", "Endo");
names.stream()
.distinct() //Les éléments en double sont supprimés et renvoyés
.forEach(name -> System.out.print(name + " ")); //Kubo Endo Vol. Okazaki Honda
4.sorted
Une méthode qui trie les éléments.
méthode triée
List<Integer> numbers = Arrays.asList(1, 5, 3, 2, 4);
numbers.stream()
.sorted() //Trier par ordre croissant
.forEach(num -> System.out.print(num + " ")); // 1 2 3 4 5
Vous pouvez également trier par ordre décroissant en passant la méthode reverseOrder de l'interface Composer comme argument de la méthode triée.
méthode triée
List<Integer> numbers = Arrays.asList(1, 5, 3, 2, 4);
numbers.stream()
.sorted(Comparator.reverseOrder()) //Trier par ordre décroissant
.forEach(num -> System.out.print(num + " ")); // 5 4 3 2 1
Jusqu'à présent, la méthode forEach était utilisée comme méthode d'opération de terminaison, mais nous présenterons également d'autres méthodes.
1.anyMatch
Une méthode qui renvoie un booléen en fonction de la condition. Renvoie true si l'un des éléments correspond à la condition. (Jugement de match partiel)
méthode anyMatch
List<String> fruits = Arrays.asList("banana", "apple", "orange", "pineapple");
boolean result = fruits.stream()
.anyMatch(fruit -> fruit.length() >= 7); //Déterminez s'il y a un élément avec 7 caractères ou plus
System.out.println(result); // true
2.allMatch
Une méthode qui renvoie un booléen en fonction de la condition. Renvoie true si tous les éléments remplissent les conditions. (Tous les matchs correspondent)
méthode allMatch
List<Integer> numbers = Arrays.asList(2, 4, 6, 7, 8, 10);
boolean result = numbers.stream()
.allMatch(num -> num % 2 == 0); //Déterminer si tous les éléments sont pairs
System.out.println(result); // false
3.noneMatch
Une méthode qui renvoie un booléen en fonction de la condition. Renvoie false si l'un des éléments remplit les conditions. (Tous les jugements de non-match)
méthode noneMatch
List<String> names = Arrays.asList("Suzuki", "Matsui", "Noshige", "Ikawa", "Kawasaki", "Shinjo", "Avec Darbish");
boolean result = names.stream()
.noneMatch(name -> name.length() > 4); //Déterminez s'il y a un élément avec 4 caractères ou plus
System.out.println(result); // false
J'ai trouvé que le code source est plus simple et plus facile à lire en utilisant l'API Stream, plutôt que d'écrire les opérations sur les éléments de la collection par moi-même. Cela peut être déroutant au début, mais je veux m'en souvenir avec le style Lambda.
** Stream Oracle Official ** ** [Java] Connaissances acquises en continuant à écrire l'API Stream **
Recommended Posts