Java에서 객체를 어떻게 복사합니까?

아래 코드를 고려하십시오.

DummyBean dum = new DummyBean();
dum.setDummy("foo");
System.out.println(dum.getDummy()); // prints 'foo'

DummyBean dumtwo = dum;
System.out.println(dumtwo.getDummy()); // prints 'foo'

dum.setDummy("bar");
System.out.println(dumtwo.getDummy()); // prints 'bar' but it should print 'foo'

그래서, 나는 복사 할 dum에 dumtwo변화 dum에 영향을주지 않고 dumtwo. 그러나 위의 코드는 그렇게하지 않습니다. 에서 무언가를 변경 dum하면 동일한 변화가 발생 dumtwo합니다.

내가 말할 때 dumtwo = dumJava는 참조 만 복사 한다고 생각 합니다 . 따라서 새로운 사본을 만들어 dum할당 할 수있는 방법이 dumtwo있습니까?

복사 생성자를 만듭니다.

class DummyBean {
  private String dummy;

  public DummyBean(DummyBean another) {
    this.dummy = another.dummy; // you can access  
  }
}

모든 객체에는 객체를 복사하는 데 사용할 수있는 복제 방법도 있지만 사용하지는 마십시오. 클래스를 생성하고 부적절한 클론 메소드를 수행하는 것은 너무 쉬운 방법입니다. 그렇게하려면 적어도 Joshua Bloch가 Effective Java 에서 그것에 대해 말한 내용을 읽으십시오 .

기본 : Java에서 객체 복사.

우리는 객체 - 가정하자 obj1, 그 두 개체가 포함되어 containedObj1 및 containedObj2을 .

얕은 복사 :
얕은 복사 instance는 동일한 클래스 의 새 클래스를 만들고 모든 필드를 새 인스턴스에 복사하여 반환합니다. Object 클래스 는 clone메서드를 제공하고 단순 복사를 지원합니다.

딥 카피 : 딥 카피 는 객체를 참조하는 객체와 함께 객체를 복사
할 때 발생합니다 . 아래 이미지는 깊은 복사가 수행 된 후의 모습 입니다. 있다뿐만 아니라 복사 ,하지만 그 안에 포함 된 개체가 아니라 복사 한. 딥 카피를 만드는 데 사용할 수 있습니다 . 불행히도,이 접근 방식에는 몇 가지 문제가 있습니다 ( 자세한 예 ).obj1obj1Java Object Serialization

가능한 문제 :
clone 올바르게 구현하기가 까다 롭습니다. 방어 복사 , 복사 생성자 (@egaga 회신) 또는 정적 팩토리 메소드
를 사용하는 것이 좋습니다 .

1. 객체가 있고 공개 clone()메소드가 있지만 컴파일 타임에 객체의 유형을 모르는 경우 문제가 있습니다. Java에는라는 인터페이스가 Cloneable있습니다. 실제로 객체를 만들려면이 인터페이스를 구현해야합니다 Cloneable. Object.cloneis protected 이므로 액세스하려면 공개 메소드로 덮어 써야 합니다.
   
2. 우리가하려고 할 때 또 다른 문제가 발생 깊은 복사 (A)의 복잡한 객체를 . clone()모든 멤버 객체 변수 의 메소드도 딥 카피를 수행 한다고 가정하면 너무 가정이 위험합니다. 모든 클래스에서 코드를 제어해야합니다.
   

예를 들어 org.apache.commons.lang.SerializationUtils 에는 serialization ( Source )을 사용하는 딥 클론 방법이 있습니다 . Bean을 복제해야하는 경우 org.apache.commons.beanutils ( Source ) 에 몇 가지 유틸리티 메소드가 있습니다.

• cloneBean Bean 클래스 자체가 Cloneable을 구현하지 않더라도 사용 가능한 특성 getter 및 setter를 기반으로 Bean을 복제합니다.
• copyProperties 등록 정보 이름이 동일한 모든 경우에 대해 원점 Bean에서 대상 Bean으로 등록 정보 값을 복사합니다.

