Bagaimana cara saya bergabung dengan dua daftar di Jawa?

Ketentuan: jangan memodifikasi daftar asli; Hanya JDK, tidak ada perpustakaan eksternal. Poin bonus untuk versi satu-liner atau JDK 1.3.

Apakah ada cara yang lebih sederhana daripada:

List<String> newList = new ArrayList<String>();
newList.addAll(listOne);
newList.addAll(listTwo);

Di Jawa 8:

List<String> newList = Stream.concat(listOne.stream(), listTwo.stream())
                             .collect(Collectors.toList());

Dari atas kepala saya, saya dapat mempersingkatnya dengan satu baris:

List<String> newList = new ArrayList<String>(listOne);
newList.addAll(listTwo);

Anda bisa menggunakan pustaka -koleksi Apache commons :

List<String> newList = ListUtils.union(list1, list2);

Salah satu persyaratan Anda adalah mempertahankan daftar asli. Jika Anda membuat daftar baru dan menggunakan addAll(), Anda secara efektif menggandakan jumlah referensi ke objek dalam daftar Anda. Ini dapat menyebabkan masalah memori jika daftar Anda sangat besar.

Jika Anda tidak perlu mengubah hasil gabungan, Anda dapat menghindari ini menggunakan implementasi daftar kustom. Kelas implementasi kustom lebih dari satu baris, jelas ... tetapi menggunakannya pendek dan manis.

CompositeUnmodifiableList.java:

public class CompositeUnmodifiableList<E> extends AbstractList<E> {

    private final List<E> list1;
    private final List<E> list2;

    public CompositeUnmodifiableList(List<E> list1, List<E> list2) {
        this.list1 = list1;
        this.list2 = list2;
    }

    @Override
    public E get(int index) {
        if (index < list1.size()) {
            return list1.get(index);
        }
        return list2.get(index-list1.size());
    }

    @Override
    public int size() {
        return list1.size() + list2.size();
    }
}

Pemakaian:

List<String> newList = new CompositeUnmodifiableList<String>(listOne,listTwo);

Mungkin tidak sederhana, tetapi menarik dan jelek:

List<String> newList = new ArrayList<String>() { { addAll(listOne); addAll(listTwo); } };

Jangan menggunakannya dalam kode produksi ...;)

Satu baris Java 8 lainnya:

List<String> newList = Stream.of(listOne, listTwo)
                            .flatMap(Collection::stream)
                            .collect(Collectors.toList());

Sebagai bonus, karena Stream.of()variadik, Anda dapat menggabungkan daftar sebanyak yang Anda suka.

List<String> newList = Stream.of(listOne, listTwo, listThree)
                            .flatMap(Collection::stream)
                            .collect(Collectors.toList());

Tidak sederhana, tetapi tanpa mengubah ukuran overhead:

List<String> newList = new ArrayList<>(listOne.size() + listTwo.size());
newList.addAll(listOne);
newList.addAll(listTwo);

Menemukan pertanyaan ini mencari untuk menggabungkan jumlah daftar sewenang-wenang, tidak mengurus perpustakaan eksternal. Jadi, mungkin itu akan membantu orang lain:

com.google.common.collect.Iterables#concat()

Berguna jika Anda ingin menerapkan logika yang sama ke sejumlah koleksi berbeda dalam satu untuk ().

Java 8 ( Stream.ofdan Stream.concat)

Solusi yang diusulkan adalah untuk tiga daftar meskipun itu dapat diterapkan untuk dua daftar juga. Di Java 8 kita dapat menggunakan Stream.of atau Stream.concat sebagai:

List<String> result1 = Stream.concat(Stream.concat(list1.stream(),list2.stream()),list3.stream()).collect(Collectors.toList());
List<String> result2 = Stream.of(list1,list2,list3).flatMap(Collection::stream).collect(Collectors.toList());

Stream.concatmengambil dua aliran sebagai input dan menciptakan aliran gabungan yang malas yang elemen-elemennya adalah semua elemen dari aliran pertama diikuti oleh semua elemen dari aliran kedua. Karena kami memiliki tiga daftar, kami telah menggunakan metode ini (Stream.concat ) dua kali.

Kami juga dapat menulis kelas utilitas dengan metode yang mengambil sejumlah daftar (menggunakan varargs ) dan mengembalikan daftar gabungan sebagai:

public static <T> List<T> concatenateLists(List<T>... collections) {
        return Arrays.stream(collections).flatMap(Collection::stream).collect(Collectors.toList()); 
}

Maka kita dapat menggunakan metode ini sebagai:

List<String> result3 = Utils.concatenateLists(list1,list2,list3);

Berikut ini adalah solusi java 8 menggunakan dua baris:

List<Object> newList = new ArrayList<>();
Stream.of(list1, list2).forEach(newList::addAll);

Sadarilah bahwa metode ini tidak boleh digunakan jika

• asal newListtidak diketahui dan mungkin sudah dibagikan dengan utas lainnya
• aliran yang memodifikasi newListadalah aliran paralel dan akses ke newListtidak disinkronkan atau threadsafe

