如何在Java中加入两个列表？

Question

条件:不修改原始列表; 仅限JDK,没有外部库.单行或JDK 1.3版本的奖励积分.

有没有比以下更简单的方法:

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

Answer 1

在我的头顶,我可以缩短一行:

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

Answer 2

在Java 8中:

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

Answer 3

您可以使用Apache commons-collections库:

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

Answer 4

您的一个要求是保留原始列表.如果创建新列表并使用addAll(),则实际上会使列表中对象的引用数增加一倍.如果列表非常大,这可能会导致内存问题.

如果您不需要修改连接结果,则可以使用自定义列表实现来避免这种情况.自定义实现类不止一行,显然......但使用它很简短.

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

用法:

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

Answer 5

可能不简单,但有趣和丑陋:

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

不要在生产代码中使用它...;)

Answer 6

不简单,但没有调整开销:

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

Answer 7

另一个Java 8单线程:

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

作为奖励,因为Stream.of()是可变参数,您可以根据需要连接多个列表.

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

Answer 8

发现这个问题寻找连接任意数量的列表,而不是关注外部库.所以,也许它会帮助别人:

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

如果要将相同的逻辑应用于for()中的多个不同集合,则非常有用.

Answer 9

这是一个使用两行的java 8解决方案:

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

请注意,如果使用此方法,则不应使用此方法

• 原因newList尚不清楚,可能已经与其他线程共享
• 修改的流newList是并行流,并且访问 newList不同步或线程安全

由于副作用的考虑.

上述两个条件都不适用于上述加入两个列表的情况,因此这是安全的.

基于这个答案的另一个问题.

Answer 10

建议的解决方案适用于三个列表,但它也可以应用于两个列表.在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将两个流作为输入并创建一个延迟连接的流,其元素是第一个流的所有元素,后跟第二个流的所有元素.由于我们有三个列表,我们使用了这个方法(Stream.concat)两次.

我们还可以使用一个方法编写一个实用程序类,该方法可以获取任意数量的列表(使用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);

Answer 11

这很简单,只有一行,但会将listTwo的内容添加到listOne.你真的需要将内容放在第三个列表中吗？

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

Answer 12

稍微简单一些:

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

Answer 13

稍短一点就是:

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

Answer 14

您可以创建通用Java 8实用程序方法来连接任意数量的列表.

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

Answer 15

如果目标列表是预先声明的,则可以执行oneliner.

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

Answer 16

在Java 8中(另一种方式):

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

Answer 17

我们可以通过 2 种方法使用 java8 连接 2 个列表。

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

1) 使用 concat ：

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

2）使用 flatMap ：

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

Answer 18

使用Java8流的另一个线性解决方案,因为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]

Answer 19

几乎所有的答案都建议使用 ArrayList。

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

更喜欢使用 LinkedList 进行高效的添加操作。

ArrayList add 是 O(1) 摊销，但 O(n) 最坏情况，因为必须调整数组大小和复制。而 LinkedList add 总是常数 O(1)。

更多信息/sf/answers/22591971/

Answer 20

我认为最聪明的是:

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

Answer 21

您可以使用静态导入和帮助程序类来完成此操作

注意这个类的generification很可能得到改善

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

Answer 22

Java 8版本,支持按对象键加入:

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