前言
事件起因是由于同事使用ArrayList的带参构造方法进行ArrayList对象复制,修改新的ArrayList对象中的元素(对象)的成员变量时也会修改原ArrayList中的元素(对象)的成员变量。

下面会通过复盘代码向大家重现遇到的问题

复盘代码
用户类
public class User {

private Integer id;

private String name;

public User(Integer id, String name) {
this.id = id;
this.name = name;
}

@Override
public String toString() {
return "User{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}

public Integer getId() {
return id;
}

public void setId(Integer id) {
this.id = id;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
问题重现示例
import java.util.ArrayList;
import java.util.List;

public class ArrayListReference {

public static void main(String[] args) {
// 原用户列表
List<User> users = new ArrayList<>();
for (int i = 0; i < 10; i++) {
users.add(new User(i, "test"));
}
// 新用户列表
List<User> newUsers = new ArrayList<>(users);
for (int j = 0; j < newUsers.size(); j++) {
// 修改新用户列表的用户名
newUsers.get(j).setName(String.valueOf(j));
}
// 打印新用户列表
System.out.println("newUsers:" + newUsers);
// 重新打印原用户列表
System.out.println("After update newUsers,users:" + users);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
示例运行结果
users:[User{id=0, name='test'}, User{id=1, name='test'}, User{id=2, name='test'}, User{id=3, name='test'}, User{id=4, name='test'}, User{id=5, name='test'}, User{id=6, name='test'}, User{id=7, name='test'}, User{id=8, name='test'}, User{id=9, name='test'}]
newUsers:[User{id=0, name='0'}, User{id=1, name='1'}, User{id=2, name='2'}, User{id=3, name='3'}, User{id=4, name='4'}, User{id=5, name='5'}, User{id=6, name='6'}, User{id=7, name='7'}, User{id=8, name='8'}, User{id=9, name='9'}]
After update newUsers,users:[User{id=0, name='0'}, User{id=1, name='1'}, User{id=2, name='2'}, User{id=3, name='3'}, User{id=4, name='4'}, User{id=5, name='5'}, User{id=6, name='6'}, User{id=7, name='7'}, User{id=8, name='8'}, User{id=9, name='9'}]
1
2
3
分析
问题
为什么使用了ArrayList的构造方法重新构造一个新的ArrayList后,操作新ArrayList对象中的元素时会影响到原来的ArrayList中的元素呢?

首先需要分析ArrayList的构造方法

ArrayList源码分析
下面是示例中调用的ArrayList构造方法的源码

public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
if ((size = elementData.length) != 0) {
if (elementData.getClass() != Object[].class)
// 此处为关键代码,此处就是数组元素的复制方法
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
this.elementData = EMPTY_ELEMENTDATA;
}
}
1
2
3
4
5
6
7
8
9
10
从源码中得知数组复制的关键代码为

elementData = Arrays.copyOf(elementData, size, Object[].class);
1
下面进入Arrays.copyOf()的源码进行研究

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
@SuppressWarnings("unchecked")
// 构造一个新的数组对象
T[] copy = ((Object)newType == (Object)Object[].class)
? (T[]) new Object[newLength]
: (T[]) Array.newInstance(newType.getComponentType(), newLength);
// 将原数组元素复制到新数组中
System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));
return copy;
}
1
2
3
4
5
6
7
8
9
10
从上面的源码得知关键代码为

System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));
1
以下为System.arraycopy()方法的源码

public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length);
1
由于System.arraycopy()方法为native方法,很难跟踪其实现代码。不过可以从方法注释中可以知道这个方法的特点:

Copies an array from the specified source array, beginning at the specified position, to the specified position of the destination array. A subsequence of array components are copied from the source array referenced by src to the destination array referenced by dest. The number of components copied is equal to the length argument. The components at positions srcPos through srcPos+length-1 in the source array are copied into positions destPos through destPos+length-1, respectively, of the destination array.

翻译结果为

将数组从指定的源数组(从指定位置开始)复制到目标数组的指定位置。将数组组件的子序列从src引用的源数组复制到dest引用的目标数组,复制的组件数量等于length参数。源数组中通过srcPos+length-1位置的组件分别复制到目标数组中通过destPos+length-1位置的destPos。

既然ArrayList的构造方法是复制新的数组,那么是为什么呢?这里提前透露一下结论:数组元素为对象时,实际上存储的是对象的引用,ArrayList进行数组复制也只是复制了对象的引用。所以才会出现一开始说的问题

再次验证
下面将会使用一个数组的复制示例验证结论,使用==来比较对象引用是否相同

问题重现示例
import java.util.Arrays;