karena pertimbangan efek samping.

Kedua kondisi di atas tidak berlaku untuk kasus menggabungkan dua daftar di atas, jadi ini aman.

Berdasarkan jawaban ini untuk pertanyaan lain.

Ini sederhana dan hanya satu baris, tetapi akan menambahkan konten listTwo ke listOne. Apakah Anda benar-benar perlu memasukkan konten ke daftar ketiga?

Collections.addAll(listOne, listTwo.toArray());

Sedikit lebih sederhana:

List<String> newList = new ArrayList<String>(listOne);
newList.addAll(listTwo);

Sedikit lebih pendek adalah:

List<String> newList = new ArrayList<String>(listOne);
newList.addAll(listTwo);

Anda dapat membuat metode utilitas Java 8 generik untuk menyelesaikan sejumlah daftar .

@SafeVarargs
public static <T> List<T> concat(List<T>... lists) {
    return Stream.of(lists).flatMap(List::stream).collect(Collectors.toList());
}

Anda dapat melakukan oneliner jika daftar target sudah ditentukan sebelumnya.

(newList = new ArrayList<String>(list1)).addAll(list2);

Di Java 8 (sebaliknya):

List<?> newList = 
Stream.of(list1, list2).flatMap(List::stream).collect(Collectors.toList());

solusi satu liner lainnya menggunakan Java8stream, karena flatMapsolusi sudah diposting, berikut adalah solusi tanpaflatMap

List<E> li = lol.stream().collect(ArrayList::new, List::addAll, List::addAll);

atau

List<E> ints = Stream.of(list1, list2).collect(ArrayList::new, List::addAll, List::addAll);

kode

    List<List<Integer>> lol = Arrays.asList(Arrays.asList(1, 2, 3), Arrays.asList(4, 5, 6));
    List<Integer> li = lol.stream().collect(ArrayList::new, List::addAll, List::addAll);
    System.out.println(lol);
    System.out.println(li);

keluaran

[[1, 2, 3], [4, 5, 6]]
[1, 2, 3, 4, 5, 6]

Yang paling cerdas menurut saya:

/**
 * @param smallLists
 * @return one big list containing all elements of the small ones, in the same order.
 */
public static <E> List<E> concatenate (final List<E> ... smallLists)
{
    final ArrayList<E> bigList = new ArrayList<E>();
    for (final List<E> list: smallLists)
    {
        bigList.addAll(list);
    }
    return bigList;
}

Anda bisa melakukannya dengan impor statis dan kelas pembantu

nb generifikasi kelas ini mungkin dapat ditingkatkan

public class Lists {

   private Lists() { } // can't be instantiated

   public static List<T> join(List<T>... lists) {
      List<T> result = new ArrayList<T>();
      for(List<T> list : lists) {
         result.addAll(list);
      }
      return results;
   }

}

Maka Anda dapat melakukan hal-hal seperti

import static Lists.join;
List<T> result = join(list1, list2, list3, list4);

Versi Java 8 dengan dukungan untuk bergabung dengan kunci objek:

public List<SomeClass> mergeLists(final List<SomeClass> left, final List<SomeClass> right, String primaryKey) {
    final Map<Object, SomeClass> mergedList = new LinkedHashMap<>();

    Stream.concat(left.stream(), right.stream())
        .map(someObject -> new Pair<Object, SomeClass>(someObject.getSomeKey(), someObject))
        .forEach(pair-> mergedList.put(pair.getKey(), pair.getValue()));

    return new ArrayList<>(mergedList.values());
}

public static <T> List<T> merge(List<T>... args) {
    final List<T> result = new ArrayList<>();

    for (List<T> list : args) {
        result.addAll(list);
    }

    return result;
}

Gunakan kelas Helper.

Saya menyarankan:

public static <E> Collection<E> addAll(Collection<E> dest, Collection<? extends E>... src) {
    for(Collection<? extends E> c : src) {
        dest.addAll(c);
    }

    return dest;
}

public static void main(String[] args) {
    System.out.println(addAll(new ArrayList<Object>(), Arrays.asList(1,2,3), Arrays.asList("a", "b", "c")));

    // does not compile
    // System.out.println(addAll(new ArrayList<Integer>(), Arrays.asList(1,2,3), Arrays.asList("a", "b", "c")));

    System.out.println(addAll(new ArrayList<Integer>(), Arrays.asList(1,2,3), Arrays.asList(4, 5, 6)));
}

public static <T> List<T> merge(@Nonnull final List<T>... list) {
    // calculate length first
    int mergedLength = 0;
    for (List<T> ts : list) {
      mergedLength += ts.size();
    }

    final List<T> mergedList = new ArrayList<>(mergedLength);

    for (List<T> ts : list) {
      mergedList.addAll(ts);
    }

    return mergedList;
  }

Kita dapat bergabung dengan 2 daftar menggunakan java8 dengan 2 pendekatan.

    List<String> list1 = Arrays.asList("S", "T");
    List<String> list2 = Arrays.asList("U", "V");

