जावा 8: लंबोदर के पुनरावृत्तियों को गिनने का पसंदीदा तरीका?

Question 1

मैं अक्सर एक ही समस्या का सामना करता हूं। मैं एक के रन गिनती करने की आवश्यकता है लैम्ब्डा के बाहर उपयोग के लिए लैम्ब्डा ।

उदाहरण के लिए:

myStream.stream().filter(...).forEach(item -> { ... ; runCount++});
System.out.println("The lambda ran " + runCount + "times");

मुद्दा यह है कि रनकाउंट की जरूरत है final, इसलिए यह नहीं हो सकता है int। यह नहीं हो सकता Integerक्योंकि यह अपरिवर्तनीय है । मैं इसे क्लास लेवल वेरिएबल (यानी एक फील्ड) बना सकता था, लेकिन कोड के इस ब्लॉक में मुझे केवल इसकी आवश्यकता होगी।

मुझे पता है कि विभिन्न तरीके हैं, मैं बस उत्सुक हूं कि इसके लिए आपका पसंदीदा समाधान क्या है?
क्या आप एक AtomicIntegerया एक सरणी संदर्भ या किसी अन्य तरीके का उपयोग करते हैं?

Question 2

चर्चा के लिए मुझे अपना उदाहरण थोड़ा सुधारना चाहिए:

long runCount = 0L;
myStream.stream()
    .filter(...)
    .forEach(item -> { 
        foo();
        bar();
        runCount++; // doesn't work
    });
System.out.println("The lambda ran " + runCount + " times");

यदि आपको वास्तव में एक लैम्ब्डा के भीतर से एक काउंटर को बढ़ाने की आवश्यकता है, तो ऐसा करने का विशिष्ट तरीका काउंटर को AtomicIntegerया AtomicLongतो बनाना है और फिर उस पर वेतन वृद्धि विधियों में से एक को कॉल करना है।

आप एकल-तत्व intया longसरणी का उपयोग कर सकते हैं , लेकिन यदि धारा समानांतर रूप से चलती है, तो दौड़ की स्थिति होगी।

लेकिन ध्यान दें कि स्ट्रीम में समाप्त होता है forEach, जिसका अर्थ है कि कोई वापसी मूल्य नहीं है। आप को बदल सकता है forEachएक करने के लिए peek, जिसके माध्यम से आइटम गुजरता है, और फिर उन्हें गिनती:

long runCount = myStream.stream()
    .filter(...)
    .peek(item -> { 
        foo();
        bar();
    })
    .count();
System.out.println("The lambda ran " + runCount + " times");

यह कुछ हद तक बेहतर है, लेकिन फिर भी थोड़ा अजीब है। कारण यह है कि है forEachऔर peekकेवल दुष्प्रभाव के माध्यम से अपने काम कर सकते हैं। जावा 8 की उभरती कार्यात्मक शैली दुष्प्रभावों से बचने के लिए है। हमने countधारा पर एक ऑपरेशन में काउंटर के वेतन वृद्धि को हटाकर थोड़ा सा किया । अन्य विशिष्ट दुष्प्रभाव संग्रह में आइटम जोड़ रहे हैं। आमतौर पर इन्हें संग्राहकों के उपयोग से बदला जा सकता है। लेकिन यह जानने के बिना कि आप किस वास्तविक काम को करने की कोशिश कर रहे हैं, मैं और अधिक विशिष्ट सुझाव नहीं दे सकता।

Question 3

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

    int[] iarr = {0}; // final not neccessary here if no other array is assigned
    stringList.forEach(item -> {
            iarr[0]++;
            // iarr = {1}; Error if iarr gets other array assigned
    });

Question 4

AtomicInteger runCount = 0L;
long runCount = myStream.stream()
    .filter(...)
    .peek(item -> { 
        foo();
        bar();
        runCount.incrementAndGet();
    });
System.out.println("The lambda ran " + runCount.incrementAndGet() + "times");

Question 5

आप AtomicInteger का उपयोग नहीं करना चाहिए , आपको चीजों का उपयोग नहीं करना चाहिए जब तक कि आपके पास उपयोग करने के लिए वास्तव में अच्छा कारण न हो। और AtomicInteger का उपयोग करने का कारण केवल समवर्ती एक्सेस या जैसे अनुमति दे सकता है।

जब आपकी समस्या की बात आती है;

