जावा प्रदर्शन: किसी ऑब्जेक्ट को साफ़ करने पर यह शून्य या सेट करने के लिए एक नया ऑब्जेक्ट बनाना बेहतर होता है।

Question

बार-बार ऑब्जेक्ट का उपयोग करते समय, डेटा को साफ़ करने के लिए इसे साफ़ करना बेहतर होता है, या एक नई ऑब्जेक्ट को तुरंत चालू करना बेहतर होता है?

Customer a = new Customer(); 
Collection<Customer> data = new ArrayList<Customer>(); 

     while (rs != null && rs.next()) { 
      a = new Customer(); 
      a.setCustId(rs.getLong("CUST_ID")); 
      a.setPerNo(period); 
      a.setName(rs.getString("cust_nm")); 

      if(a!= null) 
       data.add(a); 
     } 

मैं सोच रहा हूँ

a = new Customer(); 

यह करने के लिए सबसे अच्छा तरीका है या यह किया जाना चाहिए अगर है कि क्या:

Object a = new Object(); 
    for(...){ 
     ... 
     a = null; 
     **OR** 
     a = new Object(); 
    } 

यहाँ उदाहरण मैं की बात कर रहा हूँ है स्मृति पर और इष्टतम प्रदर्शन के लिए अलग-अलग, क्योंकि प्रत्येक लूप में नई ग्राहक जानकारी डालने के लिए है। मेरी समझ से, यदि आप कोई नया ग्राहक बनाते हैं तो आप एक नई वस्तु बना रहे हैं और उस नई ऑब्जेक्ट को इंगित कर रहे हैं। तो पुरानी वस्तु जो इंगित कर रही थी उसे कचरा कलेक्टर द्वारा उठाया जाएगा - इसे शून्य पर सेट करने के मामले में। क्या यह एक सही समझ है?

Answer 1

मैं पसंद करेंगे:

for (...) { 
    Object a = new Object(); 
    ... 
} 

क्यों गुंजाइश किसी भी अधिक से अधिक की तुलना में यह करने की जरूरत है?

इसी प्रकार, जब तक कि मैं को एक नई वस्तु की आवश्यकता नहीं है, तो मैं इसके लिए एक नहीं बनाऊंगा।

यद्यपि दिए गए विवरण से बहुत कुछ कहना मुश्किल है - अगर आप अधिक पूर्ण और वास्तविक दुनिया का उदाहरण दे सकते हैं, तो हम और अधिक ठोस सिफारिशें कर सकते हैं।

(ध्यान दें कि वहाँ कोई संकेत नहीं है कि आप बार-बार एक वस्तु उपयोग करना चाहते हैं, एक चर बार-बार का उपयोग कर के रूप में इतना है कि वे बहुत अलग अवधारणाओं रहे हैं।।)

संपादित करें: अपने विशिष्ट उदाहरण को देखते , मैं इसे इस तरह लिखना चाहते हैं:

Collection<Customer> data = new ArrayList<Customer>(); 

while (rs != null && rs.next()) { 
    Customer a = new Customer(); 
    a.setCustId(rs.getLong("CUST_ID")); 
    a.setPerNo(period); 
    a.setName(rs.getString("cust_nm")); 

    data.add(a); 
} 

ध्यान दें कि यह किसी भीCustomer जिन वस्तुओं पर कचरा संग्रहण के लिए पात्र हैं पैदा नहीं करता - अपने मूल कोड बनाता है, जबकि लूप में प्रवेश करने से पहले Customer का एक उदाहरण, और फिर नए बनाए गए ऑब्जेक्ट को अनदेखा करता है, इसके बजाय एक नया निर्माण करता है और a के मान को पुन: असाइन करता है।

Answer 2

तत्काल वस्तुओं को जहां आपको उनकी आवश्यकता है। जहां आप नहीं करते हैं। और एक प्रोफाइलर आपको बताए जाने तक अनुकूलन के इस स्तर के बारे में चिंता न करें।

संपादित करें: अपने अपडेट किए गए जवाब को देखते हुए यह पाश अंदर चर घोषित करने और अपने ग्राहकों की वस्तुओं का दृष्टांत को पाठकों के लिए स्पष्ट हो सकता है, के रूप में जॉन की सिफारिश की। आपके प्रदर्शन और कचरा संग्रहण प्रश्नों के अनुसार, आपको improve your grasp of the basic language concepts की आवश्यकता है।

Answer 3

विशेष मामलों के लिए स्पष्ट रूप से न्यूलिंग संदर्भों की आवश्यकता होती है जिसमें आप स्पष्ट रूप से किसी ऑब्जेक्ट का जिक्र करना बंद करना चाहते हैं और ऐसा करने में विफलता के परिणामस्वरूप वास्तविक स्मृति रिसाव होगा। उदाहरण के तौर पर, आप List कार्यान्वयन वाले सरणी पर एक नज़र डाल सकते हैं, जिसमें एनएलएलएस सरणी स्लॉट संदर्भ/ऑब्जेक्ट्स को इंगित करने से बचने के लिए उपयोग नहीं किया जाता है।

Answer 4

मुझे लगता है कि आपका भ्रम यह समझने से नहीं आता है कि वस्तुओं को संदर्भ द्वारा पारित किया जाता है। आप एक सी पृष्ठभूमि से आ रहे हैं, है कि जावा में समझते हैं, Customer a = new Customer(); वास्तव में की तरह

Customer* a = (Customer*) malloc (sizeof(Customer)); 
initializeCustomer (a); //the constructor initializes the state of the object. 

के बाद से आप वास्तव में प्रत्येक ग्राहक को अपनी सूची में जोड़ने के लिए नई स्मृति की जरूरत है कुछ, आप एक नया ग्राहक वस्तु बनाने से बचना नहीं कर सकते लूप के प्रत्येक पुनरावृत्ति के लिए।