जावा: प्रत्येक-लूप और संदर्भ

Question

मुझे आश्चर्य है कि निम्न लूप वस्तु का एक प्रति बनाता है, बल्कि मुझे इसका संदर्भ देने के बजाय। कारण यह है कि, पहला उदाहरण मेरी सरणी वस्तुओं को आवंटित नहीं करता है, लेकिन दूसरा करता है।

अपने सरणी

MyObject objects[] = new MyObject[6]; 
for (MyObject o: objects) { 

    o = new MyObject(); 
} 

MyObject objects[] = new MyObject[6]; 
for(int i = 0; i < objects.length; i++) { 

    objects[i] = new MyObject(); 
} 

Answer 1

जावा कई अन्य भाषाओं की तुलना में थोड़ा अलग काम करता है। क्या o पहले उदाहरण में है बस वस्तु का संदर्भ है।

जब आप कहते हैं कि o = new MyObject(), यह प्रकार MyObject और उस वस्तु के लिए संदर्भ o की एक नई वस्तु बनाता है o से पहले संदर्भित जबकि objects[index]।

यही है, ऑब्जेक्ट्स [इंडेक्स] ही स्मृति में किसी अन्य वस्तु का संदर्भ है। इसलिए ऑब्जेक्ट्स [इंडेक्स] को एक नए मायऑब्जेक्ट में सेट करने के लिए, आपको ऑब्जेक्ट्स [इंडेक्स] को इंगित करने की आवश्यकता है, जिसे ऑब्जेक्ट्स [इंडेक्स] का उपयोग करके ही किया जा सकता है।

छवि: (मेरे भयानक रंग कौशल: डी)

स्पष्टीकरण: यह मोटे तौर पर कैसे जावा स्मृति प्रबंधन काम करता है। बिलकुल नहीं, किसी भी माध्यम से, लेकिन मोटे तौर पर। आपके पास ऑब्जेक्ट्स हैं, जो ए 1 का संदर्भ देता है। जब आप ऑब्जेक्ट सरणी एक्सेस करते हैं, तो आप प्रारंभिक संदर्भ बिंदु (ए 1) से शुरू करते हैं, और एक्स ब्लॉक को आगे बढ़ाते हैं। उदाहरण के लिए, इंडेक्स 1 का संदर्भ आपको बी 1 में लाएगा। बी 1 तब आपको बताता है कि आप ए 2 पर ऑब्जेक्ट की तलाश में हैं। ए 2 आपको बताता है कि इसमें सी 2 में स्थित एक क्षेत्र है। सी 2 एक पूर्णांक, एक मूल डेटा प्रकार है। खोज हो गई है।

ओ ए 1 या बी 1, लेकिन सी 1 या सी 2 का संदर्भ नहीं देता है। जब आप new ... कहते हैं, तो यह एक नई वस्तु बनाएगा और वहां ओ रखेगा (उदाहरण के लिए, स्लॉट ए 3 में)। यह ए 1 या बी 1 को प्रभावित नहीं करेगा।

मुझे बताएं कि क्या मैं चीजों को थोड़ा सा साफ़ कर सकता हूं।

Answer 2

पहले एक आवंटन नहीं किया गया है वस्तुओं क्योंकि foreach छोरों एक संग्रह में तत्वों से अधिक पुनरावृति।

जब आप foreach लूप दर्ज करते हैं तो आपके संग्रह में कोई तत्व नहीं है, यह आकार 6 के लिए शुरू की गई एक खाली सरणी है, इसलिए आपके सरणी में कोई ऑब्जेक्ट नहीं जोड़ा जाएगा।

ही, ध्यान दें कि भले ही आप सरणी में तत्वों था foreach पाश उनमें से शीर्ष पर निर्दिष्ट नहीं करेंगे:

o = new MyObject(); 

मूल रूप से इसका मतलब है o करने के लिए MyObject का एक नया उदाहरण आवंटित है, लेकिन o ही नहीं है सरणी का हिस्सा objects यह केवल एक अस्थायी कंटेनर है जो सरणी के तत्वों को पुन: सक्रिय करने के लिए उपयोग किया जाता है, लेकिन इस मामले में, कोई भी नहीं है।

Answer 3

संक्षिप्त उत्तर: हाँ, एक प्रतिलिपि की तरह कुछ है।

विस्तृत उत्तर: जावा foreach पाश आप पोस्ट के लिए