धारक को एक लंबोदर के अंदर रखने और बढ़ाने के लिए उपयोग किया जा सकता है। और आप runCount.value पर कॉल करके प्राप्त कर सकते हैं

Holder<Integer> runCount = new Holder<>(0);

myStream.stream()
    .filter(...)
    .forEach(item -> { 
        foo();
        bar();
        runCount.value++; // now it's work fine!
    });
System.out.println("The lambda ran " + runCount + " times");

Question 6

मेरे लिए, यह चाल चली, उम्मीद है कि कोई इसे उपयोगी पाता है:

AtomicInteger runCount = new AtomicInteger(0);
myStream.stream().filter(...).forEach(item -> runCount.getAndIncrement());
System.out.println("The lambda ran " + runCount.get() + "times");

getAndIncrement() जावा प्रलेखन स्थिति:

वरहांडल.गेटएंडएड द्वारा निर्दिष्ट मेमोरी इफेक्ट के साथ एटोमिकली वर्तमान मूल्य में वृद्धि होती है। GetAndAdd (1) के बराबर।

Question 7

इसे करने का एक और तरीका (उपयोगी है यदि आप चाहते हैं कि आपकी गिनती केवल कुछ मामलों में बढ़ाई जाए, जैसे कि एक ऑपरेशन सफल रहा) कुछ इस तरह है, उपयोग करना mapToInt()और sum():

int count = myStream.stream()
    .filter(...)
    .mapToInt(item -> { 
        foo();
        if (bar()){
           return 1;
        } else {
           return 0;
    })
    .sum();
System.out.println("The lambda ran " + count + "times");

जैसा कि स्टुअर्ट मार्क्स ने कहा, यह अभी भी कुछ हद तक अजीब है, क्योंकि यह पूरी तरह से साइड इफेक्ट्स (क्या foo()और क्या bar()कर रहे हैं) के आधार पर परहेज नहीं कर रहा है।

और लैम्बडा में एक वैरिएबल को बढ़ाने का एक और तरीका जो इसके बाहर सुलभ है वह एक क्लास वैरिएबल का उपयोग करना है:

public class MyClass {
    private int myCount;

    // Constructor, other methods here

    void myMethod(){
        // does something to get myStream
        myCount = 0;
        myStream.stream()
            .filter(...)
            .forEach(item->{
               foo(); 
               myCount++;
        });
    }
}

इस उदाहरण में, एक विधि में एक काउंटर के लिए एक वर्ग चर का उपयोग करना शायद समझ में नहीं आता है, इसलिए मैं इसके खिलाफ सावधानी बरतूंगा जब तक कि कोई अच्छा कारण न हो। finalयदि संभव हो तो कक्षा चर को रखना थ्रेड सुरक्षा के संदर्भ में सहायक हो सकता है, ( उपयोग करने पर चर्चा के लिए http://www.javapractices.com/topic/TopicAction.do?Id=23 देखें final)।

इस बात का बेहतर अंदाजा लगाने के लिए कि लंबोदर अपने काम करने के तरीके, https://www.infoq.com/articles/Java-8-Lambdas-A-Peek-Under-the-Hood पर एक विस्तृत नज़र रखते हैं।

Question 8

यदि आप एक फ़ील्ड नहीं बनाना चाहते हैं क्योंकि आपको केवल स्थानीय रूप से इसकी आवश्यकता है, तो आप इसे एक अनाम वर्ग में संग्रहीत कर सकते हैं:

int runCount = new Object() {
    int runCount = 0;
    {
        myStream.stream()
                .filter(...)
                .peek(x -> runCount++)
                .forEach(...);
    }
}.runCount;

अजीब है, मुझे पता है। लेकिन यह अस्थायी चर को स्थानीय दायरे से बाहर रखता है।

Question 9

कम भी काम करता है, आप इसे इस तरह से उपयोग कर सकते हैं

myStream.stream().filter(...).reduce((item, sum) -> sum += item);

Question 10

एक अन्य विकल्प अपाचे कॉमन म्यूटेबल का उपयोग करना है।

MutableInt cnt = new MutableInt(0);
myStream.stream()
    .filter(...)
    .forEach(item -> { 
        foo();
        bar();
        cnt.increment();
    });
System.out.println("The lambda ran " + cnt.getValue() + " times");

Question 11

AtomicInteger runCount = new AtomicInteger(0);

elements.stream()
  //...
  .peek(runCount.incrementAndGet())
  .collect(Collectors.toList());

// runCount.get() should have the num of times lambda code was executed