Kombinieren verschiedener Arten von Sammlungen in Java

1. Einleitung

In diesem kurzen Tutorial werden verschiedene Möglichkeiten zum Kombinieren von Sammlungen in Java untersucht.

Wir werden verschiedene Ansätze mit Java und externen Frameworks wie Guava, Apache usw. untersuchen. Die Einführung in Sammlungen finden Sie in dieser Reihe hier.

2. Externe Bibliotheken für die Arbeit mit Sammlungen

Neben nativen Ansätzen werden wir auch externe Bibliotheken verwenden. Bitte fügen Sie die folgenden Abhängigkeiten in die pom.xml ein :

 org.apache.commons commons-collections4 4.2   org.apache.commons commons-exec 1.3   com.google.guava guava 26.0-jre 

Die neuesten Versionen finden Sie in Maven Central für Commons, Commons-exec und Guava.

3. Kombinieren von Arrays in Java

3.1. Native Java-Lösung

Java verfügt über eine integrierte void arraycopy () -Methode, mit der ein bestimmtes Quellarray in das Zielarray kopiert wird.

Wir können es folgendermaßen verwenden:

Object[] combined = new Object[first.length + second.length]; System.arraycopy(first, 0, combined, 0, first.length); System.arraycopy(second, 0, combined, first.length, second.length);

Bei dieser Methode geben wir zusammen mit den Array-Objekten auch die Position an, von der kopiert werden soll, und übergeben den Parameter length.

Dies ist eine native Java-Lösung, daher sind keine externen Bibliotheken erforderlich.

3.2. Verwenden der Java 8 Stream- API

Streams bieten eine effektive Möglichkeit, verschiedene Arten von Sammlungen zu durchlaufen. Um mit Streams zu beginnen, besuchen Sie das Java 8 Stream API Tutorial.

Um Arrays mit einem Stream zu kombinieren , können wir diesen Code verwenden:

Object[] combined = Stream.concat(Arrays.stream(first), Arrays.stream(second)).toArray();

Stream.concat () erstellt einen verketteten Stream, in dem auf die Elemente des ersten Streams die Elemente des zweiten Streams folgen, der anschließend mit der Methode toArray () in ein Array konvertiert wird.

Der Prozess zum Erstellen des Streams ist für verschiedene Arten von Sammlungen gleich. Wir können es jedoch auf verschiedene Arten sammeln, um verschiedene Datenstrukturen daraus abzurufen.

Wir werden diese Methode in Abschnitt 4.2 erneut betrachten. und 5.2. um zu sehen, wie wir dieselbe Methode für Listen und Sets verwenden können .

3.3. Verwenden von ArrayUtils aus Apache Commons

Die Apache Commons-Bibliothek stellt uns die Methode addAll () aus dem ArrayUtils- Paket zur Verfügung. Wir können Ziel- und Quellarray als Parameter angeben, und diese Methode gibt ein kombiniertes Array zurück:

Object[] combined = ArrayUtils.addAll(first, second);

Diese Methode wird auch im Artikel Array-Verarbeitung mit Apache Commons Lang 3 ausführlich erläutert.

3.4. Guave benutzen

Guava stellt uns die concat () -Methode für denselben Zweck zur Verfügung:

Object [] combined = ObjectArrays.concat(first, second, Object.class);

Es kann mit verschiedenen Datentypen verwendet werden und akzeptiert zwei Quellarrays zusammen mit dem Klassenliteral, um das kombinierte Array zurückzugeben.

4. Liste in Java kombinieren

4.1. Mit Sammlung india addAll () Methode

Die Collection- Schnittstelle selbst stellt uns die addAll () -Methode zur Verfügung, mit der alle Elemente in der angegebenen Collection zum Aufruferobjekt hinzugefügt werden. Dies wird auch in diesem Baeldung-Artikel ausführlich besprochen:

List combined = new ArrayList(); combined.addAll(first); combined.addAll(second);

Da diese Methode in der übergeordneten Schnittstelle des Collections-Frameworks bereitgestellt wird, dh in der Collection- Schnittstelle, kann sie auf alle Listen und Sets angewendet werden .

