java - मरज - इस इश्क में मर जावा




जावा 8 स्ट्रीम सूची और योग के लिए तत्व जोड़ते हैं (3)

मेरा मानना ​​है कि मैं सूची पर एक स्ट्रीम ऑपरेशन का उपयोग करके अगला कर सकता हूंप्रतिबद्ध ऑब्जेक्ट:

List<BigDecimal> myList = new ArrayList();
myList = listOfPricedObjects.stream().map(PricedObject::getPrice).collect(Collectors.toList());
BigDecimal sum = listOfPricedObjects.stream().map(PricedObject::getPrice).reduce(BigDecimal.ZERO, BigDecimal::add)

मैं कीमतों के साथ मेरी सूची को कैसे भर सकता हूं और एक बार स्ट्रीम का उपयोग करके कीमतों की गणना कर सकता हूं? धन्यवाद

यूपीडी: परिणामस्वरूप मुझे अपनी सूची की कीमतों से भरा हुआ है और राशि के साथ योग के साथ योग की ज़रूरत है। लेकिन इसके लिए दो बार स्ट्रीमिंग के साथ नहीं।


आप पहचान मैपिंग को सूची में पासथ्रू मान जोड़ सकते हैं

BigDecimal sum = listOfPricedObjects.stream()
                                    .map(o -> {
                                         myList.add(o); 
                                         return o;})
                                    .map(PricedObject::getPrice)
                                    .reduce(BigDecimal.ZERO, BigDecimal::add)

लेकिन मैं झलक () का उपयोग करके स्लेमेन जनेडी के समाधान के लिए जाना था, इसकी अधिक खूबसूरत


आप यहां क्या चाहते हैं, अपने तत्वों को 2 कलेक्टरों में एकत्रित करना है: पहले एक सूची में एकत्रित होगा, और दूसरा वाला मूल्य जोड़ देगा

चूंकि स्ट्रीम एपीआई में ऐसा कोई भी कलेक्टर नहीं हैं, इसलिए हम आसानी से अपना खुद का निर्माण कर सकते हैं। चलो एक क्लास ResultHolder बनाते हैं जो स्ट्रीम पाइपलाइन के परिणाम को पकड़ लेंगे: यह दशमलव और योग की सूची है।

class ResultHolder {
    List<BigDecimal> list = new ArrayList<>();
    BigDecimal sum = BigDecimal.ZERO;
}

अंत में, हम इसका उपयोग इसके साथ कर सकते हैं:

ResultHolder resultHolder = 
    listOfPricedObjects.stream()
            .map(PricedObject::getPrice)
            .collect(
                ResultHolder::new,
                (r, p) -> { r.list.add(p); r.sum = r.sum.add(p); },
                (r1, r2) -> { r1.list.addAll(r2.list); r1.sum = r1.sum.add(r2.sum); }
            );
System.out.println(resultHolder.list);
System.out.println(resultHolder.sum);

यह समानांतर पाइपलाइन में काम करेगा और अन्य उत्तरों के विपरीत, सूची के प्रारंभिक आदेश को बनाए रखेगा।


कमी को लागू करते समय आप peek उपयोग कर एक नई list जोड़ सकते हैं

List<BigDecimal> newList = new ArrayList<>();
BigDecimal sum = list.stream()
                     .map(PricedObject::getPrice)
                     .peek(newList::add)
                     .reduce(BigDecimal.ZERO, BigDecimal::add);

टुनकी का उत्तर देखें यदि आप parallelStream स्ट्रीम का प्रयोग गैर-समसामयिक संग्रह के साथ करना चाहते हैं जो योग के बाद से एक शर्मनाक समानांतर कार्य है।





java-stream