[JAVA] Principes de base de l'API Stream

introduction

-Affiche les méthodes typiques d'API Stream et des exemples de codage de base -L'idée, les exemples d'application et les techniques de StreamAPI seront délégués à d'autres entrées, et nous essaierons de les écrire le plus simplement possible ici. -Stream est généralement écrit en donnant une expression lambda ou une référence à une méthode, mais osez déclarer une interface fonctionnelle.

Qu'est-ce que l'API Stream?

-API pour gérer un ensemble de données ajouté dans SE8. L'objectif principal est de prendre en charge le traitement parallèle. L'utilisation de l'API Stream facilite le passage du traitement séquentiel au traitement parallèle.

-L'interface sous le package java.util.stream, qui est différente du flux utilisé dans le package java.io.

-Le package java.util.stream est basé sur l'interface BaseStream et se compose d'une interface Stream pour gérer les types de référence et de trois interfaces pour gérer les types primitifs.

-Stream est généré sur la base d'un ensemble de données tel que List ou Map, et le résultat est obtenu en exécutant 0 ou plusieurs opérations intermédiaires et 1 opération de terminaison.

Plus de détails

Package Java (tm) Platform Standard Edition 8 java.util.stream Introduction à Java Stream API-Basic Résumé approximatif du flux Java8

produire

Type de référence Stream

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
Stream<Integer> stream = list.stream();

Type primitif Stream

IntStream intStream = IntStream.of(1, 2, 3, 4, 5);

À partir du tableau

int[] array = { 1, 2, 3, 4, 5 };
IntStream intStream = Arrays.stream(array);

Spécifiez la plage

IntStream intStream = IntStream.range(1, 5);

À partir du fichier

Path path = Paths.get("D:\\hoge.txt");
Stream<String> fileStream = Files.lines(path)

L'opération Stream la plus simple

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
Stream<Integer> stream = list.stream();
stream.forEach(System.out::println);

Génère un flux de type entier et exécute le traitement de sortie standard avec 0 opération intermédiaire et 1 opération de terminaison. forEach est une opération de terminaison. L'opération de terminaison sera décrite plus loin. Fondamentalement, cela est utilisé en combinaison avec un nombre quelconque de diverses opérations intermédiaires et l'une des mêmes diverses opérations de terminaison.

Plus de détails

Essayez de diffuser du texte vers l'API Java 8 Stream (génération)

Fonctionnement intermédiaire

filtration

Stream<String> stream = Stream.of("A", "B", "A", "B", "B", "A");
Predicate<String> isA = "A"::equals;
stream.filter(isA).forEach(System.out::println);

Image de l'amincissement Faux avec le type de prédicat isHogeHoge entre les deux. Predicate est une interface fonctionnelle. L'interface fonctionnelle est la suivante. Interface fonctionnelle de base compréhensible en 3 minutes

cartographie

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
Function<Integer, Integer> toDouble = param -> param * 2;
stream.map(toDouble).forEach(System.out::println);

Renvoie un Stream avec la valeur correspondante, en utilisant chaque élément du Stream comme clé. En bref, c'est comme un traitement de conversion. L'exemple a utilisé Function pour plus de clarté, mais dans ce cas, l'opérateur unaire est intelligent. L'expression lambda est la suivante. Résumé de l'extension de grammaire Java8 Lambda Jusqu'à ce que l'implémentation de l'interface devienne lambda

Trier

Stream<Integer> stream = Stream.of(3, 2, 1, 5, 4);
Comparator<Integer> comparator = Comparator.reverseOrder();
stream.sorted(comparator).forEach(System.out::println);

Spécifiez l'ordre en donnant un comparateur à trier. Ce qui suit concerne Comparator. (o1, o2) -> o1 --o2 Arrêtez les sorts! --Comment utiliser Composer dans Java 8

Opération de terminaison

correspondant à

Stream<String> stream = Stream.of("George", "John", "Ringo", "Paul");
Predicate<String> isRingo = "Ringo"::equals;
boolean isMatch = stream.anyMatch(isRingo);

Il existe également des variantes telles que allMatch et noneMatch.

compter

Stream<String> countSt = Stream.of("George", "John", "Ringo", "Paul");
long result = countSt.count();

réduction

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
Stream<Integer> stream = list.stream();
BinaryOperator<Integer> sum = Integer::sum;
Optional<Integer> result = stream.reduce(sum);

Traitez le résultat en une valeur unique, telle que la convolution. La valeur de retour est facultative. Ce qui suit est pour facultatif. Java 8 "Facultatif" ~ Comment gérer null à l'avenir ~

Réduction variable

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
Stream<Integer> stream = list.stream();
List<Integer> resultList = stream.collect(Collectors.toCollection(ArrayList::new));
resultList.forEach(System.out::print);

Traitez dans un ensemble tel que ArrayList.

Plus de détails

J'ai essayé de diffuser le texte vers l'API Java 8 Stream (opération de terminaison) À propos de l'opération de réduction du flux Java8

Traitement parallèle

Stream<String> stream= Stream.of("A", "B", "C", "D", "E", "F");
stream.parallel().forEach(param -> System.out.println(param + " thread-id: " + Thread.currentThread().getId()));

Utilisez simplement pararelStream () au moment de la génération, ou bite parallel () dans l'opération intermédiaire et ce sera un traitement parallèle.

Plus de détails

Maintenant, commençons la programmation parallèle À propos de l'utilisation correcte de Stream et Parallel Stream dans Java 8 Discussion sur stream et parallelStream Quelle est la différence entre les performances de chaque style Java? J'ai comparé les mesures. Flux et boucle

Je ne peux pas écrire de traitement parallèle, donc je n'y toucherai pas en profondeur.