Flux simples non simples

Avec chaque nouvelle version de Java, il devient de plus en plus riche. Même si une grande partie de la richesse réside dans les versions antérieures, le langage a continué à s'améliorer tant au niveau de la méthodologie que de la mise en œuvre. Les collections en Java ne font pas exception. Le framework de base des collections est apparu dans J2SE 1.2 et a continué à évoluer, subissant des changements plus agréables que décevants. Avec la sortie du JDK 5, les collections sont devenues plus pratiques, plus rapides et plus faciles à utiliser. Cela a conduit les programmeurs à les exploiter de manière plus intensive. Certains modèles ont été développés pour travailler avec eux, qui sont sans aucun doute efficaces. Mais avec JDK 8, les collections se sont encore améliorées, et elles se sont améliorées grâce aux threads. Évidemment, du fait que la collection peut être représentée sous forme de flux, la méthodologie de travail avec eux changera également. Par conséquent, je souhaite montrer à quel point les solutions familières et compréhensibles avec les collections deviennent encore plus simples.

• Exemple 1. Rien de plus simple
• Exemple 2. Rechercher des valeurs paires dans la liste et les afficher dans la console
• Exemple 3. Comptons combien de mots dans la liste comportent 5 caractères
• Exemple 4. Imprimer des mots uniques
• Exemple 5. Mots longs
• Exemple 6. Mots avec des chiffres
• Exemple 7. Sélection de nombres

Exemple 1. Rien de plus simple

Bien sûr, commençons par le plus simple, parcourons tous les éléments de la collection et affichons tous les éléments.

// создадим и заполним список
   List<Integer> list = new ArrayList<>();
   Collections.addAll(list, 1, 5, 6, 11, 3, 15, 7, 8);
   // а теперь
   // быстрый for по всем elementм, только для коллекций
   for (Integer i:list){
       System.out.println(i);
   }
   //но мы уже живем в JDK 8
   //а значит нужно так
   list.stream().forEach(System.out::println);

Comme vous l'avez remarqué, il existe une nouvelle syntaxe qui, à mon avis en tant que débutant en Java, est beaucoup plus simple. Alors, ce qui est visible dans la nouvelle syntaxe :

берем_список(list).превращаем_в_поток(stream).перебираем_все_элементы(forEach)(тут_интуитивно_понятно)

System.out::println— un lien vers une méthode statique qui génère une chaîne sur la console Au lieu d'un lien vers une méthode statique, vous pouvez utiliser une entrée légèrement différente et moins claire :

list.stream().forEach(i -> System.out.println(i));

Cette entrée utilise des expressions lambda. Et oui, pour apprendre à travailler avec des flux, vous devrez apprendre les expressions lambda - elles sont merveilleuses. De plus, je ne montrerai pas comment travailler avec des collections en utilisant uniquement des flux, en me basant sur le fait que vous vous êtes familiarisé avec les méthodes traditionnelles au cours du cours.

Exemple 2. Rechercher des valeurs paires dans la liste et les afficher dans la console

list.stream().filter(i -> i%2==0).forEach(System.out::println);

Tout le problème a été résolu en une seule ligne. J'espère que vous apprécierez travailler sur une seule ligne. En utilisant cette méthode, filternous avons filtré le flux et affiché ce qui restait à la console. Le filtre est un outil très puissant qui peut aider dans les cas les plus inattendus. Soyons créatifs et changeons les conditions du problème. Par exemple, nous devons compter combien de nombres pairs se trouvent dans la liste :

long count = list.stream().filter(i -> i%2==0).count();

Et encore une fois sur une seule ligne. D'une manière ou d'une autre, tout semble simple. Dans le filtre, nous avons utilisé une expression lambda, plaçant ainsi uniquement les nombres pairs dans le nouveau flux, puis appliquée au nouveau flux count, qui comptait le nombre d'éléments dans le nouveau flux.

Exemple 3. Comptons combien de mots dans la liste comportent 5 caractères

Nous avons joué avec les nombres entiers, jouons maintenant avec les mots.

List<String> list = new ArrayList<>();
Collections.addAll(list, "разые", "слова", "интересные", "And", "Not", "Very");

System.out.println(list.stream().filter(w -> w.length() == 5).count());

Nous avons réutilisé le filtre. Dans le filtre, à l'aide d'une expression lambda, un nouveau flux a été affiché, puis, naturellement, countj'ai calculé le nombre d'éléments contenus dans le nouveau flux.

