मैं जावा में किसी ऑब्जेक्ट को कैसे कॉपी करूं?

794

नीचे दिए गए कोड पर विचार करें:

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 = dum, तो जावा केवल संदर्भ को कॉपी करता है । तो, क्या इसकी कोई नई प्रतिलिपि बनाने dumऔर इसे असाइन करने का कोई तरीका है dumtwo?

java  object  copy  clone 
— वीरा
स्रोत

जवाबों:

611

एक प्रतिलिपि निर्माता बनाएँ:

class DummyBean {
  private String dummy;

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

प्रत्येक ऑब्जेक्ट में एक क्लोन विधि भी होती है जिसका उपयोग ऑब्जेक्ट को कॉपी करने के लिए किया जा सकता है, लेकिन इसका उपयोग न करें। क्लास बनाना और अनुचित क्लोन विधि करना बहुत आसान है। यदि आप ऐसा करने जा रहे हैं, तो कम से कम जोशुआ बलोच ने इसके बारे में प्रभावी जावा में क्या कहना है पढ़ें ।

— egaga
स्रोत
45
लेकिन फिर उसे अपने कोड को डमीबैन दो = नए डमीबैन (एक) में बदलना होगा; सही?
— क्रिस के
12
क्या यह विधि प्रभावी रूप से एक गहरी प्रतिलिपि के रूप में एक ही चीज़ को पूरा करती है?
— मैथ्यू पिज़ियाक
124
@MatthewPiziak, मेरे लिए - यह एक गहरी क्लोन नहीं होगी क्योंकि कोई भी नेस्टेड ऑब्जेक्ट अभी भी मूल स्रोत उदाहरण को संदर्भित कर रहा होगा, डुप्लिकेट नहीं जब तक कि प्रत्येक संदर्भ (गैर-मूल्य प्रकार) ऑब्जेक्ट ऊपर के समान कंस्ट्रक्टर टेम्पलेट की आपूर्ति न करे।
— स्लीवरनिंजा -
17
@ टिमम: हां, वे उसी स्ट्रिंग का संदर्भ देंगे, लेकिन क्योंकि यह अपरिवर्तनीय है, यह ठीक है। एक ही आदिम के लिए चला जाता है। गैर-आदिम लोगों के लिए, आप बस पुनरावर्ती कॉल कॉपी करेंगे। जैसे अगर DummyBean संदर्भित FooBar तो FooBar contructor FooBar (FooBar एक और) होना चाहिए, और डमी बुलाना चाहिए this.foobar नई FooBar (another.foobar) =
— egaga
7
@ChristianVielma: नहीं, यह "जॉन्डो" नहीं होगा। जैसे टिम्मम ने कहा, स्ट्रिंग स्वयं अपरिवर्तनीय है। एक के साथ, सेटडमी (..) आप "जॉन्डो" को इंगित करने के लिए एक में संदर्भ सेट करते हैं, लेकिन एक में नहीं।
— keuleJ
404

बेसिक: जावा में ऑब्जेक्ट कॉपी करना।

हमें एक वस्तु मान लेते हैं obj1, कि दो वस्तुओं, शामिल containedObj1 और containedObj2 ।
यहां छवि विवरण दर्ज करें

उथली नकल:
उथले नकल एक instanceही वर्ग का एक नया बनाता है और सभी क्षेत्रों को नए उदाहरण में कॉपी करता है और इसे वापस करता है। ऑब्जेक्ट क्लास एक cloneविधि प्रदान करता है और उथले नकल के लिए समर्थन प्रदान करता है।
यहां छवि विवरण दर्ज करें

गहरी नकल:
एक गहरी प्रतिलिपि तब होती है जब किसी वस्तु को वस्तुओं के साथ कॉपी किया जाता है, जिसमें यह संदर्भित होता है । नीचे दी गई छवि शो के obj1बाद उस पर एक गहरी प्रतिलिपि प्रस्तुत की गई है। न केवल obj1नकल की गई है , बल्कि इसके भीतर मौजूद वस्तुओं को भी कॉपी किया गया है। हम Java Object Serializationएक गहरी प्रतिलिपि बनाने के लिए उपयोग कर सकते हैं । दुर्भाग्य से, इस दृष्टिकोण में कुछ समस्याएं भी हैं ( विस्तृत उदाहरण )।
यहां छवि विवरण दर्ज करें

संभावित समस्याएं:
clone सही ढंग से लागू करने के लिए मुश्किल है।
यह उपयोग करने के लिए बेहतर है रक्षात्मक नकल , नकल कंस्ट्रक्टर्स या (@egaga उत्तर के रूप में) स्थिर कारखाने तरीकों ।