패키지 import org.apache.commons.lang.SerializationUtils;에는 다음과 같은 방법이 있습니다.

SerializationUtils.clone(Object);

예:

this.myObjectCloned = SerializationUtils.clone(this.object);

다음과 같이 따르십시오.

public class Deletable implements Cloneable{

    private String str;
    public Deletable(){
    }
    public void setStr(String str){
        this.str = str;
    }
    public void display(){
        System.out.println("The String is "+str);
    }
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

다른 객체를 얻으려면 어디에서나 간단하게 복제를 수행하십시오. 예 :

Deletable del = new Deletable();
Deletable delTemp = (Deletable ) del.clone(); // this line will return you an independent
                                 // object, the changes made to this object will
                                 // not be reflected to other object

Reflection API 사용에 대한 답변이없는 이유는 무엇입니까?

private static Object cloneObject(Object obj){
        try{
            Object clone = obj.getClass().newInstance();
            for (Field field : obj.getClass().getDeclaredFields()) {
                field.setAccessible(true);
                field.set(clone, field.get(obj));
            }
            return clone;
        }catch(Exception e){
            return null;
        }
    }

정말 간단합니다.

편집 : 재귀를 통해 자식 개체 포함

private static Object cloneObject(Object obj){
        try{
            Object clone = obj.getClass().newInstance();
            for (Field field : obj.getClass().getDeclaredFields()) {
                field.setAccessible(true);
                if(field.get(obj) == null || Modifier.isFinal(field.getModifiers())){
                    continue;
                }
                if(field.getType().isPrimitive() || field.getType().equals(String.class)
                        || field.getType().getSuperclass().equals(Number.class)
                        || field.getType().equals(Boolean.class)){
                    field.set(clone, field.get(obj));
                }else{
                    Object childObj = field.get(obj);
                    if(childObj == obj){
                        field.set(clone, clone);
                    }else{
                        field.set(clone, cloneObject(field.get(obj)));
                    }
                }
            }
            return clone;
        }catch(Exception e){
            return null;
        }
    }

Google의 JSON 라이브러리를 사용하여 직렬화 한 다음 직렬화 된 객체의 새 인스턴스를 만듭니다. 몇 가지 제한 사항으로 딥 카피를 수행합니다.

• 재귀 참조는있을 수 없습니다

• 이종 유형의 배열을 복사하지 않습니다.

• 배열과 목록을 입력해야합니다. 그렇지 않으면 인스턴스화 할 클래스를 찾을 수 없습니다

• 자신을 선언하는 클래스에서 문자열을 캡슐화해야 할 수도 있습니다.

또한이 클래스를 사용하여 사용자 기본 설정, 창 및 런타임시 다시로드하지 않을 내용을 저장합니다. 사용하기 쉽고 효과적입니다.

import com.google.gson.*;

public class SerialUtils {

//___________________________________________________________________________________

public static String serializeObject(Object o) {
    Gson gson = new Gson();
    String serializedObject = gson.toJson(o);
    return serializedObject;
}
//___________________________________________________________________________________

public static Object unserializeObject(String s, Object o){
    Gson gson = new Gson();
    Object object = gson.fromJson(s, o.getClass());
    return object;
}
       //___________________________________________________________________________________
public static Object cloneObject(Object o){
    String s = serializeObject(o);
    Object object = unserializeObject(s,o);
    return object;
}
}

예, 객체를 참조하고 있습니다. 구현 된 객체를 복제 할 수 있습니다 Cloneable.

객체 복사에 대한이 위키 기사를 확인하십시오.

여기를 참조하십시오 : 객체 복사

Cloneable수업에 코드 추가 및 아래

public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

이것을 사용하십시오 clonedObject = (YourClass) yourClassObject.clone();

예. 객체 를 딥 카피 해야합니다.

이것도 작동합니다. 가정 모델

class UserAccount{
   public int id;
   public String name;
}

먼저 compile 'com.google.code.gson:gson:2.8.1'앱에 gradle & sync를 추가 하십시오. 그때

Gson gson = new Gson();
updateUser = gson.fromJson(gson.toJson(mUser),UserAccount.class);

transient액세스 수정 자 후 키워드를 사용하여 필드 사용을 제외 할 수 있습니다 .

참고 : 이것은 나쁜 습관입니다. 또한 사용하지 않는 것이 좋습니다 Cloneable또는 JavaSerialization이 느리고 고장입니다. 최적의 성능을 위해 쓰기 복사 생성자 심판 .

같은 것

class UserAccount{
        public int id;
        public String name;
        //empty constructor
        public UserAccount(){}
        //parameterize constructor
        public UserAccount(int id, String name) {
            this.id = id;
            this.name = name;
        }

