public char[] toCharArray() {
    // Cannot use Arrays.copyOf because of class initialization order issues
    char result[] = new char[value.length];
    System.arraycopy(value, 0, result, 0, value.length);
    return result;
}

// Person類
public class Person implements Cloneable{
    private String name;
    private int age;
    @Override
    public Person clone() throws CloneNotSupportedException {
        return (Person) super.clone();
    }
    // 省略構(gòu)造方法、getter、setter、toString
}
// PersonGroup類：持有Person類的引用，通過這個(gè)引用，就可以看出深拷貝和淺拷貝的區(qū)別
public class PersonGroup implements Cloneable {
    private String groupName;
    private Person person1;
    @Override
    public PersonGroup clone() throws CloneNotSupportedException {
        return (PersonGroup) super.clone();
    }
    // 省略構(gòu)造方法、getter、setter、toString
}
// 測試
public class Test3 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person = new Person("張三", 18);
        PersonGroup personGroup = new PersonGroup("aaa", person);
        PersonGroup clone = personGroup.clone();
        System.out.println("clone = " + clone);
    }
}

@SuppressWarnings("unchecked")
public static <T> T deepCopyByIO(T object) {
    if (object == null) {
        return null;
    }
    // ByteArrayOutputStream、ByteArrayInputStream，是內(nèi)存流，即使不關(guān)閉也不會(huì)造成資源泄露，例如文件句柄未
    // 釋放等問題，即使如此，隨時(shí)關(guān)閉流依然是一個(gè)好習(xí)慣，而且關(guān)閉輸出流會(huì)保證緩沖區(qū)的數(shù)據(jù)被正確的寫出
    try (ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
         ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream)) {
        objectOutputStream.writeObject(object);
        try (ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
             ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream)) {
            return (T) objectInputStream.readObject();
        }
    } catch (Exception e) {
        e.printStackTrace(); // 打印異常信息
        return null;
    }
}

// 這里使用的是gson框架，
public static <T> T deepCopyByGson(T object) {
    if (object == null) {
        return null;
    }
    try {
        Gson gson = new Gson(); 
        // 獲取對(duì)象的類型
        Type type = object.getClass();
        // 將對(duì)象轉(zhuǎn)換為 JSON 字符串
        String jsonString = gson.toJson(object);
        // 從 JSON 字符串解析回對(duì)象
        return gson.fromJson(jsonString, type);
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    }
}

// 兩個(gè)對(duì)象互相持有對(duì)方的引用
@Getter
@Setter
public static class Person1 implements Serializable {
    private String name;
    private Person2 person2;
    @Override
    public String toString() {
        return "Person1{" +
                "name='" + name + '\'' +
                ", person2=" + person2 +
                '}';
    }
}
@Getter
@Setter
public static class Person2 implements Serializable {
    private String name;
    private Person1 person1;
    @Override
    public String toString() {
        return "Person2{" +
                "name='" + name + '\'' +
                ", person1=" + person1.toString() +
                '}';
    }
}
// 測試
@Test
public void test4() {
    Person1 person1 = new Person1();
    Person2 person2 = new Person2();
    person1.setName("zs");
    person1.setPerson2(person2);
    person2.setName("ls");
    person2.setPerson1(person1);
    System.out.println("person1 = " + person1);
}

@Test
public void test4() {
    Person1 person1 = new Person1();
    Person2 person2 = new Person2();
    person1.setName("zs");
    person1.setPerson2(person2);
    person2.setName("ls");
    person2.setPerson1(person1);
    // 深拷貝
    String jsonString = JSON.toJSONString(person1, JSONWriter.Feature.ReferenceDetection);
    Person1 person3 = JSON.parseObject(jsonString, Person1.class);
    // {"name":"zs","person2":{"name":"ls","person1":{"$ref":"$"}}}
    System.out.println("jsonString = " + jsonString);
}