2012-03-20 10 views
5

इसलिए ऐरेलिस्ट में क्षमता से संबंधित हर सवाल यह है कि इसका उपयोग कैसे करें या (अजीब) इसका उपयोग कैसे करें और मैं उस जानकारी से काफी परिचित हूं। मुझे क्या दिलचस्पी है कि क्या यह वास्तव में ऐरेलिस्टिस्ट कन्स्ट्रक्टर का उपयोग करने लायक है जो आपको बताता है कि अगर आपको पता चल जाता है या अराजकता में कितनी वस्तुएं होंगी तो क्षमता निर्धारित करती है?क्यों ArrayList (int क्षमता) का उपयोग परेशान?

क्या कोई व्यापक मानक यह तुलना करता है कि एक ऐरेलिस्ट के तत्वों को पूर्व-सेटिंग बनाम एरेलेलिस्ट में तत्वों को बेकार करने में कितना समय लगता है?

+3

जब ArrayList की क्षमता तक पहुँच जाता है, CLR करने के लिए नव निर्मित मूल एक से मूल एक की दोहरी क्षमता और प्रतियां सभी तत्वों के साथ एक नया ArrayList बनाता है एक। इसलिए यदि आप आवश्यक आकार से संबंधित कुछ विचार रखते हैं तो आप ArrayList के आकार को पूर्व निर्धारित करके इस अतिरिक्त कार्य को सहेज सकते हैं। –

+1

@ दीपांशु: क्या यह जावा प्रश्न नहीं है? सीएलआर तस्वीर में कैसे आया? मुझे लगता है कि आप जेवीएम मतलब था? साथ ही, आपका विवरण सही लगता है लेकिन "सीएलआर" (.Net) में, जब मैं आकार को प्रीलोकेट करता हूं तो इसमें अधिक समय लगता है। कम से कम, यह तब होता है जब मैंने 1000000 वस्तुओं पर इसका परीक्षण किया। मैंने इसे 10-15 बार परीक्षण किया और हर बार डिफॉल्ट ऐरेलिस्ट कन्स्ट्रक्टर जीता! – TCM

+0

मैंने ऐरेलिस्ट को कहा, लेकिन यह सामान्य रूप से किसी सरणी द्वारा समर्थित संग्रह के सूची दृश्य रखने के सामान्य रूप से अवधारणा पर लागू हो सकता है। – Maverick

उत्तर

6

स्पष्ट रूप से किसी भी विशिष्ट अनुप्रयोग के लिए आपको यह निर्धारित करने के लिए किसी भी प्रदर्शन समायोजन का परीक्षण करना होगा कि वे वास्तव में अनुकूलन (और यदि वे वास्तव में आवश्यक हैं) हैं, लेकिन कुछ बार यह निर्धारित करने की क्षमता स्पष्ट रूप से सार्थक हो सकती है। उदाहरण के लिए:

  • आप बहुत बड़ी संख्या में सरणी-सूचियां बना रहे हैं, जिनमें से अधिकांश बहुत छोटे होंगे। इस मामले में, आप प्रारंभिक क्षमता को बहुत कम सेट करना चाहते हैं, और/या जब भी आप किसी दिए गए सरणी को पॉप्युलेट कर रहे हैं तो क्षमता को ट्रिम करने के लिए। (इस मामले में, ऑप्टिमाइज़ेशन मेमोरी उपयोग की तुलना में गति की बात कम है। लेकिन ध्यान दें कि सूची में मेमोरी ओवरहेड है, जैसा कि इसमें सरणी है, इसलिए इस तरह की स्थिति में इस तरह की स्थिति में फिर से डिजाइन करना बेहतर होगा एक तरीके के रूप में कम सूचियां बनाना।)
  • आप एक बहुत बड़े ज्ञात आकार की एक सरणी-सूची बना रहे हैं, और आप समय जोड़ने के लिए प्रत्येक तत्व बहुत छोटा होने के लिए (चाहते हैं शायद इसलिए कि हर बार जब आप एक तत्व जोड़ें, आपको बाहरी डेटा-स्रोत पर कुछ प्रतिक्रिया भेजनी होगी)। (डिफ़ॉल्ट ज्यामितीय वृद्धि अमूर्त निरंतर समय लेती है: प्रत्येक बार एक बार में, भारी जुर्माना लगाया जाता है, जैसे कि समग्र औसत प्रदर्शन पूरी तरह से ठीक है, लेकिन यदि आप अलग-अलग व्यक्तिगत प्रविष्टियों को व्यक्तिगत रूप से लेते हैं, तो यह पर्याप्त नहीं हो सकता है ।)