        //copy constructor
        public UserAccount(UserAccount in){
            this(in.id,in.name);
        }
    }

90000 회 반복 테스트 통계 :
라인 UserAccount clone = gson.fromJson(gson.toJson(aO), UserAccount.class);소요 808ms

라인 UserAccount clone = new UserAccount(aO);은 1ms 미만

결론 : 보스가 미쳤고 속도를 선호하는 경우 gson을 사용하십시오. 품질을 원하면 두 번째 사본 생성자를 사용하십시오.

Android Studio에서 복사 생성자 코드 생성기 플러그인 을 사용할 수도 있습니다 .

clone()당신이 그것을 필요로하는지에 대한 적절한 설명 이 있습니다 ...

여기 : clone (Java method)

심층 복제 유틸리티를 사용하십시오.

SomeObjectType copy = new Cloner().deepClone(someObject);

이것은 모든 Java 객체를 딥 복사하고 https://github.com/kostaskougios/cloning 에서 확인 하십시오.

딥 클로닝은 Cloneable인터페이스 구현 및 clone()메서드 재정의 가 필요한 답변 입니다.

public class DummyBean implements Cloneable {

   private String dummy;

   public void setDummy(String dummy) {
      this.dummy = dummy;
   }

   public String getDummy() {
      return dummy;
   }

   @Override
   public Object clone() throws CloneNotSupportedException {
      DummyBean cloned = (DummyBean)super.clone();
      cloned.setDummy(cloned.getDummy());
      // the above is applicable in case of primitive member types like String 
      // however, in case of non primitive types
      // cloned.setNonPrimitiveType(cloned.getNonPrimitiveType().clone());
      return cloned;
   }
}

당신은 이것을 이렇게 부를 것입니다 DummyBean dumtwo = dum.clone();

그러기 위해서는 어떤 방법 으로든 객체를 복제해야합니다. Java에는 복제 메커니즘이 있지만 필요하지 않은 경우에는 사용하지 마십시오. 복사 작업을 수행하는 복사 방법을 만든 후 다음을 수행하십시오.

dumtwo = dum.copy();

다음 은 복사를 수행하기위한 다양한 기술에 대한 조언입니다.

명시 적으로 복사하는 것 이외의 다른 방법은 객체를 변경할 수 없게 만드는 것입니다 ( set또는 다른 변경자 방법 없음). 이런 식으로 질문은 결코 일어나지 않습니다. 더 큰 물체에서는 불변성이 더 어려워 지지만 그 반대편은 작은 물체와 복합 재료로 나뉘는 방향으로 당신을 밀어 붙인다는 것입니다.

egaga의 생성자 복사 방법에 대한 대안 . 이미 POJO가있을 수 있으므로 copy()초기화 된 객체의 복사본을 반환하는 다른 메서드 를 추가하기 만하면 됩니다.

class DummyBean {
    private String dummyStr;
    private int dummyInt;

    public DummyBean(String dummyStr, int dummyInt) {
        this.dummyStr = dummyStr;
        this.dummyInt = dummyInt;
    }

    public DummyBean copy() {
        return new DummyBean(dummyStr, dummyInt);
    }