4.2. Verwenden von Java 8

Wir können Stream und Collectors auf folgende Weise verwenden, um Listen zu kombinieren :

List combined = Stream.concat(first.stream(), second.stream()).collect(Collectors.toList());

This is the same as what we did in case of Arrays in section 3.2, but instead of converting it to an array, we used collectors to convert it to list. To learn about the Collectors in detail, visit Guide to Java 8’s Collectors.

We can also use flatMaps in this way:

List combined = Stream.of(first, second).flatMap(Collection::stream).collect(Collectors.toList());

First, we're using Stream.of() which returns a sequential stream of two lists – first and second. We'll then pass it to flatMap which will return the contents of a mapped stream after applying the mapping function. This method also discussed in Merging Streams in Java article.

To learn more about the flatMap, head over to this Baeldung article.

4.3. Using ListUtils from Apache Commons

CollectionUtils.union does the union of two collections and returns a collection which contains all the elements:

List combined = ListUtils.union(first, second);

This method is also discussed in A Guide to Apache Commons Collections CollectionUtils. For more info, head over to section 4.9. of this article.

4.4. Using Guava

To merge a List using Guava, we'll use Iterable which consists of the concat() method. After concatenating all the collections, we can quickly get the combined List object as shown in this example:

Iterable combinedIterables = Iterables .unmodifiableIterable(Iterables.concat(first, second)); List combined = Lists.newArrayList(combinedIterables);

5. Combining Set in Java

5.1. Plain Java Solution

As we had already discussed in section 4.1., Collection interface comes with a built-in addAll() method which can be used for copying Lists and Sets as well:

Set combined = new HashSet(); combined.addAll(first); combined.addAll(second);

5.2. Using Java 8 Streams

The same function that we used for List objects can be applied here:

Set combined = Stream .concat(first.stream(), second.stream()) .collect(Collectors.toSet());

The only notable difference here when comparing to list is that instead of using Collectors.toList(), we're using Collectors.toSet() to accumulate all the elements from the supplied two streams into a new Set.

And similar to Lists, when using flatMaps on Sets, it would look like:

Set combined = Stream.of(first, second) .flatMap(Collection::stream) .collect(Collectors.toSet());

5.3. Using Apache Commons

Similar to the ListUtils, we can also work with the SetUtils that does a union of Set elements:

Set combined = SetUtils.union(first, second);

5.4. Using from Guava

The Guava library provides us with straightforward Sets.union() method to combine Sets in Java:

Set combined = Sets.union(first, second);

6. Combining Map in Java

6.1. Plain Java Solution

We can make use of the Map interface which itself provides us with the putAll() method which copies all of the mappings from the supplied argument of Map object to the caller Map object:

Map combined = new HashMap(); combined.putAll(first); combined.putAll(second);

6.2. Using Java 8

Since Java 8, the Map class consists of merge() method which accepts a key, value, and a BiFunction. We can use this with a Java 8 forEach statement to achieve merging functionality:

second.forEach((key, value) -> first.merge(key, value, String::concat));

The third parameter, i.e., remapping function is useful when the same key-value pair is present in both source maps. This function specifies what should be done with those type of values.

We can also use flatMap like this:

Map combined = Stream.of(first, second) .map(Map::entrySet) .flatMap(Collection::stream) .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, String::concat));

6.3. Using Apache Commons Exec

Apache Commons Exec provides us with a straightforward merge(Map first, Map second) method:

Map combined = MapUtils.merge(first, second);

6.4. Using Google Guava

Wir können ImmutableMap verwenden, das von der Guava-Bibliothek von Google bereitgestellt wird. Die putAll () -Methode ordnet alle Schlüssel und Werte der angegebenen Karte der erstellten Karte zu:

Map combined = ImmutableMap.builder() .putAll(first) .putAll(second) .build();

7. Fazit

In diesem Artikel haben wir verschiedene Ansätze zum Kombinieren verschiedener Arten von Sammlungen durchlaufen . Wir haben die Arrays , Listen , Sets und Maps zusammengeführt .

Wie immer finden Sie die vollständigen Code-Schnipsel mit den richtigen Unit-Tests auf GitHub.