Java 如何将ArrayList前置到另一个ArrayList？

我希望将

java.util.ArrayList

L1中的元素预先添加到另一个

java.util.ArrayList

L2中，但我找不到现成的方法。我不想创建第三个ArrayList，因为L2是视图层中使用的列表。无论是

java.util.Collections

还是

org.apache.commons.Collections.CollectionUtils

都没有这样的实用方法（据我所知）

如何更好地使用现有API将一个ArrayList前置到另一个ArrayList？对于Java7环境

---

备注：

addAll

附录，我想在前面添加。

子列表

提供列表视图。如果在列表的最开始处创建视图，

addAll

将做正确的事情

ArrayList<String> list = new ArrayList<String>(Arrays.asList("extant1", "extant2"));
ArrayList<String> prefix = new ArrayList<String>(Arrays.asList("prefix1", "prefix2"));

list.subList(0, 0).addAll(prefix);
list
// => list ==> [prefix1, prefix2, extant1, extant2]

ArrayList list=新的ArrayList（Arrays.asList（“extant1”、“extant2”）；
ArrayList prefix=新的ArrayList（Arrays.asList（“prefix1”、“prefix2”）；
list.subList（0,0）.addAll（前缀）；
列表
//=>列表==>[prefix1，prefix2，extant1，extant2]

检查向我显示了一个功能

ArrayList.add（int index，E element）

这很有帮助，因为您可以将ArrayList的项放在数组的开头，例如：

ArrayList <Integer> L1 = {2, 3, 5, 7} /*Imaginary declaration*/, L2 = {500, 600}; 
for(int i=0; i<L1.size(); i--) L2.add(0, L1.get(i));

import java.util.ArrayList;
import java.util.List;

public class Main {

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

        list1.add("Item #1");
        list1.add("Item #2");

        list2.add("Item #3");
        list2.add("Item #4");

        System.out.println("List #1: " + list1);
        System.out.println("List #2: " + list2);

        list2.addAll(0, list1);

        System.out.println("Combined List: " + list2);

    }
}

arraylistl1={2,3,5,7}/*虚声明*/，L2={500,600}；
对于（inti=0；i=0；i++）L2.add（0，L1.get（i））
我看不到任何特定的内置函数可以做这件事。下面是解决这个问题的诀窍。
如果L1为{1,2}，L2为{3,4}，则

反转列表L1（它将变成{2,1}）
从后面迭代列表L2并添加
元素到L1。（您也可以反转L2，并在L1上执行addAll。如果
如果可以修改L2，就这样做）（L1将变成{2,1,4,3}）
反转列表L1（L1将变成{3,4,1,2}）
总时间复杂度：O（m+n），其中m是L1的大小，n是L2的大小

        List<Integer> li1 = new ArrayList<>();
        li1.add(1);
        li1.add(2);

        List<Integer> li2 = new ArrayList<>();
        li2.add(3);
        li2.add(4);

        Collections.reverse(li1);
        ListIterator<Integer> listIterator = li2.listIterator(li2.size());
        while (listIterator.hasPrevious())
        {
            Integer previous = listIterator.previous();
            li1.add(previous);
        }
        Collections.reverse(li1);
        System.out.println(li1);

List li1=new ArrayList（）；
li1.添加（1）；
li1.添加（2）；
List li2=新的ArrayList（）；
li2.加入（3）；
li2.加入（4）；
收款。反向（li1）；
ListIterator ListIterator=li2.ListIterator（li2.size（））；
while（listIterator.hasPrevious（））
{
整数previous=listIterator.previous（）；
li1.添加（先前）；
}
收款。反向（li1）；
系统输出打印Ln（li1）；
简单地说，您可以这样做：

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

l1.add("a");
l1.add("b");

l2.add("c");
l2.add("d");

l1.addAll(l2);

System.out.println(l1); // if you want result in list 1

l2.clear();

l2.addAll(l1);

System.out.println(l2); // if you want result in list 2

List l1=new ArrayList（）；
列表l2=新的ArrayList（）；
l1.添加（“a”）；
l1.添加（“b”）；
l2.添加（“c”）；
l2.添加（“d”）；
l1.addAll（l2）；
系统输出打印Ln（l1）；//如果您想得到列表1中的结果
l2.clear（）；
l2.addAll（l1）；
System.out.println（l2）；//如果你想得到清单2中的结果
使用：

在指定位置将指定集合中的所有元素插入此列表（可选操作）。将当前位于该位置的元素（如果有）和任何后续元素向右移动（增加其索引）。新元素将按指定集合的迭代器返回的顺序显示在此列表中。如果在操作进行过程中修改了指定的集合，则此操作的行为未定义。（请注意，如果指定的集合是此列表，并且它是非空的，则会发生这种情况。）

如果使用
0
作为索引，它将在
列表中预先添加给定的
集合
。例如：

ArrayList <Integer> L1 = {2, 3, 5, 7} /*Imaginary declaration*/, L2 = {500, 600}; 
for(int i=0; i<L1.size(); i--) L2.add(0, L1.get(i));

import java.util.ArrayList;
import java.util.List;

public class Main {

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

        list1.add("Item #1");
        list1.add("Item #2");

        list2.add("Item #3");
        list2.add("Item #4");

        System.out.println("List #1: " + list1);
        System.out.println("List #2: " + list2);

        list2.addAll(0, list1);

        System.out.println("Combined List: " + list2);

    }
}

如果不想使用Collections.addAll​（int索引，集合c）

publicstaticvoidmain（字符串[]args）{
List orginalList=新的ArrayList（Arrays.asList（“E”、“F”、“G”、“H”））；
系统输出打印项次（原始列表）；
集合。反向（原始列表）；
List newList=newarraylist（Arrays.asList（“A”、“B”、“C”、“D”））；
System.out.println（newList）；
集合。反向（新列表）；
orginalList.addAll（新列表）；
集合。反向（原始列表）；
系统输出打印项次（原始列表）；
}
所以您尝试获取一个ArrayList，然后将其内容添加到另一个ArrayList的开头？@FailingCoder是。更新了问题以获得更清晰的信息HappyBuddha希望将所有内容添加到列表的开头，而不添加其他内容arraylist@FailingCoder因此，请使用
L2.addAll
注意
List#addAll（Collection）
附加，但
List#addAll（int，Collection）
可以在任何有效索引处插入，包括
0
，它将在
集合的前面添加
。我认为这没有问题-如果需要，甚至可以分配
l1=l2
。不建议分配l1=l2，因为您现在为l1分配的l2引用都指向同一引用，所以将来如果您想更改l1或l2（任何一个）两者都会生效。这将是一个代价高昂的操作。每次我们在第0个索引处添加元素时，它之后的所有元素都将被移动。只有当L2是一个链接列表时，此操作才是有益的，因为它刚刚根据其他答案中的注释实现了add方法。我认为这样做是可以的。它在内部使用这个系统Arraycopy@FailingCoder注意，在“反向for循环”中应该使用
i--
，而不是使用
add（0，element）
在循环中反复使用
i++
@pravene，因为
ArrayList
被迫对每个调用执行
arraycopy
，因此，在循环中反复使用
i--
仍然会很昂贵。如果我们必须将整个
集合
预先添加到
列表
中，我们应该使用
List#addAll（int，Collection）
，因为它允许实现优化调用（例如
ArrayList
可能只需要调用
arraycopy
一次）。当然，您是正确的，在
ArrayList
中预先添加一个元素通常比添加该元素的成本更高。
LinkedList
几乎不会注意到差异。这很聪明，但为什么不将
List#addAll（int，Collection）
与
0一起使用呢