List初始化、集合复制

偏执的太偏执、 2023-01-06 01:15 168阅读 0赞

## ArrayList 初始化的三种方式 ##

### 1. 使用 Arrays.asList() 实现 ###

ArrayList<Object> obj = new ArrayList<Type>(Arrays.asList(Object o1, Object o2, Object o3, ....so on));

> 案例：
> 
>     List<String> strList = new ArrayList<String>(Arrays.asList("2", "5", "8", "0"));
> 
> ArrayList值：`[2, 5, 8, 0]`

### 2. 通过 匿名内部类 调用 add 方法实现 ###

List<Object> objList = new ArrayList<Object>() { {  add(Object o1); add(Object o2); add(Object o3); ...}};

> 案例：
> 
>     List<String> strList = new ArrayList<String>(){ { 
>                add("str1"); add("str2"); add("str3");
>            }};
> 
> ArrayList值：`[str1, str2, str3]`

### 3. 使用 Collections.ncopies() 复制实现指定数目相同内容的赋值 ###

// 把元素 element 复制指定次数 num 次，赋值给ArrayList
        List<Object> objList = new ArrayList<Object>(Collections.nCopies(Integer num, Object element));

> 案例：
> 
>     List<String> strList = new ArrayList<>(Collections.nCopies(10, "str"));
> 
> ArrayList值：`[str, str, str, str, str, str, str, str, str, str]`

--------------------

## List集合复制 ##

User类

class User{ 
        private String a;
        private String b;
    }

### 1. 通过循环遍历复制List集合 ###

List<User> userList = new ArrayList<>();
            User user0 = new User("a0", "b0");
            userList.add(user0);
            userList.add(new User("a1", "b1"));
            userList.add(new User("a2", "b2"));
            //创建临时集合，通过循环遍历赋值
            List<User> temp = new ArrayList<>();
            for(User user: userList){ 
                temp.add(user);
            }
    		//或者通过new 来赋值
    		/* for(User user: userList){ User u = new User(); u.setA(user.getA()); u.setB(user.getB()); temp.add(user); } */
            //修改其中任意集合中的对象属性（修改userList或者temp中的对象）
            userList.get(0).setA("修改AAA000");
            userList.get(0).setB("修改BBB000");
            userList.get(1).setA("修改AAA111");
            userList.get(1).setB("修改BBB111");
    
            System.out.println("userList : " + userList);
            System.out.println("temp : " + temp);

运行结果：

> userList : \[User\{a=‘修改AAA000’, b=‘修改BBB000’\}, User\{a=‘修改AAA111’, b=‘修改BBB111’\}, User\{a=‘a2’, b=‘b2’\}\]  
> temp : \[User\{a=‘修改AAA000’, b=‘修改BBB000’\}, User\{a=‘修改AAA111’, b=‘修改BBB111’\}, User\{a=‘a2’, b=‘b2’\}\]

发现：修改列表中的对象的属性值，另一个列表的值也发生了改变。

原因：对象之间的值是复制的引用地址，对User的属性A,B修改都是修改的同一常量池的值。

解决办法：通过new对象，开辟新的内存空间，来修改值。

运行结果：

> userList : \[User\{a=‘AAA000’, b=‘BBB000’\}, User\{a=‘a1’, b=‘b1’\}, User\{a=‘a2’, b=‘b2’\}\]  
> temp : \[User\{a=‘a0’, b=‘b0’\}, User\{a=‘a1’, b=‘b1’\}, User\{a=‘a2’, b=‘b2’\}\]

发现：对userList列表的修改，对temp的值没有发生变化

原因：因为new对象，开辟了新的内存空间，所以两个指向的内存是不同的。

同理：new一个对象，增加到列表中去，对另一个列表也是没有影响的

运行结果：

> userList : \[User\{a=‘a0’, b=‘b0’\}, User\{a=‘a1’, b=‘b1’\}, User\{a=‘a2’, b=‘b2’\}, User\{a=‘addA’, b=‘addB’\}\]
> 
> temp : \[User\{a=‘a0’, b=‘b0’\}, User\{a=‘a1’, b=‘b1’\}, User\{a=‘a2’, b=‘b2’\}\]

发现：新增是不会对复制的列表有什么影响的。

### 2. 可以采用ArrayList的addAll()方法来进行复制集合 ###

addAll()方法：传入参数List，将List中所有的元素加入到新的List集合去，前List会增加的元素个数等于传入的List的大小。

List<User> userList = new ArrayList<>();
            User user0 = new User("a0", "b0");
            userList.add(user0);
            userList.add(new User("a1", "b1"));
            userList.add(new User("a2", "b2"));
            
            //创建临时集合，通过addAll方法复制userList集合
            List<User> temp = new ArrayList<>();
            temp.addAll(userList);
            
            userList.get(0).setA("修改AAA000");
            userList.get(0).setB("修改BBB000");
            System.out.println("userList : " + userList);
            System.out.println("temp : " + temp);

运行结果：

> userList : \[User\{a=‘修改AAA000’, b=‘修改BBB000’\}, User\{a=‘a1’, b=‘b1’\}, User\{a=‘a2’, b=‘b2’\}\]
> 
> temp : \[User\{a=‘修改AAA000’, b=‘修改BBB000’\}, User\{a=‘a1’, b=‘b1’\}, User\{a=‘a2’, b=‘b2’\}\]

### 3. 其他方式 ###

//创建临时变量（toArray返回Object）
    List<Object> temp =  Arrays.asList(userList.toArray());
    //直接使用 = 
    // 这种方式只是定义一个引用，指向源集合userList的内容，对其修改新增，两个集合内容变化相同
    List<User> temp = userList;	
    //这种方式，修改两个集合变化相同，新增，另一个无变化
    List<User> temp = new ArrayList<>(userList);

上述方式其实都是浅层复制，当修改原list时，新list也会改变（增加不会），不能达到生成一个完全新的互不影响的list的效果。

### 4. 通过Stream复制List生成两个互不影响的集合 ###

List<User> userList = new ArrayList<>();
            User user0 = new User("a0", "b0");
            userList.add(user0);
            userList.add(new User("a1", "b1"));
            userList.add(new User("a2", "b2"));
    
    		//stream流复制（深度复制）
            List<User> temp = userList.stream().map(user -> { 
                //new对象，开辟空间
                User u = new User();
                u.setA(user.getA());
                u.setB(user.getB());
                return u;
            }).collect(Collectors.toList());
            //修改
            userList.get(0).setA("修改AAA000");
            userList.get(0).setB("修改BBB000");
            System.out.println("userList : " + userList);
            System.out.println("temp : " + temp);

运行结果：

> userList : \[User\{a=‘修改AAA000’, b=‘修改BBB000’\}, User\{a=‘a1’, b=‘b1’\}, User\{a=‘a2’, b=‘b2’\}\]  
> temp : \[User\{a=‘a0’, b=‘b0’\}, User\{a=‘a1’, b=‘b1’\}, User\{a=‘a2’, b=‘b2’\}\]

发现：通过Stream对List进行复制之后，对其中一个list进行修改，不会影响另一个list的值。