जावा 8 स्ट्रीम प्रदर्शन बनाम। पारंपरिक संग्रह

आपने हाल ही में जावा 8 में कदम रखा है और क्लासिक संग्रह के मुकाबले इसके स्ट्रीम एपीआई के प्रदर्शन की तुलना करने के लिए एक अनौपचारिक बेंचमार्क आयोजित किया है। आपके परीक्षण में पूर्णांकों की सूची को फ़िल्टर करना, सम संख्याओं का वर्गमूल निकालना और परिणामों को दोहरी सूची में संग्रहीत करना शामिल है। हालाँकि, आप अपने परीक्षण की वैधता पर सवाल उठा रहे हैं और वास्तविक प्रदर्शन निहितार्थों को स्पष्ट करने के लिए उत्सुक हैं।

बेंचमार्क परीक्षण का आकलन

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

• लिंक्डलिस्ट का उपयोग करना: लिंक्डलिस्ट परिणाम सूची के लिए एक इष्टतम विकल्प नहीं है क्योंकि इसमें कुशल यादृच्छिक पहुंच का अभाव है। इसके बजाय ArrayList का उपयोग करने पर विचार करें।
• बेंचमार्क पद्धति: मैन्युअल बेंचमार्किंग में अशुद्धियाँ होने का खतरा हो सकता है। अधिक सटीक और विश्वसनीय माप प्रदान करने के लिए जेएमएच (जावा माइक्रोबेंचमार्किंग हार्नेस) जैसे बेंचमार्किंग ढांचे का उपयोग करें। जेएमएच और बेहतर बेंचमार्किंग का उपयोग करके प्रदर्शन मूल्यांकन रणनीतियाँ:

@OutputTimeUnit(TimeUnit.NANOSECONDS) @बेंचमार्कमोड(मोड.औसतसमय) @ऑपरेशंसपरइन्वोकेशन(स्ट्रीमVsVanilla.N) सार्वजनिक वर्ग StreamVsVanilla { सार्वजनिक स्थैतिक अंतिम पूर्णांक एन = 10000; स्थिर सूची स्रोत सूची = नई ArrayList(); स्थैतिक { के लिए (int i = 0; i वेनिला() { सूची परिणाम = नई ArrayList(sourceList.size() / 2 1); (पूर्णांक i : sourceList) के लिए { यदि (i % 2 == 0){ परिणाम.जोड़ें(गणित.sqrt(i)); } } वापसी परिणाम; } @बेंचमार्क सार्वजनिक सूची स्ट्रीम() { वापसी sourceList.stream() .फ़िल्टर(i -> i % 2 == 0) .नक्शा(गणित::वर्ग) .collect(कलेक्टर.toCollection( () -> नई ArrayList(sourceList.size() / 2 1))); } }

परिणाम:

बेंचमार्क मोड नमूने माध्य माध्य त्रुटि इकाइयां StreamVsVanilla.stream औसत 10 17.588 0.230 एनएस/ऑप StreamVsVanilla.vanilla avgt 10 10.796 0.063 ns/op

@OutputTimeUnit(TimeUnit.NANOSECONDS)
@BenchmarkMode(Mode.AverageTime)
@OperationsPerInvocation(StreamVsVanilla.N)
public class StreamVsVanilla {
    public static final int N = 10000;

    static List sourceList = new ArrayList();
    static {
        for (int i = 0; i  vanilla() {
        List result = new ArrayList(sourceList.size() / 2   1);
        for (Integer i : sourceList) {
            if (i % 2 == 0){
                result.add(Math.sqrt(i));
            }
        }
        return result;
    }

    @Benchmark
    public List stream() {
        return sourceList.stream()
                .filter(i -> i % 2 == 0)
                .map(Math::sqrt)
                .collect(Collectors.toCollection(
                    () -> new ArrayList(sourceList.size() / 2   1)));
    }
}

Findings

प्रारंभिक परिणामों के विपरीत, JMH बेंचमार्क स्पष्ट रूप से दिखाता है कि पारंपरिक संग्रह दृष्टिकोण तुलना में काफी तेज है इस विशेष में स्ट्रीम दृष्टिकोण परिदृश्य।

@OutputTimeUnit(TimeUnit.NANOSECONDS)
@BenchmarkMode(Mode.AverageTime)
@OperationsPerInvocation(StreamVsVanilla.N)
public class StreamVsVanilla {
    public static final int N = 10000;

    static List sourceList = new ArrayList();
    static {
        for (int i = 0; i  vanilla() {
        List result = new ArrayList(sourceList.size() / 2   1);
        for (Integer i : sourceList) {
            if (i % 2 == 0){
                result.add(Math.sqrt(i));
            }
        }
        return result;
    }

    @Benchmark
    public List stream() {
        return sourceList.stream()
                .filter(i -> i % 2 == 0)
                .map(Math::sqrt)
                .collect(Collectors.toCollection(
                    () -> new ArrayList(sourceList.size() / 2   1)));
    }
}

निष्कर्ष

इन बेहतर बेंचमार्किंग परिणामों के आधार पर, हम यह निष्कर्ष निकाल सकते हैं कि:

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

प्रदर्शन-महत्वपूर्ण कोड पथों के लिए, हमेशा संपूर्ण बेंचमार्किंग करने और अपने एप्लिकेशन की विशिष्ट आवश्यकताओं पर विचार करने की सलाह दी जाती है।