Verbinden und Teilen von Arrays und Sammlungen in Java

1. Übersicht

In diesem kurzen Tutorial erfahren Sie, wie Sie Arrays und Sammlungen in Java verbinden und aufteilen und dabei die neue Stream-Unterstützung optimal nutzen .

2. Verbinden Sie zwei Arrays

Beginnen wir damit, zwei Arrays mit Stream.concat zusammenzufügen :

@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. Verbinden Sie zwei Sammlungen

Machen wir den gleichen Join mit zwei Sammlungen:

@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. Verbinden Sie zwei Sammlungen mit Filter

Schließen wir uns nun zwei Sammlungen von Zahlen an, die mehr als 10 filtern:

@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. Verbinden Sie ein Array mit einem String

Als nächstes verbinden wir ein Array mit einem Collector zu einem String :

@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. Verbinden Sie eine Sammlung zu einem String

Machen wir dasselbe, aber mit einer Sammlung :

@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. Verbinden Sie eine Karte mit einer Zeichenfolge

Als nächstes erstellen wir einen String aus einer Map .

Der Prozess ist sehr ähnlich zu den vorherigen Beispielen, aber hier haben wir einen zusätzlichen Schritt zum ersten jeder beitreten Karte Eintrag :

@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. Verschachtelte Sammlungen zu einer Zeichenfolge zusammenfügen

Lassen Sie uns etwas komplexeres tun. Lassen Sie uns einige verschachtelte Sammlungen zu einem String zusammenfügen .

Im folgenden Beispiel verbinden wir zuerst jede verschachtelte Sammlung und dann das Ergebnis jeder einzelnen:

@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. Behandeln Sie Nullwerte beim Beitritt

Damit wir nicht sehen, wie wir einen Filter verwenden können , um Nullwerte zu überspringen :

@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. Teilen Sie eine Sammlung in zwei Teile

Lassen Sie uns eine Sammlung von Zahlen in zwei Sammlungen in der Mitte aufteilen :

@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. Teilen Sie ein Array nach Wortlänge

Als nächstes teilen wir ein Array durch die Länge der Wörter:

@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. Teilen Sie einen String in ein Array

Lassen Sie uns nun das Gegenteil tun und einen String in ein Array aufteilen :

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

13. Teilen Sie die Zeichenfolge in eine Sammlung auf

Dieses Beispiel ähnelt dem vorherigen. Es gibt nur einen zusätzlichen Schritt zum Konvertieren von Array in eine Sammlung :

@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. Teilen Sie einen String in eine Karte

Jetzt erstellen wir eine Map aus einem String . Wir müssen unsere Zeichenfolge zweimal teilen, einmal für jeden Eintrag und ein letztes Mal für den Schlüssel und die Werte:

@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. Split String W ith Mehrere Abscheider

Lassen Sie uns abschließend einen String mit mehreren Trennzeichen mithilfe eines regulären Ausdrucks teilen. Außerdem werden alle leeren Ergebnisse entfernt:

@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. Schlussfolgerung

In diesem Tutorial haben wir anhand der einfachen Funktion String.split und des leistungsstarken Java 8- Streams gezeigt, wie Arrays und Sammlungen verbunden und aufgeteilt werden .

Den Code für diesen Artikel finden Sie auf GitHub.