    //... Getters & Setters
}

이미 가지고 DummyBean있고 사본을 원할 경우 :

DummyBean bean1 = new DummyBean("peet", 2);
DummyBean bean2 = bean1.copy(); // <-- Create copy of bean1 

System.out.println("bean1: " + bean1.getDummyStr() + " " + bean1.getDummyInt());
System.out.println("bean2: " + bean2.getDummyStr() + " " + bean2.getDummyInt());

//Change bean1
bean1.setDummyStr("koos");
bean1.setDummyInt(88);

System.out.println("bean1: " + bean1.getDummyStr() + " " + bean1.getDummyInt());
System.out.println("bean2: " + bean2.getDummyStr() + " " + bean2.getDummyInt());

산출:

bean1: peet 2
bean2: peet 2

bean1: koos 88
bean2: peet 2

그러나 둘 다 잘 작동합니다. 궁극적으로 당신에게 달려 있습니다 ...

class DB {
  private String dummy;

  public DB(DB one) {
    this.dummy = one.dummy; 
  }
}

http://x-stream.github.io/ 에서 XStream으로 딥 카피를 자동으로 수행 할 수 있습니다 .

XStream은 객체를 XML로 직렬화하고 다시 되 돌리는 간단한 라이브러리입니다.

프로젝트에 추가하십시오 (maven을 사용하는 경우)

<dependency>
    <groupId>com.thoughtworks.xstream</groupId>
    <artifactId>xstream</artifactId>
    <version>1.3.1</version>                
</dependency>

그때

DummyBean dum = new DummyBean();
dum.setDummy("foo");
DummyBean dumCopy = (DummyBean) XSTREAM.fromXML(XSTREAM.toXML(dum));

이를 통해 복제 인터페이스를 구현할 필요없이 사본을 얻을 수 있습니다.

public class MyClass implements Cloneable {

private boolean myField= false;
// and other fields or objects

public MyClass (){}

@Override
public MyClass clone() throws CloneNotSupportedException {
   try
   {
       MyClass clonedMyClass = (MyClass)super.clone();
       // if you have custom object, then you need create a new one in here
       return clonedMyClass ;
   } catch (CloneNotSupportedException e) {
       e.printStackTrace();
       return new MyClass();
   }

  }
}

그리고 당신의 코드에서 :

MyClass myClass = new MyClass();
// do some work with this object
MyClass clonedMyClass = myClass.clone();

복사하려는 객체를 전달하고 원하는 객체를 가져옵니다.

private Object copyObject(Object objSource) {
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(objSource);
            oos.flush();
            oos.close();
            bos.close();
            byte[] byteData = bos.toByteArray();
            ByteArrayInputStream bais = new ByteArrayInputStream(byteData);
            try {
                objDest = new ObjectInputStream(bais).readObject();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return objDest;

    }

이제 objDest원하는 객체로 구문 분석하십시오 .

행복한 코딩!

메소드 를 구현 Cloneable하고 사용 하려고 시도 할 수 있습니다 clone(). 그러나, 당신은 당신이해야 복제 방법을 사용하는 경우 - 항상 무시 - 표준으로 Object의 public Object clone()방법을.

소스 파일에 주석을 추가 할 수 있습니다, 같은 주석 프로세서 또는 코드 생성기 이 하나 를 사용할 수 있습니다.

import net.zerobuilder.BeanBuilder

@BeanBuilder
public class DummyBean { 
  // bean stuff
}

얕은 복사본을 만드는 DummyBeanBuilders정적 메서드가있는 클래스 가 dummyBeanUpdater수동으로 생성되는 것과 같은 방식으로 생성됩니다.

DummyBean bean = new DummyBean();
// Call some setters ...
// Now make a copy
DummyBean copy = DummyBeanBuilders.dummyBeanUpdater(bean).done();

gson객체 복제에 사용 합니다.

public static <T>T copyObject(Object object){
    Gson gson = new Gson();
    JsonObject jsonObject = gson.toJsonTree(object).getAsJsonObject();
    return gson.fromJson(jsonObject,(Type) object.getClass());
}

내가 객체가 있다고 가정 person낭포

Person copyPerson = copyObject(person);