+0

यह एक उत्कृष्ट उत्तर है – mfrankli

1

ArrayList आंतरिक तत्व अपने तत्वों को स्टोर करने के लिए सरल सरणी का उपयोग करते हैं, यदि तत्वों की संख्या अंतर्निहित सरणी की क्षमता से अधिक है, तो एक आकार बदलने की आवश्यकता है। इसलिए, यदि आप जानते हैं कि आपकी सूची में कितनी वस्तुएं होंगी, तो आप आवश्यक आकार की सरणी का उपयोग करने के लिए ArrayList को सूचित कर सकते हैं ताकि आकार बदलने वाले तर्क की आवश्यकता या निष्पादित न हो।

3

मेरे पास खंडख के उत्तर में जोड़ने के लिए कुछ भी नहीं है, लेकिन यहां एक त्वरित परीक्षण कार्य है। मैं इस तरह के छोटे परीक्षण लिखने के लिए चारों ओर एक स्क्रैप परियोजना रखता हूं। स्रोत को समायोजित करें अपने डेटा के कुछ प्रतिनिधि को आकार दें, और आप प्रभाव की परिमाण का एक मोटा विचार प्राप्त कर सकते हैं। जैसा कि दिखाया गया है, मैंने उनके बीच 2 का एक कारक देखा।

import java.util.ArrayList; 
import java.util.Random; 

public class ALTest { 
    public static long fill(ArrayList<Byte> al, byte[] source) { 
     long start = System.currentTimeMillis(); 
     for (byte b : source) { 
      al.add(b); 
     } 
     return System.currentTimeMillis()-start; 
    } 
    public static void main(String[] args) { 
     int sourceSize = 1<<20; // 1 MB 
     int smallIter = 50; 
     int bigIter = 4; 

     Random r = new Random(); 
     byte[] source = new byte[sourceSize]; 
     for (int i = 0;i<bigIter;i++) { 
      r.nextBytes(source); 
      { 
       long time = 0; 
       for (int j = 0;j<smallIter;j++) { 
        ArrayList<Byte> al = new ArrayList<Byte>(sourceSize); 
        time += fill(al,source); 
       } 
       System.out.print("With: "+time+"ms\t"); 
      } 
      { 
       long time = 0; 
       for (int j = 0;j<smallIter;j++) { 
        ArrayList<Byte> al = new ArrayList<Byte>(); 
        time += fill(al,source); 
       } 
       System.out.print("Without: "+time+"ms\t"); 
      } 
      { 
       long time = 0; 
       for (int j = 0;j<smallIter;j++) { 
        ArrayList<Byte> al = new ArrayList<Byte>(); 
        time += fill(al,source); 
       } 
       System.out.print("Without: "+time+"ms\t"); 
      } 
      { 
       long time = 0; 
       for (int j = 0;j<smallIter;j++) { 
        ArrayList<Byte> al = new ArrayList<Byte>(sourceSize); 
        time += fill(al,source); 
       } 
       System.out.print("With: "+time+"ms"); 
      } 
      System.out.println(); 
     } 
    } 
} 

आउटपुट:

With: 401ms Without: 799ms Without: 731ms With: 347ms 
With: 358ms Without: 744ms Without: 749ms With: 342ms 
With: 348ms Without: 719ms Without: 739ms With: 347ms 
With: 339ms Without: 734ms Without: 774ms With: 358ms 
संबंधित मुद्दे