Exemple 4. Imprimer des mots uniques

Une tâche familière lorsque nous lisons de nombreux mots différents dans une collection à partir d'un fichier, et maintenant nous n'avons besoin que de mots uniques.

List<String> list = new ArrayList<>();
Collections.addAll(list, "Vasya", "Таня", "Olya", "Vasya", "Olya", "Сергей");

list.stream().distinct().forEach(System.out::println);

L'action principale a été réalisée sur le flux en utilisant distinct. Ensuite, je suggère de jeter un œil à certaines de nos tâches du cours en utilisant des fils de discussion.

Exemple 5. Mots longs

Au 9ème niveau de Java Core, dans la leçon 11, il y a un problème intéressant, dans lequel vous devez écrire des mots séparés par des virgules dans File2, dont la longueur est strictement supérieure à 6. Quel que soit le type de jardin que vous clôturez, Je propose la solution suivante :

1. À partir du fichier source, nous lisons tous les mots de la liste.

2. Ensuite, nous exécutons la ligne suivante

   Optional<String> rezult = list.stream()
   				.filter(w->w.length()>6)
   				.reduce((w1,w2)->w1+", "+w2);

3. result.get()écrire dans un fichier.

Voici une solution intéressante utilisant des threads. Le filtre a filtré et en utilisant réduire et une expression régulière, la chaîne requise a été générée.

Exemple 6. Mots avec des chiffres

Écrivez tous les mots contenant des nombres, par exemple a1 ou abc3d, séparés par un espace dans Fichier2. C'est également une condition de notre livre de problèmes, comme vous l'aurez deviné, la solution est simple.

Optional<String> rezult = list.stream()
				.filter(w->w.matches(".*?\\d+.*?"))
				.reduce((w1,w2)->w1+" "+w2);

Nous avons filtré le flux à l'aide d'une expression régulière, puis réduisons et une expression lambda. Tellement de points communs avec la tâche précédente.

Exemple 7. Sélection de nombres

L'ensemble de la tâche ressemble à ceci :

• Lisez 2 noms de fichiers depuis la console.
• Sortez dans le deuxième fichier tous les nombres qui se trouvent dans le premier fichier.
• Les nombres sont séparés par des espaces.
• Fermez les flux.

Pour la tâche principale, qui consiste à écrire des nombres dans une chaîne séparée par des espaces, pour écrire davantage dans un fichier, je suggère d'utiliser un flux, il ressemblera à ceci :

Optional<String> rezult = list.stream().filter(w->w.matches("\\d+"))
				.reduce((w1,w2)->w1+" "+w2);
System.out.println(rezult.get());

À l'aide de threads, le problème est résolu de manière très simple. Mais voilà, comparez vous-même cette solution avec les deux précédentes. En conclusion de l'article, je veux vous avouer : les gars, j'ai triché en sélectionnant des exemples. Le fait est que j'ai choisi les exemples les plus simples afin de vous montrer un sujet inconnu utilisant des problèmes familiers. Bien entendu, les threads sont utilisés à la fois pour des tâches simples et plus complexes. Mais comme Horstman le souligne dans son livre, « les flux de données fonctionnent selon le principe du « quoi faire, pas comment ? », ce qui signifie que de nombreuses tâches auparavant complexes peuvent devenir plus simples. Je ne sais pas pour vous, mais j’ai aimé les flow, j’espère ne pas vous avoir découragé de les apprendre. Et laissez-moi vous expliquer encore une chose :

1. Je n’avais pas pour objectif d’enseigner au lecteur comment utiliser les flux dans les collections ; je ne suis pas un enseignant très expérimenté. Je voulais vous montrer que les discussions sont simples et très intéressantes ! En général, c'est une nécessité.
2. Plus je comprends les flux, plus je vois des problèmes où ils résolvent tous les problèmes du manuel de cours, ce qui signifie que les flux n'ont pas été inventés en vain.
3. Les flux sont non seulement faciles à utiliser, mais ils présentent également un avantage important : lorsque vous travaillez avec de grandes quantités de données, les flux sont souvent plus productifs.

PS . Je plaisantais sur TOUS LES PROBLÈMES. Recommander : bibliothèque Java professionnelle. Volume 2 Outils de programmation avancés. Kay Horstmann. J'ai la dixième édition.