Java集合中的Collection.add（）方法和Collection.addAll（）方法有什么区别

我有两个

ArrayList

s（

a1

和

a2

），如下所示：

ArrayList a1 = new ArrayList();
a1.add(8);
a1.add("a1");

ArrayList a2 = new ArrayList();
a2.add(a1); //output : [[8, a1]]
a2.addAll(a1); //output : [[8, a1], 8, a1]

我的问题是:

为什么

a2.addAll（）

方法会打印两次数据

add

和

addAll

之间的确切区别是什么？这两种方法都返回布尔值

add（）

只需将对象添加到下一个索引：

public boolean add(E arg0) {
    this.ensureCapacityInternal(this.size + 1);
    this.elementData[this.size++] = arg0;
    return true;
}

addAll（）

将值复制到给定的

集合中

：

public boolean addAll(Collection<? extends E> arg0) {
        Object[] arg1 = arg0.toArray();
        int arg2 = arg1.length;
        this.ensureCapacityInternal(this.size + arg2);
        System.arraycopy(arg1, 0, this.elementData, this.size, arg2);
        this.size += arg2;
        return arg2 != 0;
    }

public boolean addAll（集合
为什么
a2.addAll（）
方法会将数据打印两次

因为在上一行调用
add（a1）
后，第一个副本已经存在

add（）
和
addAll（）
之间的确切区别是什么？这两种方法都返回
布尔值

add
添加单个项，而
addAll
逐个添加集合中的每个项。最后，如果集合已被修改，这两种方法都会返回
true
。对于
ArrayList
来说，这很简单，因为集合总是被修改的，但是其他集合，如
Set
，可能会被重新设置如果要添加的项目已经存在，请将
false

注意：部分混淆是因为您的列表是非类型化的，因此它们包含混合对象：
a1
混合字符串和数字，而
a2
混合字符串、数字和列表。为您的集合使用特定的泛型可以通过允许您执行
添加
或
a来防止这种混淆ddAll
，但不是两者都有：

List<String> a1 = new ArrayList<>();
a1.add("8");
a1.add("a1");
List<List<String>> a2 = new ArrayList<>();
a2.add(a1);
a2.addAll(a1); // <<== Does not compile
List<String> a3 = new ArrayList<>();
a3.add(a1);    // <<== Does not compile
a3.addAll(a1);

List a1=new ArrayList（）；
a1.添加（“8”）；
a1.添加（“a1”）；
列表a2=新的ArrayList（）；
a2.加入（a1）；
a2.addAll（a1）；//
添加
用于将单个元素添加到集合中。
添加所有
用于将源集合中的所有元素添加到集合中

在这种特殊情况下，您使用的是
ArrayList
而没有指定泛型参数，因此假定
ArrayList
。当您使用
add
添加
a1
时，它将
a1
视为单个对象

默认情况下，
ArrayList
将打印在方括号中，因此您可以看到
[[8，a1]]
。在使用
addAll
之后，您只需复制
a1
中的所有元素，并再次预期结果

希望有帮助！
方法
add（）
将一项添加到
ArrayList
，在本例中，将另一项添加到
ArrayList


方法
addAll（）
将一个
ArrayList
中的所有项添加到另一个
中

举例说明：

ArrayList a1 = new ArrayList();
a1.add(8);
a1.add("a1String"); // I changed the string value to be more clear what is a1 and what is the string "a1"
// a1 content: [8, "a1String"]

ArrayList a2 = new ArrayList();
a2.add(a1);
// a2 content: [[8, "a1String"]] - basically [a1]
// a2 has one item - a1

ArrayList a3 = new ArrayList();
a3.addAll(a1);
// a3 content: [8, "a1String"] - same content as a1
// a3 has all the items from a1

包装其他

导入java.util.ArrayList；
导入java.util.List

公开课实习{

public static void main(String[] args) {

//difference between add and addall 

    List<Integer> arrList = new ArrayList<Integer>(2);
    arrList.add(5);
    arrList.add(10);
    System.out.println("printing arrayLIst 1");

    for(Integer printNumber: arrList) {
        System.out.println(printNumber);
    }

    List<Integer> arr2List = new ArrayList<Integer>();
    arr2List.add(2);
    arr2List.add(4);
    System.out.println("printing arrayLIst 2");

    for(Integer printNumber:arr2List) {
        System.out.println(printNumber);
    }

    arrList.addAll(arr2List);
    System.out.println("printing updated arrayLIst 1");

    for(Integer printNumber: arrList) {
        System.out.println(printNumber);
    }   
}

publicstaticvoidmain（字符串[]args）{
//add和addall之间的区别
List arrList=新阵列列表（2）；
增加（5）；
增加（10）；
System.out.println（“打印阵列列表1”）；
用于（整数打印编号：arrList）{
系统输出打印LN（打印编号）；
}
List arr2List=new ArrayList（）；
arr2List.add（2）；
arr2列表添加（4）；
System.out.println（“打印阵列列表2”）；
用于（整数打印编号：arr2List）{
系统输出打印LN（打印编号）；
}
arrList.addAll（arr2List）；
System.out.println（“打印更新的arrayLIst 1”）；
用于（整数打印编号：arrList）{
系统输出打印LN（打印编号）；
}   
}

}

输出
打印阵列列表1

五,
十,

打印阵列列表2

二,
四,

打印更新的arrayLIst 1

五,
10
2.
4
不要使用原始泛型类。始终指定泛型类型，例如，
ArrayList
。是否费心阅读（附加指定元素）和（附加指定集合中的所有元素）的文档方法？@Andreas-是的，我读了文档，但看输出时感到困惑。thnx不管怎样，你的
a2
列表包含一个列表（
[8，a1]
）和两个值（
8
和
a1
）有什么让人困惑？