Java 中的数据类型分为基本数据类型和引用数据类型。对于这两种数据类型，在进行赋值操作、用作方法参数或返回值时，会有值传递和引用（地址）传递的差别。
Map对象
测试01-等号赋值：
@Test
public void TestCopy() {
Map<String, Object> beginByMap = new HashMap<>();
beginByMap.put("key01", "Value01");
Map<String, Object> endByMap = beginByMap;
endByMap.put("key02", "Value02");
System.out.println("beginByMap:" + beginByMap);
System.out.println("endByMap:" + endByMap);
}
对象复制或者说拷贝在等号下的引用类型是浅拷贝：{拷贝分为浅拷贝和深度拷贝}
可以看出 对象的 = 号赋值时 是浅复制，两个对象实际引用的是同一个地址，所以不管谁改变了，都会变。。
有时候我们又需要两个对象相等但是互相操作不干扰
浅拷贝是按位拷贝对象，它会创建一个新对象，这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型，拷贝的就是基本类型的值；如果属性是内存地址（引用类型），拷贝的就是内存地址 ，因此如果其中一个对象改变了这个地址，就会影响到另一个对象。
深拷贝，在拷贝引用类型成员变量时，为引用类型的数据成员另辟了一个独立的内存空间，实现真正内容上的拷贝。
(1) 对于基本数据类型的成员对象，因为基础数据类型是值传递的，所以是直接将属性值赋值给新的对象。基础类型的拷贝，其中一个对象修改该值，不会影响另外一个（和浅拷贝一样）。
(2) 对于引用类型，比如数组或者类对象，深拷贝会新建一个对象空间，然后拷贝里面的内容，所以它们指向了不同的内存空间。改变其中一个，不会对另外一个也产生影响。
(3) 对于有多层对象的，每个对象都需要实现 Cloneable 并重写 clone() 方法，进而实现了对象的串行层层拷贝。
(4) 深拷贝相比于浅拷贝速度较慢并且花销较大。
我这里JDK1.8
结果是：不管使用MAP的PUTALLH还是HashMap的PutAll都是属于深度拷贝
但是网上一部分人说的是HashMap才是深度拷贝，而MAp的不是深度拷贝，这个有待考察
@Test
public void TestCopy() {
Map<String, Object> beginByMap = new HashMap<>();
beginByMap.put("key01", "ADC");
//使用浅拷贝
Map<String, Object> endByMap = new HashMap<>();
endByMap.putAll(beginByMap);
endByMap.put("key02", "ABC");
endByMap.put("key03", "ADA");
endByMap.remove("key01");
System.out.println("beginByMap:" + beginByMap);
System.out.println("endByMap:" + endByMap);
HashMap<String, Object> b = new HashMap<>();
b.putAll(beginByMap);
b.put("key02", "ADA");
b.put("key03", "ADA");
b.remove("key01");
System.out.println(b);
System.out.println(beginByMap);
}
List对象
几种常见的浅拷贝：
1.直接用“=”赋值
2.遍历循环复制
3.使用List实现类的构造方法
4.使用list.addAll()方法
list的深拷贝
LIST<泛型> 泛型一定是Object类型，，实现cloneable接口并且重写clone方法。
clone方法：就是深度拷贝更多的如下
public class MyTest {
@Test
public void TestCopy() throws Exception {
List<Person> list1 = new ArrayList<Person>();
list1.add(new Person("aaa"));
list1.add(new Person("bbb"));
// 第一种方法：通过构造函数来实现，它里面调用了Arrays.copyOf(),copyOf又调用了System.arraycopy
List<Person> list2 = new ArrayList<Person>(list1);
list2.get(0).setName("ccc");
System.out.println("list1 ==>" + list1);
System.out.println("list2 ==>" + list2);
/** 此时list1 和list2 输出相同，说明是引用*/
// 第二种方法：addAll方法，它调用了System.arraycopy
// System.arraycopy：源数据-->目的数据
// Arrays.copyOf():源数据及长度，数据类型，它里面调用了System.arraycopy
List<Person> list3 = new ArrayList<Person>();
list3.addAll(list1);
list3.get(0).setName("ddd");
System.out.println("list1 ==>" + list1);
System.out.println("list3 ==>" + list3);
/** 此时list1 和list3 输出相同，说明是引用*/
// 第三种方法：实现clone来实现
List<Person> list4 = new ArrayList<Person>();
for (int i = 0; i < list1.size(); i++) {
list4.add(list1.get(i).clone());
}
list4.get(0).setName("eee");
System.out.println("list1 ==>" + list1);
System.out.println("list4 ==>" + list4);
/** 此处clone了，但要注意实现了cloneable接口只能对原始类型和String进行clone，如果是引用类型，则要进行深clone，复制内容或者对象再次clone*/
// 第四种方法：通过序列化来实现
List<Person> list5 = null;
OutputStream bo = new ByteArrayOutputStream();
ObjectOutputStream oo = new ObjectOutputStream(bo);
oo.writeObject(list1);
InputStream bi = new ByteArrayInputStream(((ByteArrayOutputStream) bo).toByteArray());
ObjectInputStream oi = new ObjectInputStream(bi);
list5 = (List<Person>) oi.readObject();
list5.get(0).setName("ggg");
System.out.println("list1 ==>" + list1);
System.out.println("list5 ==>" + list5);
/** 通过这种方法也能实现深拷贝*/
// 第五种方法： Collection.copy，它的实现过程是通过遍历然后set进入
List<Person> list6 = new ArrayList<Person>(Arrays.asList(new Person[list1.size()]));
Collections.copy(list6, list1);
list6.get(0).setName("hhh");
System.out.println("list1 ==>" + list1);
System.out.println("list6 ==>" + list6);
/** list1 和list6 输出结果是相同的*/
}
}
class Person implements Cloneable, Serializable {
private String name;
public Person(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return this.name;
}
@Override
protected Person clone() throws CloneNotSupportedException {
return (Person) super.clone();
}
public static <T> List<T> deepCopy(List<T> src)
throws IOException, ClassNotFoundException
{
ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
ObjectOutputStream out = new ObjectOutputStream(byteOut);
out.writeObject(src);
ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());
ObjectInputStream in = new ObjectInputStream(byteIn);
return (List<T>)in.readObject();
}
}