  1. यदि आपके पास कोई ऑब्जेक्ट है, तो आपको पता है कि एक सार्वजनिक clone()विधि है, लेकिन आप संकलन के समय ऑब्जेक्ट का प्रकार नहीं जानते हैं, तो आपको समस्या है। जावा में एक इंटरफ़ेस है Cloneable। व्यवहार में, हमें इस इंटरफ़ेस को लागू करना चाहिए अगर हम एक वस्तु बनाना चाहते हैं Cloneable। Object.cloneहै संरक्षित , इसलिए हम चाहिए ओवरराइड क्रम में एक सार्वजनिक विधि के साथ यह यह सुलभ होने के लिए।
  2. एक और समस्या तब होती है जब हम किसी जटिल वस्तु की गहरी नकल करने की कोशिश करते हैं । मान लें कि सभी सदस्य ऑब्जेक्ट चर की विधि भी गहरी प्रतिलिपि बनाती है, यह धारणा का बहुत जोखिम भरा है। आपको सभी कक्षाओं में कोड को नियंत्रित करना होगा।clone()

उदाहरण के लिए org.apache.commons.lang.SerializationUtils में सीरीज़ ( स्रोत ) का उपयोग करके डीप क्लोन के लिए विधि होगी । अगर हमें बीन को क्लोन करने की आवश्यकता है, तो org.apache.commons.beanutils ( स्रोत ) में कुछ उपयोगी तरीके हैं ।

  • cloneBean उपलब्ध संपत्ति पाने वालों और बसने के आधार पर एक बीन क्लोन करेगा, भले ही बीन क्लास खुद क्लोएनेबल को लागू न करे।
  • copyProperties संपत्ति के नाम समान हैं, जहां सभी मामलों के लिए मूल बीन से गंतव्य मान तक संपत्ति मूल्यों की नकल करेंगे।
— चन्द्रशेखर
स्रोत
1
क्या आप यह बता सकते हैं कि किसी अन्य वस्तु के भीतर क्या वस्तु निहित है?
— फ्रीकीसियर
1
@ चन्द्रशेखर "उथली नकल एक ही वर्ग का एक नया उदाहरण बनाता है और सभी क्षेत्रों को नए उदाहरण में कॉपी करता है और उसे वापस लौटाता है" जो कि सभी क्षेत्रों का उल्लेख करने के लिए गलत है, bcz ऑब्जेक्ट्स को केवल कॉपी किए गए संदर्भों की प्रतिलिपि नहीं मिलती है जो इंगित करता है वही वस्तु जो पुरानी (मूल) की ओर इशारा कर रही थी।
— जावा
4
@ सूनी - चंद्रा का विवरण सही है। और इसलिए आपका विवरण क्या होता है; मैं कह रहा हूं कि आपको "सभी क्षेत्रों की प्रतियां" के अर्थ की गलत समझ है। क्षेत्र है , संदर्भ यह वस्तु के रूप में भेजा जा रहा है नहीं है। "सभी क्षेत्रों की नकल" का अर्थ है "उन सभी संदर्भों की प्रतिलिपि बनाना"। यह अच्छा है कि आपने इंगित किया कि वास्तव में इसका क्या मतलब है, किसी और के लिए जो आपके समान गलत व्याख्या करता है, बयान "सभी क्षेत्रों की नकल"। :)
— टूलमेकरसेव
2
... अगर हम वस्तुओं के "संकेत" के साथ कुछ निचले स्तर की ओओ भाषा के संदर्भ में सोचते हैं, तो ऐसे क्षेत्र में स्मृति में पता होगा (जैसे "0x70FF1234") जिस पर ऑब्जेक्ट डेटा पाया जाता है। वह पता "फ़ील्ड मान" है जिसे कॉपी (असाइन) किया जा रहा है। आप सही हैं कि अंतिम परिणाम यह है कि दोनों ऑब्जेक्ट्स में एक ही ऑब्जेक्ट पर (बिंदु पर) संदर्भित फ़ील्ड हैं।
— टूलमेकरस्टेव
127

