java - How do I join two lists in Java?

Question

Conditions: do not modify the original lists; JDK only, no external libraries. Bonus points for a one-liner or a JDK 1.3 version.

Is there a simpler way than:

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

score 659 · Accepted Answer

Off the top of my head, I can shorten it by one line:

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

score 382 · Accepted Answer

Apache commons-collectionsライブラリを使用できます。

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

score 98 · Accepted Answer

要件の1つは、元のリストを保持することです。新しいリストを作成してを使用するとaddAll()、リスト内のオブジェクトへの参照の数が実質的に2倍になります。リストが非常に大きい場合、これはメモリの問題につながる可能性があります。

連結された結果を変更する必要がない場合は、カスタムリストの実装を使用してこれを回避できます。カスタム実装クラスは明らかに複数の行です...しかし、それを使用するのは短くて甘いです。

CompositeUnmodizableList.java：

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

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

    public CompositeUnmodifiableList(List<? extends E> list1, List<? extends 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();
    }
}

使用法：

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

score 97 · Accepted Answer

おそらく単純ではありませんが、興味をそそられて醜いです：

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

本番コードでは使用しないでください... ;)

score 83 · Accepted Answer

単純ではありませんが、サイズ変更のオーバーヘッドはありません:

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

score 57 · Accepted Answer

外部ライブラリを気にせずに、任意の量のリストを連結しようとしているこの質問を見つけました。だから、おそらくそれは他の誰かを助けるでしょう：

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

1 つの for() で複数の異なるコレクションに同じロジックを適用する場合に便利です。

score 53 · Accepted Answer

Java 8 (Stream.ofおよびStream.concat)

提案されたソリューションは 3 つのリスト用ですが、2 つのリストにも適用できます。Java 8 では、Stream.ofまたはStream.concatを次のように使用できます。

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.concat入力として 2 つのストリームを取り、要素が最初のストリームのすべての要素の後に 2 番目のストリームのすべての要素が続く遅延連結ストリームを作成します。3 つのリストがあるので、このメソッド ( Stream.concat) を 2 回使用しました。

また、( varargsを使用して) 任意の数のリストを取得し、連結されたリストを次のように返すメソッドを使用してユーティリティクラスを作成することもできます。

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

次に、このメソッドを次のように利用できます。

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

score 51 · Accepted Answer

以下は、2 行を使用した Java 8 ソリューションです。

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

次の場合は、このメソッドを使用しないでください。

の起源newListは不明であり、すでに他のスレッドと共有されている可能性があります
変更するストリームnewListは並列ストリームであり、へのアクセス newListは同期化されていないか、スレッドセーフではありません

副作用の考慮のため。

上記の条件は両方とも、2 つのリストを結合する上記のケースには当てはまらないため、これは安全です。

this answer to another question に基づいています。

score 38 · Accepted Answer

これは単純で 1 行だけですが、listTwo の内容を listOne に追加します。内容を 3 番目のリストに入れる必要は本当にありますか?

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

score 33 · Accepted Answer

33

Slightly simpler:

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

于 2008-10-09T23:21:09.463 に答える

score 21 · Accepted Answer

A little shorter would be:

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

score 13 · Accepted Answer

ターゲットリストが事前に宣言されている場合は、ワンライナーを実行できます。

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

score 10 · Accepted Answer

Java8ストリームを使用した別の 1 つのライナーソリューション。flatMapソリューションは既に投稿されているため、ここにソリューションなしのソリューションがあります。flatMap

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

また

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

コード

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

出力

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

score 8 · Accepted Answer

私の意見では最も賢い：

/**
 * @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;
}

score 6 · Accepted Answer

静的インポートとヘルパークラスでそれを行うことができます

nbこのクラスのジェネリフィケーションはおそらく改善される可能性があります

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

}

次に、次のようなことができます

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

score 4 · Accepted Answer

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

score 4 · Accepted Answer

ヘルパークラスを使用します。

私は提案します：

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

score 3 · Accepted Answer

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

score 0 · Accepted Answer

私はそれが単純だと主張しているわけではありませんが、ワンライナーのボーナスについて言及しました;-)

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

score 0 · Accepted Answer

リストに異なるタイプがあり、それらを別のタイプのリストに結合したい場合は、ストリームと Java 8 を使用するアプローチを次に示します。

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

score 0 · Accepted Answer

ワンライナーにはほど遠いですが、これが最も簡単だと思います：

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

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

score -6 · Accepted Answer

一般的なケースでは、独自のユーティリティメソッドを導入せずに 2 ライナーを改善することはできませんが、文字列のリストがあり、それらの文字列にコンマが含まれていないと仮定してもよい場合は、この長いリストを取得できます。 -ライナー：

List<String> newList = new ArrayList<String>(Arrays.asList((listOne.toString().subString(1, listOne.length() - 1) + ", " + listTwo.toString().subString(1, listTwo.length() - 1)).split(", ")));

ジェネリックを削除した場合、これは JDK 1.4 に準拠するはずです (ただし、私はそれをテストしていません)。また、製品コードにはお勧めしません ;-)

score -7 · Accepted Answer

public class TestApp {

/**
 * @param args
 */
public static void main(String[] args) {
    System.out.println("Hi");
    Set<List<String>> bcOwnersList = new HashSet<List<String>>();
    List<String> bclist = new ArrayList<String>();
    List<String> bclist1 = new ArrayList<String>();
    List<String> object = new ArrayList<String>();
    object.add("BC11");
    object.add("C2");
    bclist.add("BC1");
    bclist.add("BC2");
    bclist.add("BC3");
    bclist.add("BC4");
    bclist.add("BC5");
    bcOwnersList.add(bclist);
    bcOwnersList.add(object);

    bclist1.add("BC11");
    bclist1.add("BC21");
    bclist1.add("BC31");
    bclist1.add("BC4");
    bclist1.add("BC5");

    List<String> listList= new ArrayList<String>();
    for(List<String> ll : bcOwnersList){
        listList = (List<String>) CollectionUtils.union(listList,CollectionUtils.intersection(ll, bclist1));
    }
    /*for(List<String> lists : listList){
        test = (List<String>) CollectionUtils.union(test, listList);
    }*/
    for(Object l : listList){
        System.out.println(l.toString());
    }
    System.out.println(bclist.contains("BC"));

}

}

java - How do I join two lists in Java?

33 に答える 33

Related

Reference