public class ArrayReference {

public static void main(String[] args) {
// 原用户列表
User[] users = new User[10];
for (int i = 0; i < users.length; i++) {
users[i] = (new User(i, "test"));
}
// 新用户列表
User[] newUsers = Arrays.copyOf(users, users.length);
for (int j = 0; j < users.length; j++) {
// 比较对象引用
System.out.println(j + ":" + (users[j] == newUsers[j]));
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
示例运行结果
0:true
1:true
2:true
3:true
4:true
5:true
6:true
7:true
8:true
9:true
1
2
3
4
5
6
7
8
9
10
结果分析
从运行结果中可以得知,上面提出的结论是正确的。即数组元素为对象时,实际上存储的是对象的引用。

解决办法
解决方法很简单,只需要遍历对象数组中的元素,调用对象的构造方法构造新的对象并加入新的数组中即可

解决办法示例
public class ArrayListReferenceSolution {

public static void main(String[] args) {
// 原用户列表
List<User> users = new ArrayList<>();
for (int i = 0; i < 10; i++) {
users.add(new User(i, "test"));
}
// 新用户列表
List<User> newUsers = new ArrayList<>();
for (int j = 0; j < users.size(); j++) {
// 使用构造方法构造新的对象
newUsers.add(new User(users.get(j).getId(),users.get(j).getName()));
}
for (int k= 0; k < users.size(); k++) {
// 比较对象引用
System.out.println(k + ":" + (users.get(k) == newUsers.get(k)));
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
示例运行结果
0:false
1:false
2:false
3:false
4:false
5:false
6:false
7:false
8:false
9:false
1
2
3
4
5
6
7
8
9
10
结果分析
从运行结果可以得知,使用示例中的方法就可以复制出一个不会干扰原ArrayList的对象。
---------------------

Java中ArrayList的对象引用问题的更多相关文章

  1. java中ArrayList 、LinkList区别

    转自:http://blog.csdn.net/wuchuanpingstone/article/details/6678653 个人建议:以下这篇文章,是从例子说明的方式,解释ArrayList.L ...

  2. JAVA中ArrayList用法

    JAVA中ArrayList用法 2011-07-20 15:02:03|  分类: 计算机专业 |  标签:java  arraylist用法  |举报|字号 订阅     Java学习过程中做题时 ...

  3. Java中ArrayList与LinkedList的区别

    Java中ArrayList与LinkedList的区别 一般大家都知道ArrayList和LinkedList的区别: 1. ArrayList的实现是基于数组,LinkedList的实现是基于双向 ...

  4. Java中arraylist和linkedlist源代码分析与性能比較

    Java中arraylist和linkedlist源代码分析与性能比較 1,简单介绍 在java开发中比較经常使用的数据结构是arraylist和linkedlist,本文主要从源代码角度分析arra ...

  5. Java中对象、对象引用、堆、栈、值传递以及引用传递的详解

    Java中对象.对象引用.堆.栈.值传递以及引用传递的详解 1.对象和对象引用的差别: (1).对象: 万物皆对象.对象是类的实例. 在Java中new是用来在堆上创建对象用的. 一个对象能够被多个引 ...

  6. java中ArrayList 和 LinkedList 有什么区别

    转: java中ArrayList 和 LinkedList 有什么区别 ArrayList和LinkedList都实现了List接口,有以下的不同点:1.ArrayList是基于索引的数据接口,它的 ...

  7. Java中ArrayList和LinkedList差别

    一般大家都知道ArrayList和LinkedList的大致差别: 1.ArrayList是实现了基于动态数组的数据结构,LinkedList基于链表的数据结构.  2.对于随机訪问get和set.A ...

  8. Java中ArrayList和LinkedList区别 时间复杂度 与空间复杂度

    一般大家都知道ArrayList和LinkedList的大致区别:      1.ArrayList是实现了基于动态数组的数据结构,LinkedList基于链表的数据结构.      2.对于随机访问 ...

  9. Java中ArrayList的自我实现

    对于ArrayList相比大家都很熟悉,它是java中最常用的集合之一.下面就给出它的自我实现的java代码. 需要说明的一点是,它是基于数组创建的.所以它在内存中是顺序存储,对于查找十分的方便. p ...

随机推荐

  1. bzoj1412: [ZJOI2009]狼和羊的故事(最小割)

    传送门 首先,考虑只有狼和羊怎么办.我们把源点向所有羊连边,容$inf$,所有狼向汇点连边,容$inf$,然后羊向周围所有的狼连边,容$1$.那么,只要求一个割就能把狼和羊给分开,求一个最小割就是答案 ...

  2. Oracle的RBO和CBO

    Oracle的优化器有两种优化方式,即基于规则的优化方式(Rule-Based Optimization,简称为RBO)和基于代价的优化方式(Cost-Based Optimization,简称为CB ...

  3. Tomcat热部署的实现原理

    Tomcat热部署机制 对于Java应用程序来说,热部署就是在运行时更新Java类文件.在基于Java的应用服务器实现热部署的过程中,类装入器扮演着重要的角色.大多数基于Java的应用服务器,包括EJ ...

  4. Listener、Filter、Servlet的创建及初始化顺序

    一.创建顺序 1.web.xml文件中的加载顺序为:listener-filter-servlet 2.如果web.xml中配置了<context-param>,初始化顺序: contex ...

  5. php路径问题

    ./ 是在当前目录开始寻找文件/ 是在下一级目录开始寻找文件 ../ 这个是在上一级目录开始寻找文件 $_SERVER['DOCUMENT_ROOT']获取站点根目录 __FILE__获取当前文件的完 ...

  6. BufferedReader readLine

    import org.apache.commons.codec.binary.Base64;import org.apache.commons.codec.digest.DigestUtils; In ...

  7. mitmproxy——抓取http、https

    mitmproxy是一个支持HTTP和HTTPS的抓包程序,有类似Fiddler.Charles的功能.除了命令行形式的控制台,mitmproxy还有两个关联组件:mitmdump和mitmweb. ...

  8. (转)在CentOS中修改中文字符集

    虽然在实际工作环境下,Linux中不建议使用中文,但是如果一定要进行中文显示,尤其对于刚接触linux且英语基础不太好的人来说,那么本文具有一定的参考价值. 本文介绍在linux的shell环境下优化 ...

  9. Unity3D游戏高性能战争迷雾系统实现

    一 效果图 先上效果图吧,这是为了吸引到你们的ヽ(。◕‿◕。)ノ゚ 战争迷雾效果演示图 战争迷雾调试界面演示图 由于是gif录制,为了压缩图片,帧率有点低,实际运行时,参数调整好是不会像这样一卡一顿的 ...

  10. .net 向新页面跳转的语句

    1. href='##' onclick=\"window.open('../DataSplit/DrugInfo_ManualVersionViewNew.aspx?id=" + ...