Java 8(流。and Stream.concat)

建议的解决方案是针对三个列表，但它也可以应用于两个列表。在Java 8中，我们可以使用Stream。属于或属于溪流。合并多个数组:

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

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

您的要求之一是保存原始的清单。如果您创建一个新列表并使用addAll()，那么您实际上是将列表中对象的引用数量增加了一倍。如果您的列表非常大，这可能会导致内存问题。

如果不需要修改连接的结果，可以使用自定义列表实现来避免这种情况。自定义实现类不止一行，显然…但是使用它是简短而甜蜜的。

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

下面是一个使用两行代码的java 8解决方案:

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

请注意，在以下情况下不应使用此方法

newList的来源是未知的，它可能已经与其他线程共享 修改newList的流是并行流，对newList的访问不是同步的，也不是线程安全的

由于副作用的考虑。

上述两个条件都不适用于上述连接两个列表的情况，因此这是安全的。

基于我对另一个问题的回答。

可能并不简单，但有趣而丑陋:

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

不要在产品代码中使用它……；）

另一个使用Java8流的线性解决方案，因为flatMap解决方案已经发布，这里是一个没有flatMap的解决方案

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

or

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

code

    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]

几乎所有的回答都建议使用数组列表。

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

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

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

更多信息https://stackoverflow.com/a/322742/311420