2012-10-03 15 views
10

आप क्या करेंगे?जावा अनुकूलन: स्थानीय चर या फ़ंक्शन कॉल

doThings(folder.getInstructions()) ; 
for (Instruction instruction : folder.getInstructions()) { 
    // do things 
} 
functionCall(folder.getInstructions()) ; 

या इस:

instructions = folder.getInstructions() ; 
doThings(instructions) 
for (Instruction instruction : instructions) { 
    // do things 
} 
functionCall(instructions) ; 

इन सबसे ऊपर, मुझे पता है कि जब यह एक स्थानीय वेरिएबल में मान स्टोर करने के लिए और अधिक कुशल है चाहते हैं, और जब यह समारोह कॉल करने के लिए बेहतर है।

उत्तर

20

अधिक पठनीय अधिक कुशल है। अस्थायी अभिव्यक्तियों और स्थानीय चरों को एक ही स्थान की आवश्यकता होती है और सीपीयू/जेवीएम परिप्रेक्ष्य से यह बहुत अंतर नहीं करता है। JVM बेहतर काम करने/इसे जोड़ने में बेहतर काम करेगा।

हालांकि getInstructions() विधि कॉल महंगा है, कैश यह स्थानीय चर में है। यदि यह सिर्फ एक सादा गेटर है, तो इसे वैसे भी रेखांकित किया जाएगा। इसके अलावा आपके विशेष मामले में IMHO स्थानीय चर अधिक पठनीय है और getInstructions() में समय के साथ अलग-अलग परिणाम होने पर शायद और भी सही हो सकता है।

0

जब भी, आप एक से अधिक तरीकों के परिणाम का उपयोग करना चाहते हैं, तो कुछ अस्थायी चर में विधि आमंत्रण के परिणाम को स्टोर करना बेहतर होता है .. यह विधि आमंत्रण के प्रसंस्करण समय को बचाता है .. इससे अधिक प्रभावित नहीं होगा यह मामला .. लेकिन कई आमंत्रण होने पर प्रभावित हो सकता है ..

इसके अलावा, याद रखें, आपके स्थानीय चर stack पर संग्रहीत हैं। इसलिए, एक अस्थायी स्थानीय चर होने पर ढेर पर जगह पर कब्जा कर रहा है। हालांकि इस इस तरह छोटे मामलों में एक चिंता का ज्यादा .. लेकिन अनावश्यक स्थानीय चर नहीं है, से बचा जाना चाहिए ..

तो, पेशेवरों और विपक्ष दोनों तरीकों में से देखते हैं ..

10

यह पूरी तरह से getInstructions() पर निर्भर करता है। यदि यह सिर्फ एक फ़ील्ड के मान को वापस कर रहा है - और यदि आपको विश्वास है कि फ़ील्ड मान कॉल के बीच नहीं बदलेगा - तो शायद आपको दो स्निपेट के बीच कोई दक्षता अंतर दिखाई नहीं देगा।

यदि दूसरी ओर, getInstructions() को दर्जनों वेब अनुरोध करने की आवश्यकता है, तो स्पष्ट रूप से आप कई बार कॉल करने से बचना चाहते हैं।

हालांकि दक्षता दक्षता से अधिक महत्वपूर्ण है। इस मामले में मुझे दूसरा विकल्प वैसे भी अधिक पठनीय लगता है - यह स्पष्ट है कि आप एक ही मूल्य के साथ तीन अलग-अलग चरणों (दो विधि कॉल और लूप) लेना चाहते हैं।

int length; 
for (int i = 0; i < length; i++) { 
    ... 
} 

यह वास्तव में संदर्भ पर निर्भर करता: बल्कि तोड़ने कि एक अलग चर में बाहर से

for (int i = 0; i < text.length(); i++) { 
    ... 
} 

: दूसरी ओर, मैं की तरह कुछ लिखने के लिए काफी खुश हूं। कभी-कभी एक अतिरिक्त चर मदद करता है, कभी-कभी यह एक पठनीयता परिप्रेक्ष्य से नहीं करता है। दक्षता परिप्रेक्ष्य पूरी तरह से निर्भर करता है कि विधि कॉल क्या कर रहा है, और क्या यह जेआईटी के लिए "अटूट" है।

0

मेरा उत्तर आवेदन पर निर्भर करेगा जो मैं विकसित करने की कोशिश कर रहा हूं।उदाहरण के लिए,

पहले कोड ब्लॉक बेहतर होता है यदि एप्लिकेशन के दौरान मूल्य तेजी से बदलते हैं। यदि आपको सटीक परिणाम की आवश्यकता है तो यह अच्छा है।

दूसरा एक अच्छा है यदि आप सुनिश्चित हैं कि शुरू में किए गए मान कोड के अन्य हिस्सों को प्रभावित नहीं करेंगे।

0

मेरा मानना ​​है कि यह स्थिति पर निर्भर करता है। यदि इसे एक ही विधि को कई बार कॉल करने की आवश्यकता होती है (और आपको एक ही मूल्य मिल रहा है) और बेहतर एक कॉल करें और इसे कुछ स्थानीय चर में संग्रहीत करें।

और यदि आपको केवल एक बार फ़ंक्शन कॉल करने की आवश्यकता है। स्थानीय चर के लिए जाने की जरूरत नहीं है।

संबंधित मुद्दे