पैकेज import org.apache.commons.lang.SerializationUtils;में एक विधि है:

SerializationUtils.clone(Object);

उदाहरण:

this.myObjectCloned = SerializationUtils.clone(this.object);
— पचेको
स्रोत
59
जब तक ऑब्जेक्ट लागू होता हैSerializable
— Androiderson
2
इस मामले में क्लोन की गई वस्तु का मूल में कोई संदर्भ नहीं है, अगर अंतिम एक स्थिर है।
— दांते
8
ऑब्जेक्ट को क्लोन करने के लिए एक थर्ड पार्टी लाइब्रेरी!
— खान
2
@ खान, "थर्ड पार्टी लाइब्रेरी टू बस" एक पूरी तरह से अलग चर्चा है! : डी
— चार्ल्स वुड
103

बस नीचे के रूप में पालन करें:

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
— भास्कर तिवारी
स्रोत
1
क्या आपने यह परीक्षण किया? मैं अपने प्रोजेक्ट के लिए इसका इस्तेमाल कर सकता हूं और सही होना जरूरी है।
— धुंध
2
@ मिस्टी मैंने इसे टेस्ट किया है। मेरे उत्पादन ऐप पर पूरी तरह से काम करता है
— Andrii Kovalchuk
क्लोनिंग के बाद, जब आप मूल ऑब्जेक्ट को संशोधित करते हैं, तो यह क्लोन को भी संशोधित कर रहा है।
— शिबिश
4
यह गलत है कि यह एक गहरी प्रति नहीं है जो मांगी गई थी।
— ब्लूहॉर्न
1
यह विधि पॉइंटर को क्लोन करती है जो क्लोन करने योग्य ऑब्जेक्ट के लिए इंगित करता है, लेकिन दोनों ऑब्जेक्ट के अंदर सभी गुण समान हैं, इसलिए मेमोरी में एक नई ऑब्जेक्ट बनाई गई है, लेकिन प्रत्येक ऑब्जेक्ट के अंदर डेटा मेमोरी से एक ही डेटा है
— उमर हुसामल्डिन
40

प्रतिबिंब एपीआई का उपयोग करने के लिए कोई जवाब क्यों नहीं है?

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;
        }
    }
— WillingLearner
स्रोत
यह बहुत बेहतर लग रहा है, लेकिन आपको केवल अंतिम फ़ील्ड पर विचार करने की आवश्यकता है क्योंकि असफल (सत्य) विफल हो सकता है, इसलिए हो सकता है कि फ़ील्ड को शुरू करने के लिए अलग से अवैध IllegalAccessException को संभालने के लिए u की आवश्यकता हो। फ़ील्ड (क्लोन, field.get (obj) को अलग से कॉल करना
— अधिकतम
1
मुझे यह बहुत पसंद आया लेकिन क्या आप इसे जेनेरिक का उपयोग करने के लिए रिफलेक्टर कर सकते हैं? निजी स्थिर <T> T क्लोनऑब्जेक्ट (T obj) {....}
— एडेलिन
2
मुझे लगता है कि यह मुद्दा है जब हमारे पास इसके माता-पिता के लिए गुणों से संदर्भ है: Class A { B child; } Class B{ A parent; }
— नथई
यह इस स्थिति में भी विफल रहता है, इसे संभालने की आवश्यकता है, मैं इसके साथ खेलूंगा टॉमोरो। class car { car car = new car(); }
— जॅान anabčan
2
यह एरर प्रोन है। यकीन नहीं होगा कि यह संग्रह को कैसे संभालेगा
— ACV
31

मैं इसे क्रमबद्ध करने के लिए 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;
}
}
— पीटर
स्रोत
यह बहुत अच्छा काम करता है। लेकिन अगर आप लिस्ट <Integer> जैसी किसी चीज़ को क्लोन करने की कोशिश करते हैं तो देखें। यह छोटी गाड़ी होगी, मेरे इंटेगर 100.0 में डबल्स में बदल गए। मुझे यह समझने में काफी समय लगा कि वे ऐसे क्यों हैं। इसका हल यह था कि एक-एक करके इंटेर्ज को क्लोन किया जाए और एक चक्र में सूची में जोड़ा जाए।
— पाकीजिस
24