MyObject objects[] = new MyObject[6]; 

Iterator<MyObject> it = objects.iterator(); 
while (it.hasNext()) { 
    MyObject o = it.next(); 
    // The previous three lines were from the foreach loop 

    // Your code inside the foreach loop 
    o = new MyObject(); 
} 

रूप desugared संस्करण शो वाक्यात्मक चीनी है एक foreach पाश अंदर कुछ के बराबर एक संदर्भ की स्थापना की सामग्री को नहीं बदलता है सरणी।

Answer 4

ऑब्जेक्ट्स केवल "कॉपी" होते हैं जब आप स्पष्ट रूप से बताते हैं कि आप किसी ऑब्जेक्ट को क्लोन करना चाहते हैं (और यह ऑब्जेक्ट स्पष्ट रूप से क्लोनिंग सुविधा लागू करता है)।

आप संदर्भ और नाम भ्रमित लगते हैं।

पहले उदाहरण में, एक foreach के अंदर, स्थानीय o चर मेमोरी के क्षेत्र को संदर्भित करता है objects से कुछ ऑब्जेक्ट संग्रहीत किया जाता है। जब आप o = new MyObject() कर रहे हैं, तो स्मृति के किसी अन्य क्षेत्र में एक नया MyObject प्रारंभ किया गया है, और फिर o संदर्भ स्मृति के इस नए क्षेत्र को इंगित करने के लिए फिर से लिखा गया है।

दूसरे उदाहरण में, objects[i] = new MyObject() लिखकर, आप कह रहे हैं कि objects[i] संदर्भ को फिर से लिखा जाना चाहिए, कुछ स्थानीय o चर नहीं।

Answer 5

मैंने यह स्पष्ट करने के लिए प्रत्येक उदाहरण में एक टिप्पणी जोड़ा कि क्या हो रहा है।

पहले उदाहरण:

MyObject objects[] = new MyObject[6]; 
for(MyObject o: objects) { 

    // Construct a new object of type MyObject and assign a reference to it into 
    // the iteration variable o. This has no lasting effect, because the foreach 
    // loop will automatically assign the next value into the iteration variable 
    // in the the next iteration. 
    o = new MyObject(); 
} 

दूसरा उदाहरण:

MyObject objects[] = new MyObject[6]; 
for(int i = 0; i < objects.length; i++) { 

    // Construct a new object of type MyObject and store a reference to it into the 
    // i-th slot in array objects[]: 
    objects[i] = new MyObject(); 
} 

Answer 6

पहली बात मैं उल्लेख करना चाहते हैं कि गैर शून्य लंबाई सरणियों हमेशा foreach पाश

for(MyObject o in objects) 

अंदर mutable.And हैं

प्रत्येक पुनरावृत्ति में यह क्या करता है यह निम्नानुसार काम करता है।

o = objects[0] // first iteration 
o = objects[1] // 2nd iteration 

लेकिन आपके मामले में आप संदर्भ ऑब्जेक्ट को अन्य ऑब्जेक्ट असाइन करते हैं। सरणी में वस्तुओं के लिए नहीं। यह बस निम्नलिखित की तरह है।

ObjeMyObject objects[] = new MyObject[6]; 
MyObject o = Object[0]; 
0 = new MyObject(); 

लेकिन आपकी मूल वस्तुएं [0] अभी भी एक शून्य वस्तु को इंगित करती हैं।

Answer 7

हर बार जब आप "नया" ऑपरेटर का उपयोग करते हैं तो JVM एक नया उदाहरण बनाएगा और इसे असाइनमेंट ऑपरेटर के बाएं हाथ की ओर से सौंपा जाएगा। यह प्रत्येक लूप या लूप के लिए कोई फर्क नहीं पड़ता। (: ऑब्जेक्ट MyObject ओ) हे एक बार ही नहीं MyObject यह instantiated नहीं किया जाएगा हो जाएगा और वस्तु सरणी से मान होंगे हे में नकल रखने

O = Object[0] 
O = Object[1] 
O = Object[2] 
O = Object[3] 
O = Object[4] 
O = Object[5] 

की तरह बनाया जाएगा के लिए प्रत्येक पाश के लिए में

हमें काउंटर को बढ़ाने की देखभाल करने की आवश्यकता नहीं है, प्रत्येक लूप की सुंदरता है।