क्या सरणी पर क्लोन () कॉलिंग भी इसकी सामग्री को क्लोन करती है?

Question

यदि मैं clone()टाइप ए की वस्तुओं की विधि पर विधि लागू करता हूं , तो यह अपने तत्वों को कैसे क्लोन करेगा? क्या कॉपी उन्हीं वस्तुओं के संदर्भ में होगी? या यह (element of type A).clone()उनमें से प्रत्येक के लिए कॉल करेगा ?

Comments

आपको प्रत्येक तत्व पर क्लोन कॉल करना होगा।

— पीटर लॉरी

Answer 1

clone()उथली प्रति बनाता है। जिसका अर्थ है कि तत्वों का क्लोन नहीं होगा। (क्या होगा अगर वे लागू नहीं कियाCloneable ?)

आप Arrays.copyOf(..)इसके बजाय सरणियों की प्रतिलिपि बनाने के लिए उपयोग कर सकते हैं clone()(हालांकि क्लोनिंग सरणियों के लिए ठीक है, इसके विपरीत कुछ भी)

यदि आप गहरी क्लोनिंग चाहते हैं, तो इस उत्तर को जांचें

---

clone()तत्व हैं, भले ही उथलेपन का वर्णन करने के लिए एक छोटा सा उदाहरण Cloneable:

ArrayList[] array = new ArrayList[] {new ArrayList(), new ArrayList()};
ArrayList[] clone = array.clone();
for (int i = 0; i < clone.length; i ++) {
    System.out.println(System.identityHashCode(array[i]));
    System.out.println(System.identityHashCode(clone[i]));
    System.out.println(System.identityHashCode(array[i].clone()));
    System.out.println("-----");
}

प्रिंटों:

4384790  
4384790
9634993  
-----  
1641745  
1641745  
11077203  
-----  

Comments

और, यदि आप ऐसा करने जा रहे हैं, तो मैं व्यक्तिगत रूप से इस्तेमाल System.arrayCopy

— करूंगा

clone()सरणियों के साथ उपयोग करने के लिए एक अच्छा विकल्प है .. विशेष रूप से। बलोच ने उल्लेख किया कि वह इसका उपयोग केवल सरणियों के लिए करेगा और कुछ नहीं। System.arrayCopyठीक है। Arrays.copyOf(..)एक और विकल्प है जिसका उपयोग करना आसान है।

— बूझो

मैं इसे वापस लेता हूं - मैं उपयोग करूंगा Arrays.copyOf:-) इसमें एक विधि हस्ताक्षर है जो चर को सरल करता है (हाँ यह आपको सीमित करता है, लेकिन यह अधिकांश मामलों के लिए एकदम सही है) और मेरे जेडीके में कम से कम, System.arrayCopyवैसे भी इसका उपयोग किया जाता है। उस टिप के लिए धन्यवाद!

— corsiKa

@Bozho, अपने उदाहरण से। ऐरे [i] और क्लोन [i] एक ही ऑब्जेक्ट को संदर्भित करेंगे इसलिए पहले दो sysouts समान हैं। लेकिन सरणी [i] .clone भी सरणी [i] को संदर्भित करेगा, इसलिए सरणी [i] .clone () एक अलग हैशकोड मान क्यों लौटाता है?

— abhihello123

@weakstudent, array[i].clone()को संदर्भित नहीं करता है array[i]। उदाहरण के उस हिस्से का प्रदर्शन यही है।

— दत्त

Answer 2

यदि मैं टाइप ए की वस्तुओं की सरणी पर क्लोन () विधि लागू करता हूं, तो यह अपने तत्वों को कैसे क्लोन करेगा?

सरणी के तत्वों को क्लोन नहीं किया जाएगा।

क्या कॉपी उन्हीं वस्तुओं के संदर्भ में होगी?

हाँ।

या यह उनमें से प्रत्येक के लिए (ए प्रकार का तत्व) .clone () कहेगा?

नहीं, यह clone()किसी भी तत्व पर कॉल नहीं करेगा ।

Answer 3

जब क्लोन किया जाता है तो प्राइमरी का 1D एलीमेंट एलिमेंट कॉपी करता है। यह हमें 2 डी सरणी (एरे के सरणी) को क्लोन करने के लिए प्रेरित करता है।

याद रखें कि 2 डी सरणी क्लोन उथले कॉपी कार्यान्वयन के कारण काम नहीं करता है clone()।

public static void main(String[] args) {
    int row1[] = {0,1,2,3};
    int row2[] =  row1.clone();
    row2[0] = 10;
    System.out.println(row1[0] == row2[0]); // prints false

    int table1[][]={{0,1,2,3},{11,12,13,14}};
    int table2[][] = table1.clone();
    table2[0][0] = 100;
    System.out.println(table1[0][0] == table2[0][0]); //prints true
}

Comments

क्या आप मुझे बता रहे हैं कि मैं cloneप्राथमिकताओं की 1D सरणी और गहरी प्रतिलिपि प्राप्त कर सकता हूं ? ये तो शानदार है! अच्छा प्रदर्शन किया Arrays.copyOfRange(), System.arraycopy()!

— 19ez में जनेज कुहर

Yessssss! जब

— प्राइमर की

ध्यान दें कि थम्मे गौड़ा एन "आदिम" कहते हैं। वस्तुओं के सरणियों के क्लोन केवल संदर्भों का एक क्लोन होगा।

— क्रिस्टियान

क्योंकि आदिम लोगों के पास कोई राज्य नहीं है, वे स्वाभाविक रूप से अपरिवर्तनीय हैं। आप

— आदिमों

Answer 4

क्लोन सरणी की एक उथली प्रति है।

यह परीक्षण कोड प्रिंट करता है:

[१, २] / [१, २]
[१००, २००] / [१००, २]

क्योंकि MutableIntegerदोनों सरणियों में साझा किया जाता है objects[0]और objects2[0], लेकिन आप संदर्भ को objects[1]स्वतंत्र रूप से बदल सकते हैं objects2[1]।

import java.util.Arrays;                                                                                                                                 

public class CloneTest {                                                                                                                                 
    static class MutableInteger {                                                                                                                        
        int value;                                                                                                                                       
        MutableInteger(int value) {                                                                                                                      
            this.value = value;                                                                                                                          
        }                                                                                                                                                
        @Override                                                                                                                                        
        public String toString() {                                                                                                                       
            return Integer.toString(value);                                                                                                              
        }                                                                                                                                                
    }                                                                                                                                                    
    public static void main(String[] args) {                                                                                                             
        MutableInteger[] objects = new MutableInteger[] {
                new MutableInteger(1), new MutableInteger(2) };                                                
        MutableInteger[] objects2 = objects.clone();                                                                                                     
        System.out.println(Arrays.toString(objects) + " / " + 
                            Arrays.toString(objects2));                                                                
        objects[0].value = 100;                                                                                                                          
        objects[1] = new MutableInteger(200);                                                                                                            
        System.out.println(Arrays.toString(objects) + " / " + 
                            Arrays.toString(objects2));                                                               
    }                                                                                                                                                    
}