Cela fait 4 mois que j'ai changé de poste en ingénieur sans expérience et a été affecté à l'équipe java. Je suis déjà habitué à java, mais j'utilise l'instruction Extended for pour développer la liste. Je veux m'entendre avec Stream API, alors je l'ai résumé.
Nous prévoyons d'ajouter des méthodes au besoin.
Pour commencer, je pense qu'il est bon d'avoir une impression de "** quelque chose qui permet de faire fonctionner facilement le tableau **". L'évaluation des délais et le traitement asynchrone sont décrits ci-dessous, mais vous n'avez pas besoin de le savoir au début. (Je ne comprends pas grand-chose, donc je veux le penser ..)
Stream peut faire fonctionner des tableaux avec une petite quantité de description et a les fonctions suivantes.
L'API Stream peut effectuer le traitement asynchrone. Le traitement asynchrone, comme son nom l'indique, n'exécute pas une série de processus séquentiellement (synchronisation), mais les exécute en parallèle (asynchrone). Pour un traitement asynchrone avec l'API Stream, utilisez list.parallelStream () ou List.stream (). Parallel () au lieu de l'habituel List.stream ().
Par exemple, s'il existe un processus pour afficher les éléments de liste suivants à l'écran,
List<Integer> demoList = Arrays.asList(1, 2, 3, 4, 5);
Si vous le faites de manière synchrone, la sortie sera dans l'ordre du tableau car elle sera exécutée séquentiellement.
for(Integer i : demoList) {
System.out.print(i);
}
// 12345
Cependant, si vous le faites de manière asynchrone, il sera traité en parallèle, de sorte que la sortie sera différente de l'ordre du tableau.
demoList.stream().parallel().forEach(System.out::print);
// 32415
En outre, en effectuant un traitement asynchrone, le traitement peut être effectué plus rapidement que la rotation de la liste avec For. J'ai en fait mesuré le temps.
//Liste des cibles
List<Integer> demoList = Stream.iterate(1, n -> n + 1).limit(100000).collect(Collectors.toList());
//Pour obtenir le temps avant le traitement
long startTimeFor = System.currentTimeMillis();
//Sortie avec For
for(Integer i : demoList) {
System.out.println(i);;
}
//Obtenez le temps après pour le traitement
long endTimeFor = System.currentTimeMillis();
//Obtenez l'heure avant le traitement du flux
long startTimeStream = System.currentTimeMillis();
//Sortie avec Stream
demoList.parallelStream().forEach(System.out::println);
//Obtenez l'heure après le traitement du flux
long endTimeStream = System.currentTimeMillis();
System.out.println("Temps de traitement pour:" + (endTimeFor - startTimeFor) + " ms");
System.out.println("Temps de traitement Stream:" + (endTimeStream - startTimeStream) + " ms");
Les résultats sont les suivants. Ce n'est pas aussi différent que je m'y attendais, mais le processus ci-dessus était environ 100 ms plus rapide en moyenne.
Temps de traitement pour: 686 ms
Temps de traitement Stream: 573 ms
L'API Stream peut effectuer une évaluation de retard des langages fonctionnels. Qu'est-ce que l'évaluation des retards?
En programmation, les formules sont souvent calculées lorsqu'elles apparaissent, mais retarder l'évaluation consiste à ne pas les calculer jusqu'à ce qu'elles soient réellement nécessaires.
Il est. Dans StreamAPI, les expressions ne sont pas évaluées lors des opérations intermédiaires (carte et filtre) décrites plus loin. Il n'est évalué que lorsque l'opération de terminaison est effectuée. Déplaçons-le et vérifions-le.
//Liste des cibles
List<Integer> demoList = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
//Seuls les nombres pairs sont diffusés. Comme il s'agit d'un processus intermédiaire, il n'a pas encore été évalué.
Stream<Integer> oddListStream = demoList.stream().filter(n -> n % 2 == 0);
//Ajouter un élément à demoList
demoList.add(6);
demoList.add(7);
demoList.add(8);
//Flux de sortie
oddListStream.forEach(System.out::print);
Si vous y pensez normalement, le oddListStream qui génère le Stream doit contenir 2 et 4. Cependant, les opérations intermédiaires de Stream sont différées et ne sont pas évaluées jusqu'à ce que l'opération de terminaison forEach soit appelée. Donc, la sortie est ...
$ 2468
Et, 6,7,8 ajouté à demoList après le traitement de la génération Stream.
À partir de là, nous allons examiner l'opération Stream dans l'ordre de génération → opération intermédiaire → opération de terminaison.
Tout d'abord, créez un Stream qui servira de base à l'exécution des opérations décrites ci-dessous. En plus de List.stream () couramment utilisé, Stream a diverses méthodes telles que l'utilisation d'un constructeur et l'utilisation d'un générateur.
//À partir du type de liste
Stream<Integer> numberStreamFromList = Arrays.asList(8, 1, 4, 2, 9).stream();
// Stream.avec de
Stream<Integer> numberStreamFromStreamOf = Stream.of(8, 1, 4, 2, 9);
//Utilisation du constructeur
Builder<String> builder = Stream.builder();
Stream<String> stringStream = builder.add("hoge").add("fuga").build();
//Flux vide
Stream<String> emptyStream = Stream.empty();
//Avec iterate
Stream<Integer> numberStreamFromIterate = Stream.iterate(1, n -> n * 10).limit(5);
Seule la méthode d'utilisation de l'itération est un peu difficile à comprendre, c'est donc un supplément. La syntaxe de base est la suivante.
Stream.iterate(valeur initiale, valeur initialeが入る変数 ->Traitement des variables).limit(Nombre de répétitions)
La raison de l'application de la limite est que si la limite n'est pas utilisée, elle sera générée indéfiniment.
Vous pouvez facilement faire cette sortie avec iterate.
Dites un nombre à partir de 1 et ne devenez stupide que s'il s'agit d'un multiple de 3 (ressentez les temps ..)
Stream.iterate(1, n -> n + 1).limit(100)
.map(n -> n % 3 == 0 ? "Stupide" : n)
.forEach(System.out::println);
L'opération intermédiaire consiste à effectuer des traitements tels que le filtrage et l'exécution de fonctions pour chaque élément du tableau.
L'opération intermédiaire peut être répétée plusieurs fois. Après filtrage, traiter avec la carte, etc.
Veuillez noter que la valeur de retour de l'opération intermédiaire sera de type stream
Vous pouvez * filtrer * des éléments sous certaines conditions en utilisant filter (). Voici un exemple d'utilisation.
Sortie uniquement des nombres pairs du tableau
//Liste des cibles
List<Integer> numberList = Arrays.asList(8, 1, 4, 2, 9);
//Sortie uniquement même pour déclaration
for (Integer number : numberList) {
if (number % 2 == 0) {
System.out.println(number);
}
}
//Sortie uniquement des nombres pairs Stream
numberList.stream()
.filter(n -> n % 2 == 0)
.forEach(System.out::println);
Double chaque élément du tableau et le produit
List<Integer> numberList = Arrays.asList(8, 1, 4, 2, 9);
//Sortie en doublant chaque élément pour l'instruction
for (Integer number : numberList) {
System.out.println(number * 2);
}
//Double chaque élément pour le flux de sortie
numberList.stream()
.map(n -> n * 2)
.forEach(System.out::println);
Le tri des éléments est facile avec le tri.
List<Integer> numberList = Arrays.asList(8, 1, 4, 2, 9);
List<Integer> sortListAsc = numberList.stream().sorted().collect(Collectors.toList());
List<Integer> sortListDesc = numberList.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());
System.out.println(sortListAsc);
// [1, 2, 4, 8, 9]
System.out.println(sortListDesc);
// [9, 8, 4, 2, 1]
Pour l'opération de terminaison, vous pouvez exécuter la fonction de manière séquentielle à l'aide du flux
Voici un exemple typique.
Vous pouvez utiliser collect pour convertir un Stream en différents types et obtenir le résultat.
Doublez l'élément et recevez le résultat sous forme de tableau
List<Integer> numberList = Arrays.asList(8, 1, 4, 2, 9);
List<Integer> doubleList = numberList.stream()
.map(n -> n * 2)
.collect(Collectors.toList());
System.out.println(doubleList); //[16, 2, 8, 4, 18]
Jugez la valeur et créez une carte appelée [valeur, "paire" ou "impaire"].
List<Integer> numberList = Arrays.asList(8, 1, 4, 2, 9);
Map<Integer, String> demoMap = numberList.stream()
.collect(Collectors.toMap(
n -> n,
s -> s % 2 == 0 ? "Même" : "Impair"));
System.out.println(demoMap); //{1=Impair, 2=Même, 4=Même, 8=Même, 9=Impair}
Sortie standard telle quelle
List<Integer> numberList = Arrays.asList(8, 1, 4, 2, 9);
//Les deux sont les mêmes
numberList.stream().forEach(n -> System.out.println(n));
numberList.stream().forEach(System.out::println);
http://www.task-notes.com/entry/20150518/1431918000 https://qiita.com/nmby/items/52d1b0e2dad5df475737 http://aoking.hatenablog.jp/entry/20110810/1312970979 https://qiita.com/kumazo/items/104fa685da8705b8cfd8#36-flatmap
Recommended Posts