Menggabungkan Berbagai Jenis Koleksi di Jawa

1. Pengenalan

Dalam tutorial ringkas ini, kita akan meneroka pelbagai cara menggabungkan koleksi di Java.

Kami akan meneroka pelbagai pendekatan menggunakan kerangka Java dan luaran seperti Jambu, Apache, dll. Untuk pengenalan kepada Koleksi, lihat siri ini di sini.

2. Perpustakaan Luar untuk Bekerja Dengan Koleksi

Bersama dengan pendekatan asli, kami juga akan menggunakan perpustakaan luaran. Sila tambah kebergantungan berikut di pom.xml :

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

Versi terbaru boleh didapati di Maven Central for Commons, Commons-exec dan Guava.

3. Menggabungkan Array di Jawa

3.1. Penyelesaian Java Asli

Java dilengkapi dengan kaedah arraycopy void bawaan () yang menyalin susunan sumber tertentu ke tujuan.

Kita boleh menggunakannya dengan cara berikut:

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);

Dalam kaedah ini, bersama dengan objek array, kita juga menentukan kedudukan dari mana kita perlu menyalin, dan kita juga melewati parameter panjang.

Ini adalah penyelesaian Java asli, jadi ia tidak memerlukan perpustakaan luaran.

3.2. Menggunakan Java 8 Stream API

Aliran menawarkan cara yang berkesan untuk melakukan lelaran ke atas beberapa jenis koleksi. Untuk memulakan aliran, pergi ke Tutorial API Java 8 Stream.

Untuk menggabungkan tatasusunan menggunakan Aliran , kita dapat menggunakan kod ini:

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

Stream.concat () membuat aliran gabungan di mana unsur-unsur aliran pertama diikuti oleh unsur-unsur aliran kedua, yang setelah itu ditukar menjadi array menggunakan kaedah toArray () .

Proses membuat aliran adalah sama di pelbagai jenis koleksi. Walau bagaimanapun, kami dapat mengumpulkannya dengan cara yang berbeza untuk mengambil struktur data yang berbeza darinya.

Kami akan mengkaji semula kaedah ini di bahagian 4.2. dan 5.2. untuk melihat bagaimana kita boleh menggunakan kaedah yang sama pada Senarai dan Set .

3.3. Menggunakan ArrayUtils dari Apache Commons

Perpustakaan Apache commons memberi kami kaedah addAll () dari pakej ArrayUtils . Kami dapat menyediakan array tujuan dan sumber sebagai parameter, dan kaedah ini akan mengembalikan susunan gabungan:

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

Kaedah ini juga dibincangkan secara terperinci dalam artikel Array Processing with Apache Commons Lang 3.

3.4. Menggunakan Jambu Batu

Jambu biji memberi kami kaedah concat () untuk tujuan yang sama:

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

Ia dapat digunakan dengan berbagai jenis data, dan ia menerima dua susunan sumber bersamaan dengan literal kelas untuk mengembalikan susunan gabungan.

4. Menggabungkan Senarai di Jawa

4.1. Menggunakan Kaedah Koleksi Native addAll ()

The Collection muka sendiri menyediakan kami dengan addAll () kaedah, yang menambah semua unsur-unsur dalam koleksi yang dinyatakan kepada objek pemanggil. Ini juga dibincangkan secara terperinci dalam artikel Baeldung ini:

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

Kerana kaedah ini disediakan dalam antara muka ibubapa kebanyakan rangka kerja Collections, iaitu, Koleksi antara muka, ia boleh digunakan di semua Senarai s dan Set s.

4.2. Menggunakan Java 8

Kita boleh menggunakan Stream dan Pengumpul dengan cara yang berikut untuk menggabungkan Senarai :

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

Ini sama dengan yang kami lakukan dalam kasus Array di bahagian 3.2, tetapi alih-alih mengubahnya menjadi array, kami menggunakan pengumpul untuk mengubahnya menjadi daftar. Untuk mengetahui mengenai Pengumpul secara terperinci, kunjungi Panduan untuk Pengumpul Java 8's.

Kami juga boleh menggunakan flatMaps dengan cara ini:

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

Pertama, kita menggunakan Stream.of () yang mengembalikan aliran berurutan dua senarai - pertama dan kedua . Kami kemudian akan menyebarkannya ke flatMap yang akan mengembalikan kandungan aliran yang dipetakan setelah menerapkan fungsi pemetaan. Kaedah ini juga dibincangkan dalam artikel Penggabungan Aliran di Java.

Untuk mengetahui lebih lanjut mengenai flatMap , baca artikel Baeldung ini.

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

Kita boleh menggunakan ImmutableMap yang disediakan oleh perpustakaan Guava Google. Ia putAll () kaedah sekutu semua kunci dan nilai-nilai peta yang diberikan ke dalam peta dibina:

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

7. Kesimpulannya

Dalam artikel ini, kami melalui pendekatan yang berbeza untuk menggabungkan pelbagai jenis Koleksi . Kami bergabung yang tatasusunan , Senarai , Set , dan Peta .

Seperti biasa, coretan kod lengkap dengan ujian unit yang betul boleh didapati di GitHub.