TOC

Arrays und Sammlungen in Java verbinden und aufteilen

Verbinden und Teilen von Arrays und Sammlungen in Java

1. Überblick

In diesem kurzen Tutorial erfahren Sie, wie SieArrays undCollections in Java verbinden und teilen, wobei Sie die neue Stream-Unterstützung. gut nutzen

2. Verbinden Sie zweiArrays

Beginnen wir damit, zweiArrays mitStream.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 zweiCollections

Machen wir den gleichen Join mit zweiCollections: 

@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 zweiCollections mit Filter

Verbinden wir nun zweiCollections von Zahlen, 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 einArray mit einemString

Als nächstes verbinden wir ein Array mit einemString zu einemString 

@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 aCollection mit aString

Machen wir dasselbe, aber mit einemCollection: 

@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 aMap mit aString

Als nächstes erstellen wir einString aus einemMap.

Der Prozess ist den vorherigen Beispielen sehr ähnlich, aber hier haben wir einen zusätzlichen Schritt, um zuerst jedesMapEntry zu verbinden: 

@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. Verbinden Sie verschachtelteCollections mit aString

Lassen Sie uns etwas Komplexeres tun. Verbinden wir einige verschachtelteCollectionszuString.

Im folgenden Beispiel verbinden wir uns zuerst mit jeder verschachtelten Sammlung und dann mit dem Ergebnis jeder einzelnen Sammlung: 

@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 SieNull Werte beim Beitritt

Damit wir nicht sehen, wie wirFilterverwenden können, umnull-Werte 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 aCollection in zwei

Teilen wir einCollection der Zahlen in zweiCollections in der Mitte auf: 

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

11. Teilen Sie aString inArray auf

Machen wir jetzt das Gegenteil, teilen wir einString in einArray: 

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

    assertArrayEquals(result, new String[] { "Dog", "Cat", "Bird", "Cow" });
}

12. Teilen SieString inCollection

Dieses Beispiel ähnelt dem vorherigen, es gibt nur einen zusätzlichen Schritt zum Konvertieren vonArray inCollection: 

@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. Teilen Sie aString in aMap

Erstellen wir nun einMap aus einemString. Wir müssen unseren String 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");
}

14. Teilen SieString mit mehreren Trennzeichen

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

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

In diesem Tutorial haben wir anhand der einfachenString.split-Funktion und der leistungsstarken Java 8Stream, gezeigt, wieArrays undCollections. verbunden und aufgeteilt werden

Sie finden den Code für diesen Artikelover on GitHub.

Related