Joindre et diviser des tableaux et des collections en Java
1. Vue d'ensemble
Dans ce rapide didacticiel, nous allons apprendre à joindre et à fractionnerArrays etCollections en Java, en utilisant à bon escient le nouveau support de flux.
2. Rejoignez deuxArrays
Commençons par joindre deuxArrays ensemble en utilisantStream.concat:
@Test
public void whenJoiningTwoArrays_thenJoined() {
String[] animals1 = new String[] { "Dog", "Cat" };
String[] animals2 = new String[] { "Bird", "Cow" };
String[] result = Stream.concat(
Arrays.stream(animals1), Arrays.stream(animals2)).toArray(String[]::new);
assertArrayEquals(result, new String[] { "Dog", "Cat", "Bird", "Cow" });
}3. Rejoignez deuxCollections
Faisons la même jointure avec deuxCollections:
@Test
public void whenJoiningTwoCollections_thenJoined() {
Collection collection1 = Arrays.asList("Dog", "Cat");
Collection collection2 = Arrays.asList("Bird", "Cow", "Moose");
Collection result = Stream.concat(
collection1.stream(), collection2.stream())
.collect(Collectors.toList());
assertTrue(result.equals(Arrays.asList("Dog", "Cat", "Bird", "Cow", "Moose")));
} 4. Rejoindre deuxCollections avec le filtre
Maintenant, joignons deuxCollections de nombres filtrant tout ce qui est supérieur à 10:
@Test
public void whenJoiningTwoCollectionsWithFilter_thenJoined() {
Collection collection1 = Arrays.asList("Dog", "Cat");
Collection collection2 = Arrays.asList("Bird", "Cow", "Moose");
Collection result = Stream.concat(
collection1.stream(), collection2.stream())
.filter(e -> e.length() == 3)
.collect(Collectors.toList());
assertTrue(result.equals(Arrays.asList("Dog", "Cat", "Cow")));
} 5. Rejoindre unArray dans unString
Ensuite, joignons un tableau dans unString en utilisant unCollector:
@Test
public void whenConvertArrayToString_thenConverted() {
String[] animals = new String[] { "Dog", "Cat", "Bird", "Cow" };
String result = Arrays.stream(animals).collect(Collectors.joining(", "));
assertEquals(result, "Dog, Cat, Bird, Cow");
}6. Rejoindre unCollection dans unString
Faisons de même mais avec unCollection:
@Test
public void whenConvertCollectionToString_thenConverted() {
Collection animals = Arrays.asList("Dog", "Cat", "Bird", "Cow");
String result = animals.stream().collect(Collectors.joining(", "));
assertEquals(result, "Dog, Cat, Bird, Cow");
} 7. Rejoindre unMap dans unString
Ensuite, créons unString à partir d'unMap.
Le processus est très similaire aux exemples précédents, mais ici nous avons une étape supplémentaire pour d'abord joindre chaqueMapEntry:
@Test
public void whenConvertMapToString_thenConverted() {
Map animals = new HashMap<>();
animals.put(1, "Dog");
animals.put(2, "Cat");
animals.put(3, "Cow");
String result = animals.entrySet().stream()
.map(entry -> entry.getKey() + " = " + entry.getValue())
.collect(Collectors.joining(", "));
assertEquals(result, "1 = Dog, 2 = Cat, 3 = Cow");
} 8. Rejoindre desCollections imbriqués dans unString
Faisons quelque chose d'un peu plus complexe. Joignons quelquesCollections imbriqués dans unString.
Dans l'exemple suivant, nous rejoignons d'abord chaque collection imbriquée, puis nous joignons le résultat de chacune d'entre elles:
@Test
public void whenConvertNestedCollectionToString_thenConverted() {
Collection> nested = new ArrayList<>();
nested.add(Arrays.asList("Dog", "Cat"));
nested.add(Arrays.asList("Cow", "Pig"));
String result = nested.stream().map(
nextList -> nextList.stream()
.collect(Collectors.joining("-")))
.collect(Collectors.joining("; "));
assertEquals(result, "Dog-Cat; Cow-Pig");
} 9. Gérer les valeursNull lors de la jointure
Voyons comment nous pouvons utiliser unFilter pour ignorer toutes les valeursnull:
@Test
public void whenConvertCollectionToStringAndSkipNull_thenConverted() {
Collection animals = Arrays.asList("Dog", "Cat", null, "Moose");
String result = animals.stream()
.filter(Objects::nonNull)
.collect(Collectors.joining(", "));
assertEquals(result, "Dog, Cat, Moose");
} 10. Diviser unCollection en deux
Divisons unCollection de nombres en deuxCollections au milieu:
@Test
public void whenSplitCollectionHalf_thenConverted() {
Collection animals = Arrays.asList(
"Dog", "Cat", "Cow", "Bird", "Moose", "Pig");
Collection result1 = new ArrayList<>();
Collection result2 = new ArrayList<>();
AtomicInteger count = new AtomicInteger();
int midpoint = Math.round(animals.size() / 2);
animals.forEach(next -> {
int index = count.getAndIncrement();
if (index < midpoint) {
result1.add(next);
} else {
result2.add(next);
}
});
assertTrue(result1.equals(Arrays.asList("Dog", "Cat", "Cow")));
assertTrue(result2.equals(Arrays.asList("Bird", "Moose", "Pig")));
} 11. Fractionner unArray par longueur de mot
Ensuite, divisons un tableau par la longueur des mots:
@Test
public void whenSplitArrayByWordLength_thenConverted() {
String[] animals = new String[] { "Dog", "Cat", "Bird", "Cow", "Pig", "Moose"};
Map> result = Arrays.stream(animals)
.collect(Collectors.groupingBy(String::length));
assertTrue(result.get(3).equals(Arrays.asList("Dog", "Cat", "Cow", "Pig")));
assertTrue(result.get(4).equals(Arrays.asList("Bird")));
assertTrue(result.get(5).equals(Arrays.asList("Moose")));
} 11. Fractionner unString en unArray
Faisons maintenant le contraire, divisons unString en unArray:
@Test
public void whenConvertStringToArray_thenConverted() {
String animals = "Dog, Cat, Bird, Cow";
String[] result = animals.split(", ");
assertArrayEquals(result, new String[] { "Dog", "Cat", "Bird", "Cow" });
}12. FractionnerString en unCollection
Cet exemple est similaire au précédent, il y a juste une étape supplémentaire pour convertir deArray enCollection:
@Test
public void whenConvertStringToCollection_thenConverted() {
String animals = "Dog, Cat, Bird, Cow";
Collection result = Arrays.asList(animals.split(", "));
assertTrue(result.equals(Arrays.asList("Dog", "Cat", "Bird", "Cow")));
} 13. Fractionner unString en unMap
Maintenant, créons unMap à partir d'unString. Nous devrons diviser notre chaîne deux fois, une pour chaque entrée et une dernière fois pour la clé et les valeurs:
@Test
public void whenConvertStringToMap_thenConverted() {
String animals = "1 = Dog, 2 = Cat, 3 = Bird";
Map result = Arrays.stream(
animals.split(", ")).map(next -> next.split(" = "))
.collect(Collectors.toMap(entry -> Integer.parseInt(entry[0]), entry -> entry[1]));
assertEquals(result.get(1), "Dog");
assertEquals(result.get(2), "Cat");
assertEquals(result.get(3), "Bird");
} 14. FractionnerString avec plusieurs séparateurs
Enfin, divisons unString qui a plusieurs séparateurs en utilisant une expression régulière, nous supprimerons également tous les résultats vides:
@Test
public void whenConvertCollectionToStringMultipleSeparators_thenConverted() {
String animals = "Dog. , Cat, Bird. Cow";
Collection result = Arrays.stream(animals.split("[,|.]"))
.map(String::trim)
.filter(next -> !next.isEmpty())
.collect(Collectors.toList());
assertTrue(result.equals(Arrays.asList("Dog", "Cat", "Bird", "Cow")));
} 15. Conclusion
Dans ce didacticiel, en tirant parti de la simple fonctionString.split et du puissant Java 8Stream,, nous avons illustré comment joindre et fractionnerArrays etCollections.
Vous pouvez trouver le code de cet articleover on GitHub.