1. Overview

In this quick tutorial, we'll learn how to join and to split Arrays and Collections in Java, making good use of the new stream support.

2. Join Two Arrays

Let's start by joining two Arrays together using Stream.concat:

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. Join Two Collections

Let's do the same join with two Collections:

public void whenJoiningTwoCollections_thenJoined() {
    Collection<String> collection1 = Arrays.asList("Dog", "Cat");
    Collection<String> collection2 = Arrays.asList("Bird", "Cow", "Moose");
    Collection<String> result = Stream.concat(
      collection1.stream(), collection2.stream())

    assertTrue(result.equals(Arrays.asList("Dog", "Cat", "Bird", "Cow", "Moose")));

4. Join Two Collections With Filter

Now, let's join two Collections of numbers filtering anything greater than 10:

public void whenJoiningTwoCollectionsWithFilter_thenJoined() {
    Collection<String> collection1 = Arrays.asList("Dog", "Cat");
    Collection<String> collection2 = Arrays.asList("Bird", "Cow", "Moose");
    Collection<String> result = Stream.concat(
      collection1.stream(), collection2.stream())
      .filter(e -> e.length() == 3)

    assertTrue(result.equals(Arrays.asList("Dog", "Cat", "Cow")));

5. Join an Array Into a String

Next, let's join an Array into a String using a Collector:

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. Join a Collection Into a String

Let's do the same but with a Collection:

public void whenConvertCollectionToString_thenConverted() {
    Collection<String> animals = Arrays.asList("Dog", "Cat", "Bird", "Cow");
    String result = animals.stream().collect(Collectors.joining(", "));

    assertEquals(result, "Dog, Cat, Bird, Cow");

7. Join a Map Into a String

Next, let's create a String out of a Map.

The process is very similar to previous examples, but here we have an extra step to first join each Map Entry:

public void whenConvertMapToString_thenConverted() {
    Map<Integer, String> 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. Join Nested Collections Into a String

Let's do something a bit more complex. Let's join some nested Collections into a String.

In the following example we first join within each nested Collection and then we join the result of each of them:

public void whenConvertNestedCollectionToString_thenConverted() {
    Collection<List<String>> 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("; "));

    assertEquals(result, "Dog-Cat; Cow-Pig");

9. Handle Null Values When Joining

Lest's see how we can use a Filter to skip any null values:

public void whenConvertCollectionToStringAndSkipNull_thenConverted() {
    Collection<String> animals = Arrays.asList("Dog", "Cat", null, "Moose");
    String result = animals.stream()
      .collect(Collectors.joining(", "));

    assertEquals(result, "Dog, Cat, Moose");

10. Split a Collection in Two

Let's split a Collection of numbers into two Collections at the middle:

public void whenSplitCollectionHalf_thenConverted() {
    Collection<String> animals = Arrays.asList(
        "Dog", "Cat", "Cow", "Bird", "Moose", "Pig");
    Collection<String> result1 = new ArrayList<>();
    Collection<String> result2 = new ArrayList<>();
    AtomicInteger count = new AtomicInteger();
    int midpoint = Math.round(animals.size() / 2);

    animals.forEach(next -> {
        int index = count.getAndIncrement();
        if (index < midpoint) {
        } else {

    assertTrue(result1.equals(Arrays.asList("Dog", "Cat", "Cow")));
    assertTrue(result2.equals(Arrays.asList("Bird", "Moose", "Pig")));

11. Split an Array by Word Length

Next, let's split an array by the length of the words:

public void whenSplitArrayByWordLength_thenConverted() {
    String[] animals = new String[] { "Dog", "Cat", "Bird", "Cow", "Pig", "Moose"};
    Map<Integer, List<String>> result = Arrays.stream(animals)

    assertTrue(result.get(3).equals(Arrays.asList("Dog", "Cat", "Cow", "Pig")));

12. Split a String Into an Array

Let's now do the opposite, let's split a String into an Array:

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

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

13. Split String Into a Collection

This example is similar to the previous one, there is just an extra step to convert from Array to a Collection:

public void whenConvertStringToCollection_thenConverted() {
    String animals = "Dog, Cat, Bird, Cow";
    Collection<String> result = Arrays.asList(animals.split(", "));

    assertTrue(result.equals(Arrays.asList("Dog", "Cat", "Bird", "Cow")));

14. Split a String Into a Map

Now, let's create a Map from a String. We will need to split our string twice, once for each entry, and one last time for the key and values:

public void whenConvertStringToMap_thenConverted() {
    String animals = "1 = Dog, 2 = Cat, 3 = Bird";

    Map<Integer, String> 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 With Multiple Separators

Finally, let's split a String that has multiple separators using a regular expression, we will also remove any empty results:

public void whenConvertCollectionToStringMultipleSeparators_thenConverted() {
    String animals = "Dog. , Cat, Bird. Cow";

    Collection<String> result = Arrays.stream(animals.split("[,|.]"))
      .filter(next -> !next.isEmpty())

    assertTrue(result.equals(Arrays.asList("Dog", "Cat", "Bird", "Cow")));

16. Conclusion

In this tutorial, leveraging the simple String.split function and the powerful Java 8 Stream, we illustrated how to join and split Arrays and Collections.

You can find the code for this article over on GitHub.

Java bottom

I just announced the new Learn Spring course, focused on the fundamentals of Spring 5 and Spring Boot 2:

Comments are closed on this article!