हां, आप केवल ऑब्जेक्ट का संदर्भ बना रहे हैं। यदि यह लागू होता है तो आप ऑब्जेक्ट को क्लोन कर सकते हैं Cloneable।

वस्तुओं की नकल के बारे में इस विकी लेख को देखें।

यहाँ देखें: ऑब्जेक्ट कॉपी करना

— Chrisb
स्रोत
14

Cloneableअपनी कक्षा में कोड जोड़ें और नीचे करें

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

इसे इस्तेमाल करो clonedObject = (YourClass) yourClassObject.clone();

— तेजा मारिदु
स्रोत
12

हाँ। आपको अपने ऑब्जेक्ट को डीप कॉपी करने की आवश्यकता है ।

— ब्रूनो कोंडे
स्रोत
1
जैसा कि, यह भी एक प्रति नहीं है।
— माइकल मायर्स
यह शायद सबसे कम सहायक उत्तर है, जिसे मैंने स्टैकओवरफ्लो पर देखा है।
— सिरिल
12

यह भी काम करता है। मॉडल मानते हुए

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

सबसे पहले compile 'com.google.code.gson:gson:2.8.1'अपने ऐप में जोड़ें > ग्रेड और सिंक। फिर

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 पुनरावृत्ति के परीक्षण आँकड़े:
लाइन 808msUserAccount clone = gson.fromJson(gson.toJson(aO), UserAccount.class); लेता है

लाइन 1msUserAccount clone = new UserAccount(aO); से कम लगती है

निष्कर्ष: यदि आपका बॉस पागल है और आप गति पसंद करते हैं तो गन्स का उपयोग करें। यदि आप गुणवत्ता पसंद करते हैं तो दूसरी कॉपी कंस्ट्रक्टर का उपयोग करें।

आप एंड्रॉइड स्टूडियो में कॉपी कंस्ट्रक्टर कोड जनरेटर प्लगइन का उपयोग भी कर सकते हैं ।

— Qamar
स्रोत
यदि यह बुरा व्यवहार है तो आपने इसे क्यों सुझाया?
— पार्थ मेहरोत्रा
धन्यवाद @ParthMehrotra अब सुधर गया
— Qamar
9

एक गहरी क्लोनिंग उपयोगिता का उपयोग करें: 

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

यह किसी भी जावा ऑब्जेक्ट को कॉपी करेगा, इसे https://github.com/kostaskougios/cloning पर देखें

— cojones
स्रोत
1
कस्टम क्लास का उपयोग करके मेरे लिए काम नहीं किया। निम्नलिखित अपवाद प्राप्त करना: java.lang.NoClassDefFoundError: sun.reflect.ReflectionFactory
— stefanjunker
9

डीप क्लोनिंग आपका जवाब है, जिसमें 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();

— अब्बास
स्रोत
2
dummy, एक String, अपरिवर्तनीय है, आप इसे कॉपी की जरूरत नहीं है
— स्टीव कू
7

ऐसा करने के लिए आपको ऑब्जेक्ट को किसी तरह से क्लोन करना होगा। यद्यपि जावा में एक क्लोनिंग तंत्र है, अगर आपको नहीं करना है तो इसका उपयोग न करें। एक कॉपी विधि बनाएं जो आपके लिए कॉपी का काम करे और फिर करें:

