java深复制

㈠ java中深克隆与浅克隆的区别

深克隆与浅克隆

大家知道，对象是互相引用的，即对象中可能包含了另一个对象的引用，举例如：有一个Order对象，Order对象中又包含了LineItems对象，然后LineItems对象又包含了Item对象。

好了，现在我有一个Order对象order1,它包含了一个LineItems对象items，这表示的是有一个订单order1，订单的内容是items。

好的，现在有另一个客户想要一份订单，内容跟order1完全一样，那么在系统的逻辑层我们怎么做呢？很简单，order2=order1.clone(). 我们知道clone方法是在内存中生成一个新的对象，而不是只得到原对象的引用。这时候，有人说话了：“哦，明白了我们对order2的成员变量进行修改，是不会影响order1的。” 很可惜，这句话只对了一半。

假设order类有一个成员变量name，当然改变order2.name不会影响order1.name，因为他们在不同的内存区域。但是如果改变 order1.items呢？很遗憾，简单地使用order1.clone，是会影响到order2.items的。原因很简单，就是因为clone方法默认的是浅克隆，即不会克隆对象引用的对象，而只是简单地复制这个引用。所以在上例中，items对象在内存中只有一个，order1和order2都指向它，任何一个对象对它的修改都会影响另一个对象。

那相对浅克隆，深克隆自然就是会克隆对象引用的对象了。也就是说，在上例中，改变order1.items并不会影响order2.items了。因为内存中有两个一样的items。

如果实现深克隆？

一个方法自然是重写clone方法，添加如order.items=(LineItems)items.clone()的语句，也就是人为地添加对引用对象的复制。这个方法的缺点是如果引用对象有很多，或者说引用套引用很多重，那么太麻烦了。业界常用的方法是使用串行化然后反串行化的方法来实现深克隆。由于串行化后，对象写到流中，所有引用的对象都包含进来了，所以反串行化后，对等于生成了一个完全克隆的对象。绝！

这个方法的要求是对象（包括被引用对象）必须事先了Serializable接口，否则就要用transient关键字将其排除在复制过程中。

㈡ 什么是深拷贝和浅拷贝

浅拷贝就是指对象复制的时候只复制一层；深拷贝是指复制对象的所有层级。

深拷贝和浅拷贝，主要是对象发生复制的时候，根据复制的层级不同来区分的。很多人在这里经常变量赋值发生混淆。对于JavaScript数组等复杂的数据类型来说，将其赋值给其它变量，其实只是复制了对象的地址给它，两个变量指向的是同一个对象，因此普通的赋值既不是深拷贝也不是浅拷贝。

深拷贝和浅拷贝需要注意的地方就是可变元素的拷贝：

在浅拷贝时，拷贝出来的新对象的地址和原对象是不一样的，但是新对象里面的可变元素（如列表）的地址和原对象里的可变元素的地址是相同的，也就是说浅拷贝它拷贝的是浅层次的数据结构（不可变元素），对象里的可变元素作为深层次的数据结构并没有被拷贝到新地址里面去。

而是和原对象里的可变元素指向同一个地址，所以在新对象或原对象里对这个可变元素做修改时，两个对象是同时改变的，但是深拷贝不会这样，这个是浅拷贝相对于深拷贝最根本的区别。

㈢ java二维数组怎么复制，，array方法行吗麻烦给个例子。谢啦

