Łączenie i dzielenie tablic i kolekcji w Javie

1. Przegląd

W tym krótkim samouczku nauczymy się, jak łączyć i dzielić tablice i kolekcje w Javie, dobrze wykorzystując nową obsługę strumieni .

2. Połącz dwie tablice

Zacznijmy od połączenia dwóch tablic za pomocą Stream.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. Połącz dwie kolekcje

Zróbmy to samo połączenie z dwiema kolekcjami:

@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. Połącz dwie kolekcje za pomocą filtra

Teraz połączmy dwie kolekcje liczb filtrujących wszystko większe niż 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. Połącz tablicę w łańcuch

Następnie połączmy tablicę w łańcuch za pomocą kolektora:

@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. Dołącz kolekcję do łańcucha

Zróbmy to samo, ale z kolekcją :

@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. Połącz mapę w ciąg

Następnie utwórzmy String z mapy .

Proces jest bardzo podobny do poprzednich przykładów, ale tutaj mamy dodatkowy krok, aby najpierw dołączyć do każdego wpisu na mapie :

@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. Połącz zagnieżdżone kolekcje w łańcuch

Zróbmy coś bardziej złożonego. Połączmy niektóre zagnieżdżone Kolekcje w łańcuch .

W poniższym przykładzie najpierw łączymy się w ramach każdej zagnieżdżonej kolekcji, a następnie łączymy wynik każdego z nich:

@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. Obsługuj wartości Null podczas łączenia

Aby nie zobaczyć, jak możemy użyć filtru, aby pominąć wartości null :

@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. Podziel kolekcję na dwie części

Podzielmy zbiór liczb na dwie kolekcje pośrodku:

@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. Podziel tablicę według długości słowa

Następnie podzielmy tablicę według długości słów:

@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"))); }
    

12. Podziel łańcuch na tablicę

Zróbmy teraz odwrotnie, podzielmy String na Array:

@Test public void whenConvertStringToArray_thenConverted() { String animals = "Dog, Cat, Bird, Cow"; String[] result = animals.split(", "); assertArrayEquals(result, new String[] { "Dog", "Cat", "Bird", "Cow" }); }

13. Podziel strunę na kolekcję

Ten przykład jest podobny do poprzedniego, jest tylko dodatkowy krok do konwersji z tablicy do kolekcji :

@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"))); }

14. Podziel łańcuch na mapę

Teraz stwórzmy Mapa z punktu A String . Będziemy musieli dwukrotnie podzielić nasz ciąg, raz dla każdego wpisu i ostatni raz dla klucza i wartości:

@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"); }

15. Podziel łańcuch z wieloma separatorami

Na koniec podzielmy String, który ma wiele separatorów, używając wyrażenia regularnego, usuniemy również wszelkie puste wyniki:

@Test public void whenConvertCollectionToStringMultipleSeparators_thenConverted() .]")) .map(String::trim) .filter(next -> !next.isEmpty()) .collect(Collectors.toList()); assertTrue(result.equals(Arrays.asList("Dog", "Cat", "Bird", "Cow"))); 

16. Wniosek

W tym samouczku, wykorzystując prostą funkcję String.split i potężny strumień Java 8 , zilustrowaliśmy, jak łączyć i dzielić tablice i kolekcje.

Możesz znaleźć kod tego artykułu na GitHub.