dumtwo = dum.copy();

यहाँ एक प्रतिलिपि को पूरा करने के लिए विभिन्न तकनीकों पर कुछ और सलाह दी गई है।

— Yishai
स्रोत
6

स्पष्ट रूप से नकल करने के अलावा, एक अन्य दृष्टिकोण वस्तु को अपरिवर्तनीय (कोई setया अन्य उत्परिवर्ती तरीके) बनाने के लिए है। इस तरह सवाल कभी नहीं उठता। बड़ी वस्तुओं के साथ अपरिहार्यता अधिक कठिन हो जाती है, लेकिन इसका दूसरा पहलू यह है कि यह आपको सुसंगत छोटी वस्तुओं और कंपोजिट में विभाजित होने की दिशा में धकेलती है।

— टॉम हॉकिन - डीललाइन
स्रोत
5

उदाहरण के लिए, उदाहरण के लिए कॉपी की रचनाकार विधि। आपके पास संभवतः पहले से ही एक पीओजेओ है, इसलिए बस एक और तरीका जोड़ें 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

लेकिन दोनों अच्छी तरह से काम करते हैं, यह अंततः आपके ऊपर है ...

— पियरे
स्रोत
3

आप XStream के साथ, http://x-stream.github.io/ से स्वचालित रूप से कॉपी कर सकते हैं :

एक्सस्ट्रीम एक्सएमएल और फिर से वापस वस्तुओं को अनुक्रमित करने के लिए एक सरल पुस्तकालय है।

इसे अपनी परियोजना में जोड़ें (यदि मावेन का उपयोग करके)

<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));

इसके साथ आपके पास किसी भी क्लोनिंग इंटरफ़ेस को लागू करने की आवश्यकता के बिना एक प्रति है।

— जयम हबतलज
स्रोत
29
XML से / के लिए परिवर्तित बहुत सुंदर नहीं लगता ... नरम शब्दों में कहना!
— टिम्मम
java.beans.XMLEncoderएक मानक जावा एपीआई के लिए एक नज़र डालें जो एक्सएमएल पर भी प्रसारित होता है (हालांकि गहरी प्रतिलिपि उद्देश्यों के लिए ठीक नहीं)।
— Jaime Hablutzel
1
क्या आपको एहसास है कि यह कितना भारी है?
— महिद्दीन
1
मेरी राय में बहुत उपरि करने के लिए रास्ता, क्योंकि आपको एक 3 पार्टी लाइब्रेरी जोड़ने और ऑब्जेक्ट सीरियलाइज़ेशन करने की ज़रूरत है, जो सबसे अधिक संभावना है कि एक विशाल प्रदर्शन प्रभाव पड़ता है।
— NiThDi
2 
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();
— अमीर होसैन घासेमी
स्रोत
2
यदि आप अपवाद को पकड़ने की कोशिश करते हैं और फेंका नहीं जाता है, तो घोषणा में "थ्रोन्स क्लॉटनॉटसुप्रेसेडसेप्शन" को सेट करने का कोई मतलब नहीं है। तो, आप इसे हटा सकते हैं।
— क्रिश्चियन
2

उस वस्तु को पास करें जिसे आप कॉपी करना चाहते हैं और वह वस्तु प्राप्त करना चाहते हैं जो आप चाहते हैं:

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इच्छित वस्तु को पार्स करें ।

हैप्पी कोडिंग!

— A-Droid Tech
स्रोत
1

आप विधि को लागू करने Cloneableऔर उपयोग करने का प्रयास कर सकते हैं clone(); हालांकि, आप क्लोन विधि आपको चाहिए का उपयोग करता है, तो - हमेशा ओवरराइड - मानक द्वारा Objectकी public Object clone()विधि।

1

आप स्रोत फ़ाइल में एक टिप्पणी जोड़ सकते हैं, एक एनोटेशन प्रोसेसर या की तरह कोड जनरेटर यह एक प्रयोग किया जा सकता।

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();
— लार्स बोहल
स्रोत
0

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);
— tuhin47
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.