1) Menggunakan concat:

    List<String> collect2 = Stream.concat(list1.stream(), list2.stream()).collect(toList());
    System.out.println("collect2 = " + collect2); // collect2 = [S, T, U, V]

2) Menggunakan flatMap:

    List<String> collect3 = Stream.of(list1, list2).flatMap(Collection::stream).collect(toList());
    System.out.println("collect3 = " + collect3); // collect3 = [S, T, U, V]

Hampir semua jawaban menyarankan untuk menggunakan ArrayList.

List<String> newList = new LinkedList<>(listOne);
newList.addAll(listTwo);

Lebih suka menggunakan LinkedList untuk operasi penambahan yang efisien.

ArrayList add adalah O (1) diamortisasi, tetapi O (n) terburuk karena array harus diubah ukurannya dan disalin. Sedangkan LinkedList add selalu konstan O (1).

info lebih lanjut https://stackoverflow.com/a/322742/311420

Saya tidak mengklaim bahwa itu sederhana, tetapi Anda menyebutkan bonus untuk satu-liner ;-)

Collection mergedList = Collections.list(new sun.misc.CompoundEnumeration(new Enumeration[] {
    new Vector(list1).elements(),
    new Vector(list2).elements(),
    ...
}))

Tidak jauh dari one-liner, tapi saya pikir ini yang paling sederhana:

List<String> newList = new ArrayList<String>(l1);
newList.addAll(l2);

for(String w:newList)
        System.out.printf("%s ", w);

Berikut ini pendekatan menggunakan stream dan java 8 jika daftar Anda memiliki tipe yang berbeda dan Anda ingin menggabungkannya ke daftar tipe lain.

public static void main(String[] args) {
    List<String> list2 = new ArrayList<>();
    List<Pair<Integer, String>> list1 = new ArrayList<>();

    list2.add("asd");
    list2.add("asdaf");
    list1.add(new Pair<>(1, "werwe"));
    list1.add(new Pair<>(2, "tyutyu"));

    Stream stream = Stream.concat(list1.stream(), list2.stream());

    List<Pair<Integer, String>> res = (List<Pair<Integer, String>>) stream
            .map(item -> {
                if (item instanceof String) {
                    return new Pair<>(0, item);
                }
                else {
                    return new Pair<>(((Pair<Integer, String>)item).getKey(), ((Pair<Integer, String>)item).getValue());
                }
            })
            .collect(Collectors.toList());
}

Jika Anda ingin melakukan ini secara statis, Anda dapat mengikuti yang berikut.

Contoh-contoh menggunakan 2 EnumSets dalam urutan alami (== Enum-urutan) A, Bdan bergabung kemudian dalam ALLdaftar.

public static final EnumSet<MyType> CATEGORY_A = EnumSet.of(A_1, A_2);
public static final EnumSet<MyType> CATEGORY_B = EnumSet.of(B_1, B_2, B_3);

public static final List<MyType> ALL = 
              Collections.unmodifiableList(
                  new ArrayList<MyType>(CATEGORY_A.size() + CATEGORY_B.size())
                  {{
                      addAll(CATEGORY_A);
                      addAll(CATEGORY_B);
                  }}
              );

import java.util.AbstractList;
import java.util.List;


/**
 * The {@code ConcatList} is a lightweight view of two {@code List}s.
 * <p>
 * This implementation is <em>not</em> thread-safe even though the underlying lists can be.
 * 
 * @param <E>
 *            the type of elements in this list
 */
public class ConcatList<E> extends AbstractList<E> {

    /** The first underlying list. */
    private final List<E> list1;
    /** The second underlying list. */
    private final List<E> list2;

    /**
     * Constructs a new {@code ConcatList} from the given two lists.
     * 
     * @param list1
     *            the first list
     * @param list2
     *            the second list
     */
    public ConcatList(final List<E> list1, final List<E> list2) {
        this.list1 = list1;
        this.list2 = list2;
    }

    @Override
    public E get(final int index) {
        return getList(index).get(getListIndex(index));
    }

    @Override
    public E set(final int index, final E element) {
        return getList(index).set(getListIndex(index), element);
    }

    @Override
    public void add(final int index, final E element) {
        getList(index).add(getListIndex(index), element);
    }

    @Override
    public E remove(final int index) {
        return getList(index).remove(getListIndex(index));
    }

    @Override
    public int size() {
        return list1.size() + list2.size();
    }

    @Override
    public boolean contains(final Object o) {
        return list1.contains(o) || list2.contains(o);
    }

    @Override
    public void clear() {
        list1.clear();
        list2.clear();
    }

    /**
     * Returns the index within the corresponding list related to the given index.
     * 
     * @param index
     *            the index in this list
     * 
     * @return the index of the underlying list
     */
    private int getListIndex(final int index) {
        final int size1 = list1.size();
        return index >= size1 ? index - size1 : index;
    }

    /**
     * Returns the list that corresponds to the given index.
     * 
     * @param index
     *            the index in this list
     * 
     * @return the underlying list that corresponds to that index
     */
    private List<E> getList(final int index) {
        return index >= list1.size() ? list2 : list1;
    }

}