लूप के अंदर परिवर्तनीय घोषणा

Question

एक सामान्य दुविधा जो मैंने पूरे प्रोग्रामिंग का सामना किया है वह एक लूप के अंदर चर घोषित करने के बारे में है। myBo पाश बाहर घोषित किया जाना चाहिए

List list=myObject.getList(); 
Iterator itr=list.iterator(); 
while (itr.hasNext()){ 
    BusinessObject myBo=(BusinessObject)itr.next(); 
    process(myBo); 
} 

ऊपर स्निपेट में, या करता है पाश अंदर यह घोषित स्मृति और प्रदर्शन करने के लिए नुकसान का कारण नहीं: मैं निम्नलिखित की तरह कुछ प्रदर्शन करने के लिए है कहो?

Answer 1

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

Answer 2

लूप के अंदर इसे घोषित करने से स्मृति और प्रदर्शन को कोई नुकसान नहीं पहुंचाएगा। संभावित उपयोग List<BusinessObject> और Iterator<BusinessObject> कास्टिंग से बचने के लिए

Answer 3

हैं:

अच्छा सॉफ्टवेयर डिजाइन की

List<BusinessObject> list = myObject.getList(); 
Iterator<BusinessObject> itr = list.iterator(); 

while (itr.hasNext()) { 
    process(itr.next()); 
} 

Answer 4

एक सिद्धांत है स्थानीय चर का दायरा सीमित करने के लिए, यानी उन्हें सिर्फ एक ब्लॉक है कि जल्द ही बाद ही समाप्त होता भीतर समय में घोषित करने के लिए उस चर का अंतिम उपयोग। यह प्रदर्शन या अन्य "कठिन" पहलुओं को प्रभावित नहीं करता है लेकिन प्रोग्राम को अधिक पढ़ने योग्य और विश्लेषण करने में आसान बनाता है।

संक्षेप में, जो भी आप कर रहे हैं वह अच्छा माना जाता है।

Answer 5

यदि छोटा - नहीं। सी ++ में यह समस्या हो सकती है यदि MyBo की प्रतिलिपि बनाकर बनाया गया है लेकिन जावा में हमेशा संदर्भों का उपयोग किया जाता है, है ना?
प्रदर्शन के लिए, अपने बेहतर कुछ आप इस प्रक्रिया में क्या कर रहे हैं अनुकूलन करने के लिए()

Answer 6

अस्थायी संदर्भ myBo ढेर पर डाल दिया जाता है और ज्यादातर दूर अनुकूलित किया जाना चाहिए। आपके कोड में कोई प्रदर्शन जुर्माना नहीं होना चाहिए।

Answer 7

अपने पाश के लिए सबसे सुरुचिपूर्ण समाधान एक पाश (जावा 5 या नया) के लिए बढ़ाया जाएगा:

List<BusinessObject> list = myObject.getList(); 

for(BusinessObject myBo : list) { 
    process(myBo); 
} 

लेकिन फिर भी कोड आप कोई प्रदर्शन समस्या नहीं होगी प्रदान की है, साथ क्योंकि सभी अस्थायी चर केवल BusinessObject पर संदर्भ रखें, जो कि बहुत सस्ता है।

Answer 8

इससे कोई स्मृति हानि नहीं होती है।

BTW जब तक आप कुछ कोड को छोड़ते हुए कर रहे हैं आप पूरी तरह घोषणा को छोड़ सकते हैं:

while (itr.hasNext()){ 
    //BusinessObject myBo=(BusinessObject)itr.next(); 
    process((BusinessObject)itr.next()); 
} 

Answer 9

बस javap -c [ClassName] साथ बाइट कोड पर एक नजर है। लूप के साथ एकल-उपयोग चर के कुछ उदाहरण प्रदर्शित करने वाली एक कक्षा यहां दी गई है। प्रासंगिक बाईटकोड डंप टिप्पणी में है:

class HelloWorldLoopsAnnotated { 
    // 
    // HelloWorldLoopsAnnotated(); 
    // Code: 
    // 0: aload_0 
    // 1: invokespecial #1; //Method java/lang/Object."<init>":()V 
    // 4: return 
    //////////////////////////////////////////////////////////////////////////// 

    void stringDeclaredInsideLoop(){ 
     while (true) { 
      // 0: ldC#2; //String Hello World! 
      String greeting = "Hello World!"; 
      doNothing(greeting); 
     } 
    } 
    // 
    // void stringDeclaredInsideLoop(); 
    // Code: 
    // 0: ldC#2; //String Hello World! 
    // 2: astore_1 
    // 3: aload_0 
    // 4: aload_1 
    // 5: invokespecial #3; //Method doNothing:(Ljava/lang/String;)V 
    // 8: goto 0 
    //////////////////////////////////////////////////////////////////////////// 

    void stringDeclaredOutsideLoop(){ 
     String greeting; 
     while (true) { 
      greeting = "Hello World!"; 
      doNothing(greeting); 
     } 
    } 
    // 
    // void stringDeclaredOutsideLoop(); 
    // Code: 
    // 0: ldC#2; //String Hello World! 
    // 2: astore_1 
    // 3: aload_0 
    // 4: aload_1 
    // 5: invokespecial #3; //Method doNothing:(Ljava/lang/String;)V 
    // 8: goto 0 
    //////////////////////////////////////////////////////////////////////////// 

    void stringAsDirectArgument(){ 
     while (true) { 
      doNothing("Hello World!"); 
     } 
    } 
    // void stringAsDirectArgument(); 
    // Code: 
    // 0: aload_0 
    // 1: ldC#2; //String Hello World! 
    // 3: invokespecial #3; //Method doNothing:(Ljava/lang/String;)V 
    // 6: goto 0 
    //////////////////////////////////////////////////////////////////////////// 

    private void doNothing(String s) { 
    } 
} 

stringDeclaredInsideLoop() और stringDeclaredOutsideLoop() उपज समान छह अनुदेश बाईटकोड। stringDeclaredInsideLoop() अभी भी जीतता है: सीमित दायरा सबसे अच्छा है।

कुछ चिंतन के बाद, मैं वास्तव में नहीं देख सकता कि कितना कसौटी प्रदर्शन कभी प्रभावित करेगा: ढेर में समान डेटा को समान निर्देशों की आवश्यकता होगी।

stringAsDirectArgument(), हालांकि, केवल चार निर्देशों में ऑपरेशन को परिभाषित करता है। कम मेमोरी वातावरण (जैसे मेरा शानदार बेवकूफ फोन) ऑप्टिमाइज़ेशन की सराहना कर सकता है जबकि आपके कोड को पढ़ने वाले सहयोगी नहीं हो सकते हैं, इसलिए अपने कोड से शेविंग बाइट्स से पहले निर्णय लें।

अधिक के लिए full gist देखें।