// ipconfig | findstr "IPv4"
// soapui cracker:
<[https://download.csdn.net/download/tonyluo23/8014727]>
// json 对象与数组:
<[https://www.cnblogs.com/zhangji/archive/2011/09/02/2163811.html]>
<[https://msdn.microsoft.com/zh-cn/library/ie/cc836459(v=vs.94).aspx]>
<[https://msdn.microsoft.com/zh-cn/library/ie/cc836466(v=vs.94).aspx]>
<[https://msdn.microsoft.com/zh-cn/library/ie/htbw4ywd(v=vs.94).aspx]>
<[https://blog.csdn.net/column/details/step-to-oracle.html]>
package com.qingyuan.server;
import java.io.Serializable;
public class Car implements Serializable
{
/** serialVersionUID */
private static final long serialVersionUID = 4539772529921666906L;
private String brand;
private int price;
public String getBrand()
{
return brand;
}
public void setBrand(String brand)
{
this.brand = brand;
}
public int getPrice()
{
return price;
}
public void setPrice(int price)
{
this.price = price;
}
public Object clone()
{
Car car = null;
try
{
car = (Car) super.clone();
}
catch (CloneNotSupportedException e)
{
e.printStackTrace();
}
return car;
}
}
package com.qingyuan.server;
public class Person implements Cloneable
{
private String name;
private Car car;
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public Car getCar()
{
return car;
}
public void setCar(Car car)
{
this.car = car;
}
public Object clone()
{
Person person = null;
try
{
person = (Person) super.clone();
}
catch (CloneNotSupportedException e)
{
e.printStackTrace();
}
return person;
}
}
package com.qingyuan.server;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
/**
* <[java 浅拷贝与深层次拷贝 -> 深拷贝:最大水平与原对象脱离关系]>
* Java中的拷贝方法分为深拷贝和浅拷贝。简略来讲，深拷贝就是把一个对象中的所有值，如果被拷贝对象中有对其他对象的援用，
* 那末这个援用指向的对象本身会被重新创立。浅拷贝和深拷贝相似，但是如果被拷贝对象中有对其他对象的援用，只是这个援用会
* 被拷贝，而不是这个被援用的对象
*
* https://kuangbaoxu.iteye.com/blog/193222
* https://stackoverflow.com/questions/2589741/how-to-effectively-copy-an-array-in-java
* https://stackoverflow.com/questions/18638743/is-it-better-to-use-system-arraycopy-than-a-fast-for-loop-for-copying-array
*
* public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType)
* Object[] foo = new Object[]{...};
* String[] bar = new String[foo.length];
* System.arraycopy(foo, 0, bar, 0, bar.length);
*
* "援用类型的变量"称为指针 [指针变量和该指针变量指向的对象]
* 假定在函数中写了以下这个简略的语句: StringBuffer str = new StringBuffer("newString");
* 1) : new StringBuffer("newString") 在堆里申请了一块内存,把创立好的StringBuffer 对象放入;
* 2) : String str 声明了一个指针,这个指针本领存储在栈上的[由于语句写在函数中],可以用来指向某个StringBuffer 类型的对象,或换句话说,这个指针可以用来保留某个
* StringBuffer 对象的地址;
* 3) : StringBuffer str = new StringBuffer("newString"); 把刚才申请的那一块内存地址保留为str 的值;
* StringBuffer str2 = str
* 实际上就是把str的地址复制给str2,是地址的复制，StringBuffer对象本身并没有复制。所以两个指针指向的是同一个
*
* 实际上两个指针的值雷同，则确定是指向同一个对象（所以对象内容一定雷同）。但是两个内容雷同的对象，
* 它们的地址可能不一样（比如克隆出来的多个对象之间，地址就不同）
*
* final常量的问题:
* 针对援用类型变量的final润饰符也是很多人弄混杂的处所。实际上final只是润饰指针的值(也就是限定指针保留的地址不能变)
* 至于该指针指向的对象,内容是不是能变,那就管不着了,所以,对以下语句：
* final StringBuffer strConst = new StringBuffer();
* 你可以修正它指向的对象的内容,比如：strConst.append("");
* 但是不能修正它的值,比如: strConst = null;
*/
/**
* reference: <[https://www.bdqn.cn/news/201306/9459.shtml]>
*/
public class SystemCopy
{
/*
* 重点在Person person2 = person1;这一句上，person1里面包括了一个对Car对象的援用，
* 那末这句话是深拷贝还是浅拷贝呢？答案是甚么都不是。它只是一个简略的援用传递，履行完这句话以后，
* person1和person2都指向了同一个person对象，所以不管谁去转变对象，另外一个援用再去调用该对象
* 的值都会产生转变
*/
/* public static void main(String[] args)
{
Car car1 = new Car();
car1.setBrand("BMW");
car1.setPrice(10000);
Person person1 = new Person();
person1.setCar(car1);
person1.setName("person1");
Person person2 = person1;
person2.setName("person2");
System.out.println(person1.getName()); // person2
System.out.println(person2.getName()); // person2
Car car2 = new Car();
car2.setBrand("Benz");
car2.setPrice(20000);
person1.setCar(car2);
System.out.println(person2.getCar().getBrand()); // Benz
System.out.println(person2.getCar().getPrice()); // 20000
}*/
/**
* Car类不变，Person实现了Cloneable接口，然后重载了父类的clone办法，并且直接调用super.clone()
* 办法来拷贝。但是值得注意的是，父类的clone只是浅拷贝，所以才会有上述的输出成果。那末，要想到达深拷
* 贝，须要做些甚么呢？ 其实答案已很显著了，由于clone是浅拷贝，而Car中都是原始类型的变量，所以我们
* 只须要让Car类也实现Cloneable接口，然后重载clone办法，然后回到Person类中，在clone的时候，加上
* car = car.clone()就好了
* @throws IOException
* @throws ClassNotFoundException
*/
/* public static void main(String[] args)
{
Car car1 = new Car();
car1.setBrand("BMW");
car1.setPrice(10000);
Person originalPerson = new Person();
originalPerson.setCar(car1);
originalPerson.setName("originalPerson");
Person clonePerson = (Person)originalPerson.clone();
originalPerson.setName("originalPerson_1");
originalPerson.getCar().setBrand("Benz");
System.out.println(originalPerson.getName());
System.out.println(originalPerson.getCar().getBrand());
System.out.println(clonePerson.getName());
System.out.println(clonePerson.getCar().getBrand());
}*/
/**
* 让Car 类实现Serializable 接口使其能够序列化, 其次便可以够应用java的 Io来传输对象了,序列化能够到达深拷贝目标
* 的缘由是,它首先将全部对象进行持久化,然后全体读出, 每读出一次就得到一个全新的拷贝, 序列化较cloneable 效力低,
* 毕竟甚么时候用浅拷贝, 甚么时候用深拷贝, 答案是如果一个对象中只包括原始类型的变量,那末就应用浅拷贝, 如果类中有
* 对其它类的援用, 但是其它类是immutable的,依然应用浅拷贝,如果有对其它类的援用, 而其它类是可被修正的, 就不能不
* 深拷贝了;
*/
public static void main(String[] args) throws IOException, ClassNotFoundException
{
Car originalCar = new Car();
originalCar.setBrand("BMW");
originalCar.setPrice(500000);
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
objectOutputStream.writeObject(originalCar);
objectOutputStream.flush();
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
Car cloneCar = (Car) objectInputStream.readObject();
System.out.println(cloneCar.getBrand()); // BMW
System.out.println(cloneCar.getPrice()); // 500000
cloneCar.setBrand("Honda");
cloneCar.setPrice(3000);
System.out.println(originalCar.getBrand()); // BMW
System.out.println(originalCar.getPrice()); // 500000
System.out.println(cloneCar.getBrand()); // Honda
System.out.println(cloneCar.getPrice()); // 3000
}
}// ipconfig | findstr "IPv4"
// soapui cracker:
阅读背景：
java clone方法例子
来源：互联网
分享到：
