flatMap en Java
-
La fonction
flatMapen Java -
Comment utiliser la méthode
flatMap()en Java -
Supprimer le doublon de
flatMapen Java -
Filtrer les éléments
flatMapen Java -
flatMapet type primitif - Conclusion
Ce tutoriel présente flatMap et comment l’utiliser en Java.
flatMap est une opération/fonction dans le flux Java utilisée pour obtenir un nouveau flux après avoir effectué une tâche fonctionnelle. Ici, nous allons parler de l’opération flatMap().
Cette opération est une extension de l’opération map(). Cette fonction est appliquée à chaque élément de flux et génère un flux de nouvelles valeurs.
Les éléments générés par ces nouveaux flux sont ensuite copiés dans un flux récemment créé, qui sert de valeur de retour de la méthode.
La fonction flatMap en Java
La signature de la fonction flatMap() est :
<R> Stream<R> flatMap(Function<? super T,? extends Stream<? extends R>> mapper)
flatMap est une opération intermédiaire. Les opérations intermédiaires sont des opérations paresseuses et appelées sur une instance Stream, et après avoir terminé leur traitement, elles renvoient une instance Stream.
L’opération flatMap() est une combinaison des opérations map() et flat(). Cela signifie que l’opération flatMap() applique d’abord l’opération map(), puis aplatit le résultat.
Cette méthode prend un mappeur, une fonction qui doit être appliquée à chaque élément du Stream entrant.
Aplatir en Java
Comprenons d’abord ce qu’est l’aplatissement. L’aplatissement d’une liste convertit deux listes de niveau ou plus en une liste de niveau unique.
Voici un exemple de liste à deux niveaux :
[[ "I" ], [ "Love" ], [ "Delft", "Stack" ]]
La liste ci-dessus après aplatissement est convertie en :
["I", "Love", "Delft", "Stack"]
La liste produite est une liste à un seul niveau.
Besoin d’aplatir une liste
Il est nécessaire d’aplatir une liste car traiter plusieurs niveaux de flux peut être difficile, compliqué et sujet aux erreurs.
Nous pouvons utiliser l’opération Stream.flatMap() pour convertir les deux niveaux de flux en un seul niveau de flux. Nous comprendrons cela à l’aide d’un exemple plus loin dans cet article.
Comment utiliser la méthode flatMap() en Java
Dans cet exemple, nous avons d’abord créé un flux d’objets à partir d’une List en utilisant la méthode stream(). Chaque objet est un programmeur dans une entreprise.
Nous allons d’abord créer une classe pour représenter un développeur/programmeur dans une entreprise.
import java.util.HashSet;
import java.util.Set;
class Programmer {
private String name;
private Set<String> languages_known;
public Programmer(String name) {
this.name = name;
this.languages_known = new HashSet<>();
}
public void addLanguage(String lang) {
this.languages_known.add(lang);
}
public Set<String> getLanguages() {
return languages_known;
}
}
Nous allons maintenant initialiser des objets et créer une liste de listes contenant tous les langages connus par les programmeurs de toute l’entreprise. Nous aplatirons ensuite cette liste pour connaître toutes les langues de l’équipe.
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
public class SimpleTesting {
public static void main(String[] args) {
Programmer raj = new Programmer("Raj");
raj.addLanguage("Java");
raj.addLanguage("Dart");
raj.addLanguage("go");
raj.addLanguage("groovy");
Programmer karan = new Programmer("Karan");
karan.addLanguage("Java");
karan.addLanguage("Python");
Programmer chahal = new Programmer("Chahal");
chahal.addLanguage("Dart");
chahal.addLanguage("Javascript");
List<Programmer> team = new ArrayList<>();
team.add(raj);
team.add(karan);
team.add(chahal);
System.out.println("Programming languages in the team: ");
List<String> languages = team.stream()
.map(Programmer::getLanguages)
.flatMap(Collection::stream)
.collect(Collectors.toList());
System.out.println(languages);
}
}
Production :
Programming languages in the team:
[Java, groovy, go, Dart, Java, Python, Javascript, Dart]
Dans l’exemple ci-dessus, nous avons d’abord créé un flux de tous les programmeurs à l’aide de l’API de flux. Après cela, nous avons créé un flux de listes de langages connus par chaque programmeur à l’aide de la fonction map().
Supprimer le doublon de flatMap en Java
Nous aplatissons ensuite cette liste à l’aide de l’opération flatMap() et convertissons le flux résultant en une liste. Notez que la liste produite contient des valeurs en double ; nous utilisons l’opération duplicate() pour les éliminer.
Regardez le code ci-dessous.
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
public class SimpleTesting {
public static void main(String[] args) {
Programmer raj = new Programmer("Raj");
raj.addLanguage("Java");
raj.addLanguage("Dart");
raj.addLanguage("go");
raj.addLanguage("groovy");
Programmer karan = new Programmer("Karan");
karan.addLanguage("Java");
karan.addLanguage("Python");
Programmer chahal = new Programmer("Chahal");
chahal.addLanguage("Dart");
chahal.addLanguage("Javascript");
List<Programmer> team = new ArrayList<>();
team.add(raj);
team.add(karan);
team.add(chahal);
System.out.println("Programming languages in the team: ");
List<String> languages = team.stream()
.map(Programmer::getLanguages)
.flatMap(Collection::stream)
.distinct()
.collect(Collectors.toList());
System.out.println(languages);
}
}
Production :
Programming languages in the team:
[Java, groovy, go, Dart, Python, Javascript]
Filtrer les éléments flatMap en Java
Si nous voulons obtenir toutes les langues sauf Dart, nous pouvons utiliser la fonction filter() avec flatMap(). Regardez le code ci-dessous.
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
public class SimpleTesting {
public static void main(String[] args) {
Programmer raj = new Programmer("Raj");
raj.addLanguage("Java");
raj.addLanguage("Dart");
raj.addLanguage("go");
raj.addLanguage("groovy");
Programmer karan = new Programmer("Karan");
karan.addLanguage("Java");
karan.addLanguage("Python");
Programmer chahal = new Programmer("Chahal");
chahal.addLanguage("Dart");
chahal.addLanguage("Javascript");
List<Programmer> team = new ArrayList<>();
team.add(raj);
team.add(karan);
team.add(chahal);
System.out.println("Programming languages in the team: ");
List<String> languages = team.stream()
.map(Programmer::getLanguages)
.flatMap(Collection::stream)
.distinct()
.filter(x -> !x.equals("Dart"))
.collect(Collectors.toList());
System.out.println(languages);
}
}
Production :
Programming languages in the team:
[Java, groovy, go, Python, Javascript]
flatMap et type primitif
L’API Java Stream fournit également des opérations distinctes telles flatMapto{primitive type} pour les types de données primitifs tels que int, float, long pour aplatir le flux de type primitif.
import java.util.Arrays;
import java.util.stream.IntStream;
import java.util.stream.Stream;
public class SimpleTesting {
public static void main(String[] args) {
int[] Je_array = {3, 5, 2, 35, 85, 32, 23, 43, 12};
Stream<int[]> JE_streamArray = Stream.of(Je_array);
IntStream JE_intStream = JE_streamArray.flatMapToInt(x -> Arrays.stream(x));
JE_intStream.forEach(x -> System.out.println(x));
}
}
Production :
3
5
2
35
85
32
23
43
12
Conclusion
Nous avons discuté de l’opération flatMap() et pourquoi elle est nécessaire. Nous avons également expliqué comment l’API Java Stream fournit une opération flatMap() distincte pour les types de données primitifs.
Notez que l’opération normale flatMap() est également applicable aux types de données primitifs.