java的多维数组的：希望采纳
class C{
public static void main(String args[]){
int a[][] = {{1,2,3},{4,5,6}};
int b[][] = new int[a.length][a[0].length];
System.array(a,0,b,0,a.length); //通过array()函数拷贝数组
b[0][0] = 4; //改变数组b[0][0]的值
System.out.println("a[][]");
for(int i=0;i<2;i++){
for(int j=0;j<3;j++){
System.out.print(a[i][j]+" ");
}
System.out.println();
}
System.out.println("b[][]");
for(int i=0;i<2;i++){
for(int j=0;j<3;j++){
System.out.print(b[i][j]+" ");
}
System.out.println();
}
}
打印的结果如下：
a[][]
4 2 3
4 5 6
b[][]
4 2 3
4 5 6
而如果把上述程序中的二维数组改为一维数组，结果却不同。程序如下：
class C{
public static void main(String args[]){
int a[] = {1,2,3};
int b[] = new int[a.length];
System.array(a,0,b,0,a.length); //通过array()函数拷贝数组
b[0] = 4; //改变数组b[0]的值
System.out.println("a[]:");
for(int i=0;i<3;i++){
System.out.print(a[i] + " ");
}
System.out.println();
System.out.println("b[]:");
for(int i=0;i<3;i++){
System.out.print(b[i] + " ");
}
}
}
打印结果如下：
a[]:
1 2 3
b[]:
4 2 3

在
第一个程序中，用b[0][0] =
4;只改变了数组b[0][0]的值，可是结果却是数组a[0][0]的值也发生了改变。而在第二个程序中，由于是一个一维数组，改变了b[0]的
值，a[0]的值却并没有受到影响，所以问题可能就出在数组的维数上。第一个程序中的a 是一个数组的数组(java
中没有多维数组的概念，只有数组的数组),同理b 也是，那么a 含有两个元素，第一个是指向(1,2,3)
这个数组的引用，第二个是指向(4,5,6）这个数组的引用，而arrayCopy 就是负责把数组的内容 过去的，因此 a 的内容 (2
个引用) 被 到b 中去了，因此你对b[0][0] 做修改，a 也会同样跟着变化.
在JAVA里面，可以用复制语句“A=B”给基本类型的数据传递值，但是如果A,B是两个同类型的数组，复制就相当于将一个数组变量的引用传递给另一个数组；如果一个数组发生改变，那么引用同一数组的变量也要发生改变。
JAVA中复制数组元素值的的方法指深拷贝
1 使用for循环，将数组的每个元素复制（需要将每个对象调用clone方法，才能实现真正的复制）
2 使用clone方法，得到数组的值，而不是引用
3 使用System.array方法
注意：
1.上面方法中array效率较高。
2. 以上所说的拷贝数组的方法，只是针对一维数组，对于多维数组，要在每一维用以上方法进行复制才能实现复制数组元素的值而不是引用。
3. clone 和 array对二维数组进行复制时，是浅拷贝， 即
Object[][] aa;
Object[][] bb = aa.clone();
//or bb＝System.array(aa,0,bb, 0, bb.length);
则：
boolean b1 = ( aa[i] == bb[i] ); //false
boolean b2 = (aa[i][j] == bb[i][j]); //true, 可见数组元素只复制了引用。新旧数组指向相同的内存地址，（不论对象数组，还是基本类型数组）。
/**
* 数组的浅拷贝是指数组拷贝时，只拷贝了数组的地址，新旧数组指向同一数据
* 数组的深拷贝，不论数据是基本类型，还是对象类型，都是一样的。
* 对数组来说，不一样的地方在于，当为数组元素赋值时，基本类型值传递，对象类型是引用传递。
*
*/
Object[] a = new Object[]{"String", new Integer(1)};
Object[] b = a;

/**
* 数组深拷贝的方法有如下几种：
* 1。 调用clone
* 2。 调用System.array
* 以上两种对基本类型和对象类型数据效果等同。
* 3。 使用FOR循环，将数组的每个元素复制。（注意调用clone方法）
*
*/

/*
* 当数组数据是基本类型时，
*/
// int[] array = new int[]{0,1,2,3,4};
// int[] = array.clone(); //1.拷贝数据
// System.out.println( .equals(array));
// System.out.println( == array );
// for (int i = 0; i < .length; i++) {
// System.out.print( [i]+", " );
// [i]++; //2.改变新数组数据内容
// System.out.print( [i]+", " );
// System.out.println( array[i]+","); //3.不影响原始数组
// }
// System.out.println();

/*
* 当数组数据是对象类型时，
*/
// Object[] src = new Object[]{ new String("Zhao"),
// Integer.valueOf(1),
// Integer.valueOf(2),
// Integer.valueOf(3),
// Integer.valueOf(4)};
//
// Object[] dest = src.clone(); //1.拷贝数据
//
//// Object[] dest = new Object[5];
//// System.array(src, 0, dest, 0, dest.length);
//
// System.out.println( dest.equals(src));
// System.out.println( dest == src );
// for (int i = 0; i < dest.length; i++) {
// System.out.print( dest[i]+", " );
// dest[i] = new String("KE"); //2.改变新数组内容
// System.out.print( dest[i]+", " );
// System.out.println( src[i]+","); //3.不影响原始数组
// }
// System.out.println();
/**
* 对多维数组(多维基本类型数组和多维对象数组完全一致。)
*
*/
//多维基本类型数组
int[][] aa = new int[][]{
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};

// //多维对象类型数组
// Object[][] aa = new Object[][]{
// { Integer.valueOf(1),Integer.valueOf(2),Integer.valueOf(3) },
// { Integer.valueOf(4),Integer.valueOf(5),Integer.valueOf(6) },
// { Integer.valueOf(7),Integer.valueOf(8),Integer.valueOf(9) }
// };

/**
* 一维数组下的深拷贝在 多维数组 只是浅拷贝！！
*/
int[][] bb = aa.clone(); //一维数组下的深拷贝，对于二维数组只是浅拷贝！！
// int[][] bb = new int[aa.length][aa[0].length];
// System.array(aa, 0, bb, 0, aa.length);

// Object[][] bb = aa.clone();
//// Object[][] bb = new Object[3][3];
//// System.array(aa, 0, bb, 0, aa.length); //一维数组下的深拷贝，对于二维数组只是浅拷贝！！

/**
* 二维数组的深拷贝的实现方式！！！ 转为一维数组拷贝。
*/
// for (int i = 0; i < bb.length; i++) { //实现深拷贝的方法！！！！！！！！！！！！
// System.array(aa[i], 0, bb[i], 0, aa[i].length);
// // bb[i] = aa[i].clone();
// }

System.out.println("＃＃ 初始 aa:" ); //1. 初始原数组
for (int i = 0; i < aa.length; i++) {
for (int j = 0; j < aa[i].length; j++) {
System.out.print(aa[i][j]+" ");
}
System.out.println( );
}

System.out.println("＃＃ bb = aa.clone() 后bb:" ); //2. 新数组（值等于原数组的值）
for (int i = 0; i < bb.length; i++) {
for (int j = 0; j < bb[i].length; j++) {
System.out.print(bb[i][j]+" ");
}
System.out.println( );
}

System.out.println("＃＃ bb改变后:" ); //3.改变新数组后
for (int i = 0; i < bb.length; i++) {
for (int j = 0; j < bb[i].length; j++) {
bb[i][j] += 10; //for 多维基本类型数组
// bb[i][j] = new String("Zhao"); //for 多维对象类型数组
System.out.print(bb[i][j]+" ");
}
System.out.println( );
}

System.out.println("＃＃ bb改变后， aa:" ); //4.输出原数组
for (int i = 0; i < aa.length; i++) {
for (int j = 0; j < aa[i].length; j++) {
System.out.print(aa[i][j]+" ");
}

还有和c++不同，java定义int [][]a=new int[3][];是没有问题的，c和c++后面就是必须要有维数，int a[][3];。
如果list里面全是String[]，转为String[][]，使用
(String[][]) bodyDataList.toArray(new String[bodyDataList.size()][]);这样就能转成功，还一直不清楚toArray(x)x里面的东西，因为java里面只有array对象

㈣ 如何使Java中的InputStream的深层复制

我们知道在Java中存在这个接口Cloneable，实现该接口的类都会具备被拷贝的能力，同时拷贝是在内存中进行，在性能方面比我们直接通过new生成对象来的快，特别是在大对象的生成上，使得性能的提升非常明显。然而我们知道拷贝分为深拷贝和浅拷贝之分，但是浅拷贝存在对象属性拷贝不彻底问题。关于深拷贝、浅拷贝的请参考这里：渐析java的浅拷贝和深拷贝

一、浅拷贝问题

我们先看如下代码：

[java] view plain
public class Person implements Cloneable{
/** 姓名 **/
private String name;

/** 电子邮件 **/
private Email email;

public String getName() {
return name;
}

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

public Email getEmail() {
return email;
}

public void setEmail(Email email) {
this.email = email;
}

public Person(String name,Email email){
this.name = name;
this.email = email;
}

public Person(String name){
this.name = name;
}

protected Person clone() {
Person person = null;
try {
person = (Person) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}

return person;
}
}

public class Client {
public static void main(String[] args) {
//写封邮件
Email email = new Email("请参加会议","请与今天12:30到二会议室参加会议...");

Person person1 = new Person("张三",email);

Person person2 = person1.clone();
person2.setName("李四");
Person person3 = person1.clone();
person3.setName("王五");

System.out.println(person1.getName() + "的邮件内容是：" + person1.getEmail().getContent());
System.out.println(person2.getName() + "的邮件内容是：" + person2.getEmail().getContent());
System.out.println(person3.getName() + "的邮件内容是：" + person3.getEmail().getContent());
}
}
--------------------
Output:
张三的邮件内容是：请与今天12:30到二会议室参加会议...
李四的邮件内容是：请与今天12:30到二会议室参加会议...
王五的邮件内容是：请与今天12:30到二会议室参加会议...

在该应用程序中，首先定义一封邮件，然后将该邮件发给张三、李四、王五三个人，由于他们是使用相同的邮件，并且仅有名字不同，所以使用张三该对象类拷贝李四、王五对象然后更改下名字即可。程序一直到这里都没有错，但是如果我们需要张三提前30分钟到，即把邮件的内容修改下：

[java] view plain
public class Client {
public static void main(String[] args) {
//写封邮件
Email email = new Email("请参加会议","请与今天12:30到二会议室参加会议...");

Person person1 = new Person("张三",email);

Person person2 = person1.clone();
person2.setName("李四");
Person person3 = person1.clone();
person3.setName("王五");

person1.getEmail().setContent("请与今天12:00到二会议室参加会议...");

System.out.println(person1.getName() + "的邮件内容是：" + person1.getEmail().getContent());
System.out.println(person2.getName() + "的邮件内容是：" + person2.getEmail().getContent());
System.out.println(person3.getName() + "的邮件内容是：" + person3.getEmail().getContent());
}
}
在这里同样是使用张三该对象实现对李四、王五拷贝，最后将张三的邮件内容改变为：请与今天12:00到二会议室参加会议...。但是结果是：

[java] view plain
张三的邮件内容是：请与今天12:00到二会议室参加会议...
李四的邮件内容是：请与今天12:00到二会议室参加会议...
王五的邮件内容是：请与今天12:00到二会议室参加会议...

这里我们就疑惑了为什么李四和王五的邮件内容也发送了改变呢？让他们提前30分钟到人家会有意见的！

其实出现问题的关键就在于clone()方法上，我们知道该clone()方法是使用Object类的clone()方法，但是该方法存在一个缺陷，它并不会将对象的所有属性全部拷贝过来，而是有选择性的拷贝，基本规则如下：

1、 基本类型

如果变量是基本很类型，则拷贝其值，比如int、float等。

2、 对象

如果变量是一个实例对象，则拷贝其地址引用，也就是说此时新对象与原来对象是公用该实例变量。

3、 String字符串

若变量为String字符串，则拷贝其地址引用。但是在修改时，它会从字符串池中重新生成一个新的字符串，原有紫都城对象保持不变。

基于上面上面的规则，我们很容易发现问题的所在，他们三者公用一个对象，张三修改了该邮件内容，则李四和王五也会修改，所以才会出现上面的情况。对于这种情况我们还是可以解决的，只需要在clone()方法里面新建一个对象，然后张三引用该对象即可：

[java] view plain
protected Person clone() {
Person person = null;
try {
person = (Person) super.clone();
person.setEmail(new Email(person.getEmail().getObject(),person.getEmail().getContent()));
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}

return person;
}

所以：浅拷贝只是Java提供的一种简单的拷贝机制，不便于直接使用。

对于上面的解决方案还是存在一个问题，若我们系统中存在大量的对象是通过拷贝生成的，如果我们每一个类都写一个clone()方法，并将还需要进行深拷贝，新建大量的对象，这个工程是非常大的，这里我们可以利用序列化来实现对象的拷贝。

二、利用序列化实现对象的拷贝

如何利用序列化来完成对象的拷贝呢？在内存中通过字节流的拷贝是比较容易实现的。把母对象写入到一个字节流中，再从字节流中将其读出来，这样就可以创建一个新的对象了，并且该新对象与母对象之间并不存在引用共享的问题，真正实现对象的深拷贝。

[java] view plain
public class CloneUtils {
@SuppressWarnings("unchecked")
public static <T extends Serializable> T clone(T obj){
T cloneObj = null;
try {
//写入字节流
ByteArrayOutputStream out = new ByteArrayOutputStream();
ObjectOutputStream obs = new ObjectOutputStream(out);
obs.writeObject(obj);
obs.close();

//分配内存，写入原始对象，生成新对象
ByteArrayInputStream ios = new ByteArrayInputStream(out.toByteArray());
ObjectInputStream ois = new ObjectInputStream(ios);
//返回生成的新对象
cloneObj = (T) ois.readObject();
ois.close();
} catch (Exception e) {
e.printStackTrace();
}
return cloneObj;
}
}

使用该工具类的对象必须要实现Serializable接口，否则是没有办法实现克隆的。

[html] view plain
public class Person implements Serializable{
private static final long serialVersionUID = 2631590509760908280L;

..................
//去除clone()方法

}

public class Email implements Serializable{
private static final long serialVersionUID = 1267293988171991494L;

....................
}

所以使用该工具类的对象只要实现Serializable接口就可实现对象的克隆，无须继承Cloneable接口实现clone()方法。

㈤ 澶у︾敓绂忛煶Java甯歌佽捐℃ā寮忔荤粨

Java甯歌佽捐℃ā寮忓揩𨱒ョ湅鐪

1銆佸垱寤哄瀷-宸ュ巶鏂规硶妯″纺:

(1)绠鍗曞伐铡傛ā寮:

寤虹珛涓涓宸ュ巶绫伙纴骞跺畾涔変竴涓鎺ュ彛瀵瑰疄鐜颁简钖屼竴鎺ュ彛镄勪骇鍝佺被杩涜屽垱寤恒

(2)宸ュ巶鏂规硶妯″纺:

宸ュ巶鏂规硶妯″纺鏄瀵圭亩鍗曞伐铡傛ā寮忕殑鏀硅繘锛岀亩鍗曞伐铡傜殑缂洪櫡鍦ㄥ共涓岖﹀悎钬滃紑闂铡熷垯钬

(3)闱欐佸伐铡傛柟娉曟ā寮:

闱欐佸伐铡傛ā寮忔槸灏嗗伐铡傛柟娉曟ā寮忛噷镄勬柟娉旷疆涓洪润镐佺殑锛屼笉闇瑕佸垱寤哄疄渚嬶纴鐩存帴璋幂敤鍗冲彲銆

2銆佸垱寤哄瀷-鎶借薄宸ュ巶妯″纺:

鎶借薄宸ュ巶妯″纺涓昏佺敤浜庡垱寤虹浉鍏冲硅薄镄勫舵棌銆傚綋涓涓浜у搧镞忎腑闇瑕佽璁捐″湪涓璧峰伐浣沧椂锛岄氲繃鎶借薄宸ュ巶妯″纺锛岃兘澶熶缭璇佸㈡埛绔濮嬬粓鍙浣跨敤钖屼竴涓浜у搧镞忎腑镄勫硅薄:骞朵笖阃氲繃闅旂诲叿浣撶被镄勭敓鎴愶纴浣垮缑瀹㈡埛绔涓嶉渶瑕佹槑纭鎸囧畾鍏蜂綋鐢熸垚绫;镓链夌殑鍏蜂綋宸ュ巶閮藉疄鐜颁简鎶借薄宸ュ巶涓瀹氢箟镄勫叕鍏辨帴鍙ｏ纴锲犳ゅ彧闇瑕佹敼鍙桦叿浣揿伐铡傜殑瀹炰緥锛屽氨鍙浠ュ湪镆愮岖▼搴︿笂鏀瑰彉鏁翠釜杞浠剁郴缁熺殑琛屼负銆

浣呜ユā寮忕殑缂虹偣鍦ㄤ簬娣诲姞鏂扮殑琛屼负镞舵瘆杈冮夯鐑︼纴濡傛灉闇瑕佹坊锷犱竴涓鏂颁骇鍝佹棌瀵硅薄镞讹纴闇瑕佹洿鏀规帴鍙ｅ强鍏朵笅镓链夊瓙绫伙纴杩椤繀铹朵细甯︽潵寰埚ぇ镄勯夯鐑︺

3銆佸垱寤哄瀷-寤洪犺呮ā寮:

寤洪犺呮ā寮忓皢澶嶆潅浜у搧镄勫垱寤烘ラゅ垎瑙ｅ湪鍦ㄤ笉钖岀殑鏂规硶涓浣垮缑鍒涘缓杩囩▼镟村姞娓呮榈锛屼粠钥屾洿绮剧‘鎺у埗澶嶆潅瀵硅薄镄勪骇鐢熻繃绋;阃氲繃闅旂诲嶆潅瀵硅薄镄勬瀯寤轰笌浣跨敤锛屼篃灏辨槸灏嗕骇鍝佺殑鍒涘缓涓庝骇鍝佹湰韬鍒嗙诲紑𨱒ワ纴浣垮缑钖屾牱镄勬瀯寤鸿繃绋嫔彲浠ュ垱寤轰笉钖岀殑瀵硅薄;骞朵笖姣忎釜鍏蜂綋寤洪犺呴兘鐩镐簰镫绔嬶纴锲犳ゅ彲浠ュ緢鏂逛究鍦版浛鎹㈠叿浣揿缓阃犺呮垨澧炲姞鏂扮殑鍏蜂綋寤洪犺咃纴鐢ㄦ埛浣跨敤涓嶅悓镄勫叿浣揿缓阃犺呭嵆鍙寰楀埌涓嶅悓镄勪骇鍝佸硅薄銆

4銆佸垱寤哄瀷-鍗曚緥妯″纺

鍗曚緥妯″纺鍙浠ョ‘淇濈郴缁熶腑镆愪釜绫诲彧链変竴涓瀹炰緥锛岃ョ被镊琛屽疄渚嫔寲骞跺悜鏁翠釜绯荤粺鎻愪緵杩欎釜瀹炰緥镄勫叕鍏辫块梾镣癸纴闄や简璇ュ叕鍏辫块梾镣癸纴涓嶈兘阃氲繃鍏朵粬阃斿缎璁块梾璇ュ疄渚嬨傚崟渚嬫ā寮忕殑浼樼偣鍦ㄤ簬:绯荤粺涓鍙瀛桦湪涓涓鍏辩敤镄勫疄渚嫔硅薄锛屾棤闇棰戠箒鍒涘缓鍜岄攒姣佸硅薄锛岃妭绾︿简绯荤粺璧勬簮锛屾彁楂樼郴缁熺殑镐ц兘鍙浠ヤ弗镙兼带鍒跺㈡埛镐庝箞镙蜂互鍙娄綍镞惰块梾鍗曚緥瀵硅薄銆傚崟渚嬫ā寮忕殑鍐欐硶链夊ソ鍑犵嶏纴涓昏佹湁涓夌:镍掓眽寮忓崟渚嬨侀タ姹夊纺鍗曚緥銆佺橱璁板纺鍗曚緥銆

5銆佸垱寤哄瀷-铡熷瀷妯″纺:

鍦 Java 涓锛屽师鍨嬫ā寮忕殑镙稿绩鏄灏辨槸铡熷瀷绫 Prototype,Prototype绫婚渶瑕佸叿澶囦互涓嬩袱涓𨱒′欢:瀹炵幇 Cloneable 鎺ュ彛:

閲嶅啓 Object 绫讳腑镄 clone() 鏂规硶锛岀敤浜庤繑锲炲硅薄镄勬嫹璐;Object 绫讳腑镄 clone() 鏂规硶榛樿ゆ槸娴呮嫹璐濓纴濡傛灉𨱍宠佹繁𨰾疯礉瀵硅薄锛屽垯闇瑕佸湪 clone() 鏂规硶涓镊瀹氢箟镊宸辩殑澶嶅埗阃昏緫銆傛祬澶嶅埗:灏嗕竴涓瀵硅薄澶嶅埗钖庯纴锘烘湰鏁版嵁绫诲瀷镄勫彉閲忎细閲嶆柊鍒涘缓锛岃屽紩鐢ㄧ被鍨嬫寚钖戠殑杩樻槸铡熷硅薄镓鎸囧悜镄勫唴瀛桦湴鍧銆傛繁澶嶅埗:灏嗕竴涓瀵硅薄澶嶅埗钖庯纴涓嶈烘槸锘烘湰鏁版嵁绫诲瀷杩樻湁寮旷敤绫诲瀷锛岄兘鏄閲嶆柊鍒涘缓镄勚

浣跨敤铡熷瀷妯″纺杩涜屽垱寤哄硅薄涓崭粎绠鍖栧硅薄镄勫垱寤烘ラわ纴杩樻瘆new 鏂瑰纺鍒涘缓瀵硅薄镄勬ц兘瑕佸ソ镄勫氾纴锲犱负 Object 绫荤殑clone() 鏂规硶鏄涓涓链鍦版柟娉曪纴鐩存帴镎崭綔鍐呭瓨涓镄勪簩杩涘埗娴佺壒鍒鏄澶嶅埗澶у硅薄镞讹纴镐ц兘镄勫樊鍒闱炲父鏄庢樉

6.缁撴瀯鍨-阃傞厤鍣ㄦā寮

阃傞厤鍣ㄦā寮忎富瑕佺敤浜庡皢涓涓绫绘垨钥呮帴鍙ｈ浆鍖栨垚瀹㈡埛绔甯屾湜镄勬牸寮忥纴浣垮缑铡熸湰涓嶅吋瀹圭殑绫诲彲浠ュ湪涓璧峰伐浣滐纴灏嗙洰镙囩被鍜岄傞厤钥呯被瑙ｈ;钖屾椂涔熺﹀悎钬滃紑闂铡熷垯钬濓纴鍙浠ュ湪涓崭慨鏀瑰师浠ｇ爜镄勫熀纭涓婂炲姞鏂扮殑阃傞厤鍣ㄧ被;灏嗗叿浣撶殑瀹炵幇灏佽呭湪阃傞厤钥呯被涓锛屽逛簬瀹㈡埛绔绫绘潵璇存槸阃忔槑镄勶纴钥屼笖鎻愰珮浜嗛傞厤钥呯殑澶岖敤镐э纴浣嗘槸缂虹偣鍦ㄤ簬镟存崲阃傞厤鍣ㄧ殑瀹炵幇杩囩▼姣旇缉澶嶆潅銆

镓浠ワ纴阃傞厤鍣ㄦā寮忔瘆杈冮傚悎浠ヤ笅鍦烘櫙:

(1)绯荤粺闇瑕佷娇鐢ㄧ幇链夌殑绫伙纴钥岃繖浜涚被镄勬帴鍙ｄ笉绗﹀悎绯荤粺镄勬帴

(2)浣跨敤绗涓夋柟缁勪欢锛岀粍浠舵帴鍙ｅ畾涔夊拰镊宸卞畾涔夌殑涓嶅悓锛屼笉甯屾湜淇鏀硅嚜宸辩殑鎺ュ彛锛屼絾鏄瑕佷娇鐢ㄧ涓夋柟缁勪欢鎺ュ彛镄勫姛鑳姐

7銆佺粨鏋勫瀷-瑁呴グ鍣ㄦā寮:

瑁呴グ鍣ㄦā寮忓彲浠ュ姩镐佺粰瀵硅薄娣诲姞涓浜涢濆栫殑镵岃矗浠庤屽疄鐜板姛鑳界殑𨰾揿𪾢锛屽湪杩愯屾椂阃夋嫨涓嶅悓镄勮呴グ鍣锛屼粠钥屽疄鐜颁笉钖岀殑琛屼负;姣斾娇鐢ㄧ户镓挎洿锷犵伒娲伙纴阃氲繃瀵逛笉钖岀殑瑁呴グ绫昏繘琛屾帓鍒楃粍钖堬纴鍒涢犲嚭寰埚氢笉钖岃屼负锛屽缑鍒板姛鑳芥洿涓哄己澶х殑瀵硅薄;绗﹀悎钬滃紑闂铡熷垯钬濓纴琚瑁呴グ绫讳笌瑁呴グ绫荤嫭绔嫔彉鍖栵纴鐢ㄦ埛鍙浠ユ牴鎹闇瑕佸炲姞鏂扮殑瑁呴グ绫诲拰琚瑁呴グ绫伙纴鍦ㄤ娇鐢ㄦ椂鍐嶅瑰叾杩涜岀粍钖堬纴铡熸湁浠ｇ爜镞犻’鏀瑰彉銆

浣嗘槸瑁呴グ鍣ㄦā寮忎篃瀛桦湪缂虹偣锛岄栧厛浼氢骇鐢熷緢澶氱殑灏忓硅薄澧炲姞浜嗙郴缁熺殑澶嶆潅镐э纴绗浜屾槸鎺挜敊姣旇缉锲伴毦锛屽逛簬澶氭¤呴グ镄勫硅薄锛岃皟璇曟椂瀵绘垒阌栾鍙鑳介渶瑕侀愮骇鎺掓煡锛岃缉涓虹储鐞愩

8銆佺粨鏋勫瀷-浠ｇ悊妯″纺:

浠ｇ悊妯″纺镄勮捐″姩链烘槸阃氲繃浠ｇ悊瀵硅薄𨱒ヨ块梾鐪熷疄瀵硅薄锛岄氲繃寤虹珛涓涓瀵硅薄浠ｇ悊绫伙纴鐢变唬鐞嗗硅薄鎺у埗铡熷硅薄镄勫紩鐢锛屼粠钥屽疄鐜板圭湡瀹炲硅薄镄勬搷浣溿傚湪浠ｇ悊妯″纺涓锛屼唬鐞嗗硅薄涓昏佽捣鍒颁竴涓涓浠嬬殑浣灭敤锛岀敤浜庡岗璋冧笌杩炴帴璋幂敤钥(鍗冲㈡埛绔)鍜岃璋幂敤钥(鍗崇洰镙囧硅薄)锛屽湪涓瀹氱▼搴︿笂闄崭绠浜嗙郴缁熺殑钥﹀悎搴︼纴钖屾椂涔熶缭鎶や简鐩镙囧硅薄銆备絾缂虹偣鏄鍦ㄨ皟鐢ㄨ呬笌琚璋幂敤钥呬箣闂村炲姞浜嗕唬鐞嗗硅薄锛屽彲鑳戒细阃犳垚璇锋眰镄勫勭悊阃熷害鍙樻参銆

9銆佺粨鏋勫瀷-妗ユ帴妯″纺:

妗ユ帴妯″纺灏嗙郴缁熺殑鎶借薄閮ㄥ垎涓庡疄鐜伴儴鍒嗗垎绂昏В钥︼纴浣夸粬浠鍙浠ョ嫭绔嬬殑鍙桦寲銆备负浜呜揪鍒拌╂娊璞￠儴鍒嗗拰瀹炵幇閮ㄥ垎镫绔嫔彉鍖栫殑鐩镄勶纴妗ユ帴妯″纺浣跨敤缁勫悎鍏崇郴𨱒ヤ唬镟跨户镓垮叧绯伙纴鎶借薄閮ㄥ垎𨰾ユ湁瀹炵幇閮ㄥ垎镄勬帴鍙ｅ硅薄锛屼粠钥岃兘澶熼氲繃杩欎釜鎺ュ彛瀵硅薄𨱒ヨ皟鐢ㄥ叿浣揿疄鐜伴儴鍒嗙殑锷熻兘銆备篃灏辨槸璇达纴妗ユ帴妯″纺涓镄勬ˉ鎺ユ槸涓涓鍗曟柟钖戠殑鍏崇郴锛屽彧鑳藉熸娊璞￠儴鍒嗗幓浣跨敤濂栫幇閮ㄥ垎镄勫硅薄锛岃屼笉鑳藉弽杩囨潵銆

妗ユ帴妯″纺绗﹀悎钬滃紑闂铡熷垯钬濓纴鎻愰珮浜嗙郴缁熺殑鍙𨰾揿𪾢镐э纴鍦ㄤ袱涓鍙桦寲缁村害涓浠绘剰镓╁𪾢涓涓缁村害锛岄兘涓嶉渶瑕佷慨鏀瑰师𨱒ョ殑绯荤粺:骞朵笖瀹炵幇缁呜妭瀵瑰㈡埛涓嶉忔槑锛屽彲浠ラ殣钘忓疄鐜扮粏鑺伞备絾鏄鐢变簬镵氩悎鍏崇郴寤虹珛鍦ㄦ娊璞″眰锛岃佹眰寮鍙戣呴拡瀵规娊璞¤繘琛岀紪绋嬶纴杩椤炲姞绯荤粺镄勭悊瑙ｅ拰璁捐￠毦搴︺

10銆佺粨鏋勫瀷-澶栬傛ā寮:

瑙傛ā寮忛氲繃瀵瑰㈡埛绔鎻愪緵涓涓缁熶竴镄勬帴鍙ｏ纴鐢ㄤ簬璁块梾瀛愮郴缁熶腑镄勪竴缇ゆ帴鍙ｃ备娇鐢ㄥ栬傛ā寮忔湁浠ヤ笅鍑犵偣濂藉:

(1)镟村姞鏄撶敤:浣垮缑瀛愮郴缁熸洿锷犳槗鐢锛屽㈡埛绔涓嶅啀闇瑕佷简瑙ｅ瓙绯荤粺鍐呴儴镄勫疄鐜帮纴涔熶笉闇瑕佽窡浼楀氩瓙绯荤粺鍐呴儴镄勬ā鍧楄繘琛屼氦浜掞纴鍙闇瑕佽窡澶栬傜被浜や簰灏卞彲浠ヤ简;

(2)𨱒炬暎钥﹀悎:灏嗗㈡埛绔涓庡瓙绯荤粺瑙ｈ︼纴璁╁瓙绯荤粺鍐呴儴镄勬ā鍧楄兘镟村规槗镓╁𪾢鍜岀淮鎶ゃ

(3)镟村ソ镄勫垝鍒呜块梾灞傛: 阃氲繃钖堢悊浣跨敤 Facade锛屽彲浠ユ洿濂藉湴鍒掑垎璁块梾镄勫眰娆★纴链変簺鏂规硶鏄瀵圭郴缁熷栫殑锛屾湁浜涙柟娉曟槸绯荤粺鍐呴儴浣跨敤镄勚傛妸闇瑕佹毚闇茬粰澶栭儴镄勫姛鑳介泦涓鍒伴棬闱涓锛岃繖镙锋棦鏂逛究瀹㈡埛绔浣跨敤锛屼篃寰埚ソ鍦伴殣钘忎简鍐呴儴镄勭粏鑺伞

11銆佺粨鏋勫瀷-缁勫悎妯″纺:

缁勫悎妯″纺灏嗗彾瀛愬硅薄鍜屽瑰櫒瀵硅薄杩涜岄掑綊缁勫悎锛屽舰鎴愭爲褰㈢粨鏋勪互琛ㄧず钬滈儴鍒-鏁翠綋钬濈殑灞傛＄粨鏋勶纴浣垮缑鐢ㄦ埛瀵瑰崟涓瀵硅薄鍜岀粍钖埚硅薄镄勪娇鐢ㄥ叿链変竴镊存э纴鑳藉熷儚澶勭悊鍙跺瓙瀵硅薄涓镙锋潵澶勭悊缁勫悎瀵硅薄锛屾棤闇杩涜屽尯鍒嗭纴浠庤屼娇鐢ㄦ埛绋嫔簭鑳藉熶笌澶嶆潅鍏幂礌镄勫唴閮ㄧ粨鏋勮繘琛岃В钥︺

缁勫悎妯″纺链鍏抽敭镄勫湴鏂规槸鍙跺瓙瀵硅薄鍜岀粍钖埚硅薄瀹炵幇浜嗙浉钖岀殑鎶借薄鏋勫缓绫伙纴瀹冩棦鍙琛ㄧず鍙跺瓙瀵硅薄锛屼篃鍙琛ㄧず瀹瑰櫒瀵硅薄锛屽㈡埛浠呬粎闇瑕侀拡瀵硅繖涓鎶借薄鏋勫缓绫昏繘琛岀紪绋嬶纴杩椤氨鏄缁勫悎妯″纺鑳藉熷皢鍙跺瓙鑺傜偣鍜屽硅薄鑺傜偣杩涜屼竴镊村勭悊镄勫师锲犮

12銆佺粨鏋勫瀷-浜鍏冩ā寮:

浜鍏冩ā寮忛氲繃鍏变韩鎶链链夋晥鍦版敮鎸佺粏绮掑害銆佺姸镐佸彉鍖栧皬镄勫硅薄澶岖敤锛屽綋绯荤粺涓瀛桦湪链夊氢釜鐩稿悓镄勫硅薄锛岄偅涔埚彧鍏变韩涓浠戒笉蹇呮疮涓閮藉幓瀹炰緥鍖栦竴涓瀵硅薄锛屾瀬澶у湴鍑忓皯绯荤粺涓瀵硅薄镄勬暟閲忥纴浠庤岃妭鐪佽祫婧愩

浜鍏冩ā寮忕殑镙稿绩鏄浜鍏冨伐铡傜被锛屼韩鍏冨伐铡傜被缁存姢浜嗕竴涓瀵硅薄瀛桦偍姹狅纴褰揿㈡埛绔闇瑕佸硅薄镞讹纴棣栧厛浠庝韩鍏冩睁涓銮峰彇锛屽傛灉浜鍏冩睁涓瀛桦湪瀵硅薄瀹炰緥鍒欑洿鎺ヨ繑锲烇纴濡傛灉浜鍏冩睁涓涓嶅瓨鍦锛屽垯鍒涘缓涓涓鏂扮殑浜鍏冨硅薄瀹炰緥杩斿洖缁欑敤鎴凤纴骞跺湪浜鍏冩睁涓淇濆瓨璇ユ柊澧炲硅薄锛岃繖镣规湁浜涘崟渚嬬殑镒忔濄

宸ュ巶绫婚氩父浼氢娇鐢ㄩ泦钖堢被鍨嬫潵淇濆瓨瀵硅薄锛屽 HashMap銆丠ashtable銆乂ector 绛夌瓑锛屽湪 Java 涓锛屾暟鎹搴撹繛鎺ユ睁銆佺嚎绋嬫睁绛夐兘鏄鐢ㄤ韩鍏冩ā寮忕殑搴旂敤銆

㈥ java如何深度一个object

方法一：把对象序列化之后再反序列化，之后得到的对象就是深度克隆的对象；
方法二：自己重写方法，不过有点麻烦。

㈦ java深拷贝对象与新建对象哪个更耗资源

这个问题没有可比性:
首先浅克隆比new性能高
而深克隆包括克隆对象本身以及对象内部的所有成员, 以及成员的成员等,
如果这个对象有一个集合字段, 这个字段里有100w个对象, 那么深克隆要克隆100w+1个对象, 而你所说的新建对象, 如果是new一个对象, 然后set这个100w的集合, 那么肯定性能更好, 而你如果是new一个对象, 然后new一个集合, 然后把集合里的100w个对象每个都重新new, 并添加到集合中, 然后赋值到新的对象上, 那么还是克隆的性能好

㈧ java.util.ArrayList.clone是不是彻底的克隆

你好，官方api 说明如下：

Returns a shallow of this ArrayList instance. (The elements themselves are not copied.)
arraylist.clone是浅拷贝，浅拷贝是指拷贝对象时仅仅拷贝对象本身（包括对象中的基本变量），而不拷贝对象包含的引用指向的对象。深拷贝不仅拷贝对象本身，而且拷贝对象包含的引用指向的所有对象。