有一次,在写一个项目
// for (DateReportBean d : lists) {
// System.out.println(d.toString());
// }
// System.out.println("==========================" + lists.size());
for (DateReportBean d : lists) {
// 门店数组
boolean is_add = true;
for (String s : shops) {
if ( d.getShopName().equals( s)) {
is_add = false;
}
}
if ( is_add) {
shops.add( d.getShopName());
}
// 套餐数组
is_add = true;
for (String g : goods) {
if ( d.getGoodName().equals( g)) {
is_add = false;
}
}
if ( is_add) {
goods.add( d.getGoodName());
}
// 列表数组
is_add = true;
for (DateReportBean dT : listT) {
if ( d.getGoodName().equals( dT.getGoodName()) && d.getShopName().equals( dT.getShopName())) {
is_add = false;
dT.setNum( dT.getNum() + d.getNum());
System. out
.println( dT.getShopName() + " " + dT .getGoodName() + " " + dT .getNum() + " " + d .getNum());
dT.setPrice( dT.getPrice() + d.getPrice());
}
}
if ( is_add) {
listT.add( d);
}
}
// for (DateReportBean d : lists) {
// System.out.println(d.toString());
// }
// System.out.println("==========================" + lists.size());
今天写的代码 lists 没有经过 变值,但两次输出结果却不同。
后来仔细一想,原因:
listT.add( d);主要是这行代码,lists listT 共用了同一个对象,
当listT内部对象变值时,lists的对象也跟着变化
list是一堆指针链,要 复制对象,而原来的list不受影响,只好用克隆。
克隆测试:
package com.test;
import java.io.Serializable;
public class Student implements Serializable{
private String name = null;
public String getName() {
return name;
}
public void setName(String name) {
this. name = name;
}
}
package com.test;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class Teacher implements Cloneable ,Serializable{
private Student stu = null;
private String str = null;
/**
*浅克隆
*/
public Object Clone(){
try {
return super.clone();
} catch (CloneNotSupportedException e) {
// TODO Auto-generated catch block
return null;
}
}
/**
* 深克隆
*/
public Object deepClone() throws IOException, ClassNotFoundException{
ByteArrayOutputStream bOut = new ByteArrayOutputStream();
ObjectOutputStream oOut = new ObjectOutputStream(bOut);
oOut.writeObject(this);
ByteArrayInputStream bIn = new ByteArrayInputStream(bOut.toByteArray());
ObjectInputStream oIn = new ObjectInputStream(bIn);
return oIn.readObject();
}
public Student getStu() {
return stu;
}
public void setStu(Student stu) {
this.stu = stu;
}
public String getStr() {
return str;
}
public void setStr(String str) {
this.str = str;
}
}
package com.test;
import java.io.IOException;
public class Test {
public static void main(String[] args) throws ClassNotFoundException, IOException {
//实现Teacher对象,并赋值
Student s = new Student();
s.setName( "zhangsan");
Teacher t01 = new Teacher();
t01.setStu( s);
t01.setStr( "123");
System. out.println( "------------------>进行浅克隆" );
//浅克隆 --->只能对基本类型克隆
Teacher t02 = (Teacher) t01.Clone();
System. out.println( t01.getStr().hashCode() == t02.getStr().hashCode()); //原因吗,编程思想
t02.setStr( "123456");
System. out.println( t01.getStr());
System. out.println( t01.getStu().hashCode() == t02.getStu().hashCode());
t02.getStu().setName( "lisi");
System. out.println( t01.getStu().getName());
System. out.println( "------------------>进行深克隆" );
//深度克隆 ---> 可对非基本类型克隆
Teacher t03 = (Teacher) t01.deepClone();
System. out.println( t01.getStr().hashCode() == t03.getStr().hashCode()); //原因吗,编程思想
t03.setStr( "123456789");
System. out.println( t01.getStr());
System. out.println( t01.getStu().hashCode() == t03.getStu().hashCode());
t03.getStu().setName( "wangwu");
System. out.println( t01.getStu().getName());
}
}
⑴浅复制(浅克隆)
被复制对象的所有变量都含有与原来的对象相同的值,而所有的对其他对象的引用仍然指向原来的对象。换言之,浅复制仅仅复制所考虑的对象,而不
复制它所引用的对象。
⑵深复制(深克隆)
被复制对象的所有变量都含有与原来的对象相同的值,除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象,而不再是原
有的那些被引用的对象。换言之,深复制把要复制的对象所引用的对象都复制了一遍。