बेंजामिन विंटरबर्ग स्ट्रीम एपीआई गाइड ट्रांसलेशन

नमस्कार, हेब्र! मैं आपके लिए लेख " जावा 8 स्ट्रीम ट्यूटोरियल " का अनुवाद प्रस्तुत करता हूं।

यह उदाहरण, कोड उदाहरणों के आधार पर, जावा 8 में धाराओं का एक व्यापक अवलोकन प्रदान करता है। जब मैंने पहली बार स्ट्रीम एपीआई की शुरुआत की थी, तो मुझे नाम से हैरान कर दिया गया था क्योंकि यह java.io पैकेज से InputStream और OutputStream के साथ बहुत व्यंजन है; हालाँकि, Java 8 में थ्रेड्स पूरी तरह से अलग हैं। थ्रेड्स मोनाड हैं जो जावा में कार्यात्मक प्रोग्रामिंग के विकास में महत्वपूर्ण भूमिका निभाते हैं।

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

यह ट्यूटोरियल आपको स्ट्रीम के साथ काम करने और स्ट्रीम एपीआई में उपलब्ध विभिन्न तरीकों को संभालने का तरीका बताएगा। हम संचालन के क्रम का विश्लेषण करेंगे और देखेंगे कि श्रृंखला में विधियों का क्रम प्रदर्शन को कैसे प्रभावित करता है। शक्तिशाली स्ट्रीम एपीआई विधियों जैसे कि reduce , collect और flatMap । मैनुअल के अंत में, हम धाराओं के साथ समानांतर काम पर ध्यान देंगे।

यदि आप लैम्ब्डा एक्सप्रेशंस, फंक्शनल इंटरफेस और रेफरेंस मेथड्स के साथ काम करने के लिए स्वतंत्र महसूस नहीं करते हैं, तो यह आपके लिए जावा 8 (हेबरे में अनुवाद ), और उसके बाद स्टडी फ्लो पर लौटने के लिए मेरे गाइड के साथ खुद को परिचित करने के लिए उपयोगी होगा।

धागे कैसे काम करते हैं

एक धारा तत्वों के अनुक्रम का प्रतिनिधित्व करती है और इन तत्वों पर गणना करने के लिए विभिन्न तरीके प्रदान करती है:

 List<String> myList = Arrays.asList("a1", "a2", "b1", "c2", "c1"); myList .stream() .filter(s -> s.startsWith("c")) .map(String::toUpperCase) .sorted() .forEach(System.out::println); // C1 // C2 

प्रवाह के तरीके मध्यवर्ती (इंटरमीडिएट) और टर्मिनल (टर्मिनल) हैं। मध्यवर्ती विधियां एक धारा लौटाती हैं, जो इनमें से कई तरीकों को क्रमिक रूप से कहा जाता है। टर्मिनल विधियाँ या तो एक मान (शून्य) नहीं लौटाती हैं या एक धारा के अलावा अन्य प्रकार का परिणाम देती हैं। उपरोक्त उदाहरण में, filter , map और sorted इंटरमीडिएट हैं, और forEach टर्मिनल हैं। उपलब्ध प्रवाह विधियों की पूरी सूची के लिए, दस्तावेज देखें। धारा संचालन की ऐसी श्रृंखला को ऑपरेशन पाइपलाइन के रूप में भी जाना जाता है।

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

एक विधि गैर-हस्तक्षेप कर रही है यदि यह धारा में अंतर्निहित अंतर्निहित डेटा को संशोधित नहीं करती है। उदाहरण के लिए, उपर्युक्त उदाहरण में, कोई लंबोदर भाव सूची सरणी myList को संशोधित नहीं करता है।

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

विभिन्न प्रकार के धागे

मुख्य रूप से संग्रह से विभिन्न स्रोत डेटा से धाराएं बनाई जा सकती हैं। अनुक्रमिक और समानांतर स्ट्रीम बनाने के लिए सूचियाँ और सेट नई stream() और parllelStream() विधियों का समर्थन करते हैं। समानांतर धागे बहु-थ्रेडेड मोड (कई थ्रेड्स पर) में काम करने में सक्षम हैं और मैनुअल के अंत में चर्चा की जाएगी। इस बीच, अनुक्रमिक सूत्र पर विचार करें:

 Arrays.asList("a1", "a2", "a3") .stream() .findFirst() .ifPresent(System.out::println); // a1 

यहां, किसी सूची पर stream() विधि को कॉल करने से एक सामान्य स्ट्रीम ऑब्जेक्ट प्राप्त होता है।
हालांकि, एक स्ट्रीम के साथ काम करने के लिए, एक संग्रह बनाना बिल्कुल भी आवश्यक नहीं है:

 Stream.of("a1", "a2", "a3") .findFirst() .ifPresent(System.out::println); // a1 

कई ऑब्जेक्ट संदर्भों से एक स्ट्रीम बनाने के लिए बस Stream.of() का उपयोग करें।

नियमित वस्तु धाराओं के अलावा, आदिम प्रकार के साथ काम करने के लिए जावा 8 में विशेष प्रकार की धाराएँ हैं: int, long, double। जैसा कि आप अनुमान लगा सकते हैं, यह IntStream , LongStream , LongStream ।

IntStream.range () का उपयोग करके इन्ट्रीम्रीम स्ट्रीम (;;) IntStream.range() लिए नियमित रूप से बदल सकते हैं।

 IntStream.range(1, 4) .forEach(System.out::println); // 1 // 2 // 3 

आदिम प्रकार के साथ काम करने के लिए ये सभी धाराएँ वस्तुओं की नियमित धाराओं की तरह काम करती हैं, सिवाय निम्नलिखित के:

• आदिम धाराएँ विशेष लंबोदर भावों का उपयोग करती हैं। उदाहरण के लिए, फ़ंक्शन के बजाय IntFunction, या Predicate के बजाय IntPredicate।
• आदिम धाराएँ अतिरिक्त टर्मिनल विधियों का समर्थन करती हैं: sum() और average()
  
  

   Arrays.stream(new int[] {1, 2, 3}) .map(n -> 2 * n + 1) .average() .ifPresent(System.out::println); // 5.0 

  
  

कभी-कभी वस्तुओं की एक धारा को आदिम की एक धारा में बदलना या इसके विपरीत करना उपयोगी होता है। इस उद्देश्य के लिए, ऑब्जेक्ट प्रवाह विशेष विधियों का समर्थन करता है: mapToInt() , mapToLong() , mapToDouble() :

 Stream.of("a1", "a2", "a3") .map(s -> s.substring(1)) .mapToInt(Integer::parseInt) .max() .ifPresent(System.out::println); // 3 

आदिमता की धाराओं को mapToObj() कहकर वस्तुओं की धाराओं में परिवर्तित किया जा सकता है:

 IntStream.range(1, 4) .mapToObj(i -> "a" + i) .forEach(System.out::println); // a1 // a2 // a3 

निम्नलिखित उदाहरण में, फ्लोटिंग-पॉइंट नंबरों की एक धारा को पूर्णांकों की एक धारा में मैप किया जाता है और फिर वस्तुओं की एक धारा में मैप किया जाता है:

 Stream.of(1.0, 2.0, 3.0) .mapToInt(Double::intValue) .mapToObj(i -> "a" + i) .forEach(System.out::println); // a1 // a2 // a3 

निष्पादन आदेश

अब जब हमने सीख लिया है कि विभिन्न धाराएँ कैसे बनायें और उनके साथ कैसे काम करें, तो हम गहराई से गोता लगाएँगे और विचार करेंगे कि स्ट्रीमिंग संचालन हूड के तहत कैसे दिखता है।

मध्यवर्ती तरीकों की एक महत्वपूर्ण विशेषता उनका आलस्य है । इस उदाहरण में कोई टर्मिनल विधि नहीं है:

 Stream.of("d2", "a2", "b1", "b3", "c") .filter(s -> { System.out.println("filter: " + s); return true; }); 

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

 Stream.of("d2", "a2", "b1", "b3", "c") .filter(s -> { System.out.println("filter: " + s); return true; }) .forEach(s -> System.out.println("forEach: " + s)); 

इस कोड के टुकड़े का निष्पादन निम्न परिणाम के कंसोल में आउटपुट की ओर जाता है:

 filter: d2 forEach: d2 filter: a2 forEach: a2 filter: b1 forEach: b1 filter: b3 forEach: b3 filter: c forEach: c 

जिस क्रम में परिणाम की व्यवस्था की जाती है वह आश्चर्यचकित कर सकता है। एक व्यक्ति यह उम्मीद कर सकता है कि विधियों को "क्षैतिज रूप से" निष्पादित किया जाएगा: धारा के सभी तत्वों के लिए एक के बाद एक। हालांकि, इसके बजाय, तत्व श्रृंखला के साथ "लंबवत" चलता है। पहले, "d2" की पहली पंक्ति filter विधि से गुजरती है, फिर forEach माध्यम से forEach और उसके बाद ही, विधियों की पूरी श्रृंखला के माध्यम से पहला तत्व पास करने के बाद, अगला तत्व संसाधित होना शुरू होता है।

इस व्यवहार को देखते हुए, आप संचालन की वास्तविक संख्या को कम कर सकते हैं:

 Stream.of("d2", "a2", "b1", "b3", "c") .map(s -> { System.out.println("map: " + s); return s.toUpperCase(); }) .anyMatch(s -> { System.out.println("anyMatch: " + s); return s.startsWith("A"); }); // map: d2 // anyMatch: D2 // map: a2 // anyMatch: A2 

जैसे ही anyMatch आने वाले तत्व पर लागू होगा वैसे ही कोई भी anyMatch विधि सही हो जाएगी। इस मामले में, यह अनुक्रम का दूसरा तत्व है - "ए 2"। तदनुसार, धागा श्रृंखला के "ऊर्ध्वाधर" निष्पादन के कारण, map केवल दो बार कहा जाएगा। इस प्रकार, धारा के सभी तत्वों को प्रदर्शित करने के बजाय, map को यथासंभव कम बार बुलाया जाएगा।

अनुक्रम क्यों मायने रखता है

निम्नलिखित उदाहरण में दो मध्यवर्ती विधि map और filter और एक टर्मिनल विधि forEach । गौर कीजिए कि ये तरीके कैसे किए जाते हैं:

 Stream.of("d2", "a2", "b1", "b3", "c") .map(s -> { System.out.println("map: " + s); return s.toUpperCase(); }) .filter(s -> { System.out.println("filter: " + s); return s.startsWith("A"); }) .forEach(s -> System.out.println("forEach: " + s)); // map: d2 // filter: D2 // map: a2 // filter: A2 // forEach: A2 // map: b1 // filter: B1 // map: b3 // filter: B3 // map: c // filter: C 

यह अनुमान लगाना आसान है कि map और filter दोनों तरीकों को रनटाइम पर 5 बार कहा जाता है - एक बार स्रोत संग्रह के प्रत्येक तत्व के लिए, जबकि forEach को केवल एक बार - फिल्टर को पारित करने वाले तत्व के लिए कहा जाता है।

पहली बार filter लगाकर विधि कॉल के क्रम को बदलकर आप ऑपरेशन की संख्या को काफी कम कर सकते हैं:

 Stream.of("d2", "a2", "b1", "b3", "c") .filter(s -> { System.out.println("filter: " + s); return s.startsWith("a"); }) .map(s -> { System.out.println("map: " + s); return s.toUpperCase(); }) .forEach(s -> System.out.println("forEach: " + s)); // filter: d2 // filter: a2 // map: a2 // forEach: A2 // filter: b1 // filter: b3 // filter: c 

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

हम एक अतिरिक्त सॉर्ट ऑपरेशन जोड़कर उपरोक्त उदाहरण का विस्तार करते हैं - सॉर्ट की गई विधि:

 Stream.of("d2", "a2", "b1", "b3", "c") .sorted((s1, s2) -> { System.out.printf("sort: %s; %s\n", s1, s2); return s1.compareTo(s2); }) .filter(s -> { System.out.println("filter: " + s); return s.startsWith("a"); }) .map(s -> { System.out.println("map: " + s); return s.toUpperCase(); }) .forEach(s -> System.out.println("forEach: " + s)); 

छँटाई एक विशेष प्रकार का मध्यवर्ती संचालन है। यह तथाकथित स्टेटफुल ऑपरेशन है, क्योंकि एक संग्रह को सॉर्ट करने के लिए, पूरे ऑपरेशन के दौरान इसकी स्थिति को ध्यान में रखा जाना चाहिए।

इस कोड के निष्पादन के परिणामस्वरूप, हम कंसोल को निम्नलिखित आउटपुट प्राप्त करते हैं:

 sort: a2; d2 sort: b1; a2 sort: b1; d2 sort: b1; a2 sort: b3; b1 sort: b3; d2 sort: c; b3 sort: c; d2 filter: a2 map: a2 forEach: A2 filter: b1 filter: b3 filter: c filter: d2 

सबसे पहले, पूरे संग्रह को क्रमबद्ध किया जाता है। दूसरे शब्दों में, sorted विधि क्षैतिज रूप से चलती है। इस मामले में, आवक संग्रह में तत्वों के कई संयोजनों के लिए 8 बार sorted है।

एक बार फिर, हम श्रृंखला में विधि कॉल के क्रम को बदलकर इस कोड के निष्पादन का अनुकूलन करते हैं:

 Stream.of("d2", "a2", "b1", "b3", "c") .filter(s -> { System.out.println("filter: " + s); return s.startsWith("a"); }) .sorted((s1, s2) -> { System.out.printf("sort: %s; %s\n", s1, s2); return s1.compareTo(s2); }) .map(s -> { System.out.println("map: " + s); return s.toUpperCase(); }) .forEach(s -> System.out.println("forEach: " + s)); // filter: d2 // filter: a2 // filter: b1 // filter: b3 // filter: c // map: a2 // forEach: A2 

इस उदाहरण में, sorted को बिल्कुल नहीं कहा जाता है। filter एक तत्व में इनपुट संग्रह को कम करता है। बड़े इनपुट डेटा के मामले में, प्रदर्शन से काफी लाभ होगा।

धाराओं का पुन: उपयोग करें

जावा 8 में, थ्रेड्स का पुन: उपयोग नहीं किया जा सकता है। किसी भी टर्मिनल विधि को कॉल करने के बाद, थ्रेड समाप्त हो जाता है:

 Stream<String> stream = Stream.of("d2", "a2", "b1", "b3", "c") .filter(s -> s.startsWith("a")); stream.anyMatch(s -> true); // ok stream.noneMatch(s -> true); // exception 

निम्नलिखित अपवाद में किसी भी थ्रेड के परिणाम के बाद anyMatch को कॉल noneMatch

 java.lang.IllegalStateException: stream has already been operated upon or closed at java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:229) at java.util.stream.ReferencePipeline.noneMatch(ReferencePipeline.java:459) at com.winterbe.java8.Streams5.test7(Streams5.java:38) at com.winterbe.java8.Streams5.main(Streams5.java:28) 

इस सीमा को पार करने के लिए, प्रत्येक टर्मिनल विधि के लिए एक नया धागा बनाया जाना चाहिए।

उदाहरण के लिए, आप एक नए थ्रेड कंस्ट्रक्टर के लिए एक सप्लायर बना सकते हैं जिसमें सभी मध्यवर्ती तरीके स्थापित किए जाएंगे:

 Supplier<Stream<String>> streamSupplier = () -> Stream.of("d2", "a2", "b1", "b3", "c") .filter(s -> s.startsWith("a")); streamSupplier.get().anyMatch(s -> true); // ok streamSupplier.get().noneMatch(s -> true); // ok 

get विधि के लिए प्रत्येक कॉल एक नया धागा बनाता है जिसमें आप सुरक्षित रूप से वांछित टर्मिनल विधि कह सकते हैं।

उन्नत तरीके

थ्रेड बड़ी संख्या में विभिन्न तरीकों का समर्थन करते हैं। हम पहले से ही सबसे महत्वपूर्ण तरीकों से खुद को परिचित कर चुके हैं। बाकी के साथ खुद को परिचित करने के लिए, प्रलेखन देखें। और अब और अधिक जटिल तरीकों में भी गहरा गोता flatMap : collect , flatMap और reduce ।

इस अनुभाग में अधिकांश कोड उदाहरण ऑपरेशन को प्रदर्शित करने के लिए निम्न कोड स्निपेट का उल्लेख करते हैं:

 class Person { String name; int age; Person(String name, int age) { this.name = name; this.age = age; } @Override public String toString() { return name; } } List<Person> persons = Arrays.asList( new Person("Max", 18), new Person("Peter", 23), new Person("Pamela", 23), new Person("David", 12)); 

कलेक्ट

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

Collector एक Collector स्वीकार करता है जिसमें चार अलग-अलग विधियाँ होती हैं: एक आपूर्तिकर्ता। संचायक, कंघी, फिनिशर। पहली नज़र में, यह बहुत जटिल लगता है, लेकिन जावा 8 कलेक्टरों के माध्यम से विभिन्न अंतर्निहित कलेक्टरों का समर्थन करता है, जहां सबसे अधिक उपयोग किए जाने वाले तरीकों को लागू किया जाता है।

लोकप्रिय मामला:

 List<Person> filtered = persons .stream() .filter(p -> p.name.startsWith("P")) .collect(Collectors.toList()); System.out.println(filtered); // [Peter, Pamela] 

जैसा कि आप देख सकते हैं, स्ट्रीम आइटम से एक सूची बनाना बहुत सरल है। सूची नहीं बल्कि बहुत कुछ चाहिए? Collectors.toSet() उपयोग करें Collectors.toSet() ।

निम्नलिखित उदाहरण में, लोगों को आयु के आधार पर वर्गीकृत किया गया है:

 Map<Integer, List<Person>> personsByAge = persons .stream() .collect(Collectors.groupingBy(p -> p.age)); personsByAge .forEach((age, p) -> System.out.format("age %s: %s\n", age, p)); // age 18: [Max] // age 23: [Peter, Pamela] // age 12: [David] 

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

 Double averageAge = persons .stream() .collect(Collectors.averagingInt(p -> p.age)); System.out.println(averageAge); // 19.0 

अधिक व्यापक आँकड़े प्राप्त करने के लिए, हम एक सारांश कलेक्टर का उपयोग करते हैं जो सूचना के साथ एक विशेष वस्तु लौटाता है: न्यूनतम, अधिकतम और औसत मान, मूल्यों का योग और तत्वों की संख्या:

 IntSummaryStatistics ageSummary = persons .stream() .collect(Collectors.summarizingInt(p -> p.age)); System.out.println(ageSummary); // IntSummaryStatistics{count=4, sum=76, min=12, average=19.000000, max=23} 

निम्नलिखित उदाहरण एक पंक्ति में सभी नामों को जोड़ता है:

 String phrase = persons .stream() .filter(p -> p.age >= 18) .map(p -> p.name) .collect(Collectors.joining(" and ", "In Germany ", " are of legal age.")); System.out.println(phrase); // In Germany Max and Peter and Pamela are of legal age. 

कनेक्टिंग कलेक्टर एक विभाजक को स्वीकार करता है, साथ ही एक वैकल्पिक उपसर्ग और प्रत्यय भी।

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

 Map<Integer, String> map = persons .stream() .collect(Collectors.toMap( p -> p.age, p -> p.name, (name1, name2) -> name1 + ";" + name2)); System.out.println(map); // {18=Max, 23=Peter;Pamela, 12=David} 

इसलिए, हम कुछ सबसे शक्तिशाली निर्मित संग्राहकों से परिचित हुए। आइए अपने स्वयं के निर्माण का प्रयास करें। हम धारा के सभी तत्वों को एक ही पंक्ति में बदलना चाहते हैं, जिसमें एक ऊर्ध्वाधर पट्टी द्वारा अलग किए गए अपरकेस नाम हैं। ऐसा करने के लिए, Collector.of() का उपयोग करके एक नया कलेक्टर बनाएं। हमें अपने कलेक्टर के चार घटकों की आवश्यकता है: आपूर्तिकर्ता, बैटरी, कनेक्टर, फिनिशर।

 Collector<Person, StringJoiner, String> personNameCollector = Collector.of( () -> new StringJoiner(" | "), // supplier (j, p) -> j.add(p.name.toUpperCase()), // accumulator (j1, j2) -> j1.merge(j2), // combiner StringJoiner::toString); // finisher String names = persons .stream() .collect(personNameCollector); System.out.println(names); // MAX | PETER | PAMELA | DAVID 

चूंकि Java में तार अपरिवर्तनीय हैं, हमें StringJoiner जैसे सहायक वर्ग की StringJoiner होती है जो कलेक्टर को हमारे लिए एक स्ट्रिंग बनाने की अनुमति देता है। पहले चरण में, प्रदाता एक असाइन किए गए सीमांकक के साथ StringJoiner निर्माण करता है। StringJoiner प्रत्येक नाम जोड़ने के लिए बैटरी का उपयोग किया जाता है।

कनेक्टर जानता है कि एक में दो StringJoiner को कैसे कनेक्ट किया StringJoiner । और अंत में, फिनिशर StringJoiner s से वांछित स्ट्रिंग का निर्माण करता है।

FlatMap

इसलिए, हमने सीखा कि कैसे map विधि का उपयोग करके वस्तुओं को अन्य प्रकार की वस्तुओं में बदलना है। Map एक प्रकार की सीमित विधि है, क्योंकि प्रत्येक वस्तु को केवल एक ही वस्तु पर मैप किया जा सकता है। लेकिन क्या होगा यदि आप एक वस्तु को कई अन्य लोगों के लिए मैप करना चाहते हैं, या इसे बिल्कुल भी प्रदर्शित नहीं करना चाहते हैं? यह वह जगह है जहाँ flatMap विधि मदद करती है। FlatMap प्रत्येक स्ट्रीम ऑब्जेक्ट को अन्य ऑब्जेक्ट्स की एक स्ट्रीम में बदल देता है। फिर इन थ्रेड्स की सामग्री को flatMap विधि की लौटी हुई धारा में पैक किया जाता है।

कार्रवाई में flatMap देखने के लिए, आइए एक उदाहरण के लिए एक उपयुक्त प्रकार पदानुक्रम का निर्माण करें:

 class Foo { String name; List<Bar> bars = new ArrayList<>(); Foo(String name) { this.name = name; } } class Bar { String name; Bar(String name) { this.name = name; } } 

आइए कुछ वस्तुओं का निर्माण करें:

 List<Foo> foos = new ArrayList<>(); // create foos IntStream .range(1, 4) .forEach(i -> foos.add(new Foo("Foo" + i))); // create bars foos.forEach(f -> IntStream .range(1, 4) .forEach(i -> f.bars.add(new Bar("Bar" + i + " <- " + f.name)))); 

अब हमारे पास तीन फू की सूची है, जिनमें से प्रत्येक में तीन बार हैं ।

FlatMap एक फ़ंक्शन को स्वीकार करता है जिसे वस्तुओं की एक धारा वापस करनी चाहिए। इस प्रकार, प्रत्येक फू के बार ऑब्जेक्ट्स को एक्सेस करने के लिए, हमें केवल उचित फ़ंक्शन खोजने की आवश्यकता है:

 foos.stream() .flatMap(f -> f.bars.stream()) .forEach(b -> System.out.println(b.name)); // Bar1 <- Foo1 // Bar2 <- Foo1 // Bar3 <- Foo1 // Bar1 <- Foo2 // Bar2 <- Foo2 // Bar3 <- Foo2 // Bar1 <- Foo3 // Bar2 <- Foo3 // Bar3 <- Foo3 

इसलिए, हमने तीन फू वस्तुओं की एक धारा को 9 बार वस्तुओं की एक धारा में सफलतापूर्वक बदल दिया है।

अंत में, उपरोक्त सभी कोड को संचालन की एक सरल पाइपलाइन तक कम किया जा सकता है:

 IntStream.range(1, 4) .mapToObj(i -> new Foo("Foo" + i)) .peek(f -> IntStream.range(1, 4) .mapToObj(i -> new Bar("Bar" + i + " <- " f.name)) .forEach(f.bars::add)) .flatMap(f -> f.bars.stream()) .forEach(b -> System.out.println(b.name)); 

FlatMap जावा 8. में शुरू की गई Optional वर्ग में भी उपलब्ध है। Optional वर्ग से FlatMap किसी अन्य वर्ग की एक वैकल्पिक वस्तु देता है। इसका उपयोग null जांचों के एक समूह से बचने के लिए किया जा सकता है।

इस तरह एक पदानुक्रमित संरचना की कल्पना करें:

 class Outer { Nested nested; } class Nested { Inner inner; } class Inner { String foo; } 

किसी बाहरी ऑब्जेक्ट से नेस्टेड स्ट्रिंग फू प्राप्त करने के लिए, आपको NullPointException से बचने के लिए कई null चेक जोड़ने की आवश्यकता है:

 Outer outer = new Outer(); if (outer != null && outer.nested != null && outer.nested.inner != null) { System.out.println(outer.nested.inner.foo); } 

वैकल्पिक वर्ग के फ्लैटपाइप का उपयोग करके इसे प्राप्त किया जा सकता है:

 Optional.of(new Outer()) .flatMap(o -> Optional.ofNullable(o.nested)) .flatMap(n -> Optional.ofNullable(n.inner)) .flatMap(i -> Optional.ofNullable(i.foo)) .ifPresent(System.out::println); 

flatMap प्रत्येक कॉल वांछित वस्तु के लिए एक Optional आवरण देता है, यदि मौजूद है, या यदि ऑब्जेक्ट गायब है तो null है।

कम करें

सरलीकरण ऑपरेशन एक धारा के सभी तत्वों को एक ही परिणाम में जोड़ता है। जावा 8 कम करने के तीन अलग-अलग तरीकों का समर्थन करता है।

पहले तत्वों के प्रवाह को एक एकल प्रवाह तत्व को कम करता है। हम इस विधि का उपयोग तत्व को सबसे बड़ी उम्र के साथ निर्धारित करने के लिए करते हैं:

 persons .stream() .reduce((p1, p2) -> p1.age > p2.age ? p1 : p2) .ifPresent(System.out::println); // Pamela 

reduce विधि एक द्विआधारी ऑपरेटर (बाइनरीऑपरेटर) के साथ एक संचय कार्य करती है। यहां reduce एक द्वि-फ़ंक्शन (BiFunction) है, जहां दोनों तर्क एक ही प्रकार के हैं। हमारे मामले में, व्यक्ति के प्रकार के लिए। एक द्वि-फ़ंक्शन लगभग एक के समान है, लेकिन इसमें 2 तर्क हैं। हमारे उदाहरण में, फ़ंक्शन दो लोगों की उम्र की तुलना करता है और अधिक आयु के साथ एक तत्व देता है।

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

 Person result = persons .stream() .reduce(new Person("", 0), (p1, p2) -> { p1.age += p2.age; p1.name += p2.name; return p1; }); System.out.format("name=%s; age=%s", result.name, result.age); // name=MaxPeterPamelaDavid; age=76 

तीसरा reduce विधि तीन मापदंडों को लेती है: प्रारंभिक मूल्य, द्वि-फ़ंक्शन के साथ संचायक और एक बाइनरी ऑपरेटर जैसे संयोजन फ़ंक्शन। चूंकि प्रकार का प्रारंभिक मूल्य व्यक्ति के प्रकार तक सीमित नहीं है, इसलिए आप प्रत्येक व्यक्ति के कुल जीवित वर्षों का निर्धारण करने के लिए कटौती का उपयोग कर सकते हैं:

 Integer ageSum = persons .stream() .reduce(0, (sum, p) -> sum += p.age, (sum1, sum2) -> sum1 + sum2); System.out.println(ageSum); // 76 

जैसा कि आप देख सकते हैं, हमें परिणाम 76 मिला, लेकिन वास्तव में हुड के तहत क्या होता है?

हम डिबग के लिए पाठ के आउटपुट के साथ उपरोक्त कोड के टुकड़े का विस्तार करते हैं:

 Integer ageSum = persons .stream() .reduce(0, (sum, p) -> { System.out.format("accumulator: sum=%s; person=%s\n", sum, p); return sum += p.age; }, (sum1, sum2) -> { System.out.format("combiner: sum1=%s; sum2=%s\n", sum1, sum2); return sum1 + sum2; }); // accumulator: sum=0; person=Max // accumulator: sum=18; person=Peter // accumulator: sum=41; person=Pamela // accumulator: sum=64; person=David 

जैसा कि आप देख सकते हैं, संचय कार्य सभी कार्य करता है। इसे पहले 0 के शुरुआती मूल्य और पहले व्यक्ति मैक्स के साथ बुलाया जाता है। अगले तीन चरणों में, व्यक्ति की आयु अंतिम चरण से लगातार बढ़ जाती है जब तक कि वह 76 वर्ष की आयु तक नहीं पहुंच जाता।

तो आगे क्या है? क्या कंबाइन को कभी नहीं बुलाया जाता है? इस धागे के समानांतर निष्पादन पर विचार करें:

 Integer ageSum = persons .parallelStream() .reduce(0, (sum, p) -> { System.out.format("accumulator: sum=%s; person=%s\n", sum, p); return sum += p.age; }, (sum1, sum2) -> { System.out.format("combiner: sum1=%s; sum2=%s\n", sum1, sum2); return sum1 + sum2; }); // accumulator: sum=0; person=Pamela // accumulator: sum=0; person=David // accumulator: sum=0; person=Max // accumulator: sum=0; person=Peter // combiner: sum1=18; sum2=23 // combiner: sum1=23; sum2=12 // combiner: sum1=41; sum2=35 

समानांतर निष्पादन के साथ, हमें पूरी तरह से अलग कंसोल आउटपुट मिलता है। अब कंबाइन को वास्तव में बुलाया जा रहा है। , , -.

.

. ForkJoinPool ForkJoinPool.commonPool() . 5 — .

 ForkJoinPool commonPool = ForkJoinPool.commonPool(); System.out.println(commonPool.getParallelism()); // 3 

3 . JVM:

 -Djava.util.concurrent.ForkJoinPool.common.parallelism=5 

parallelStream() . parallel() .

, (thread) System.out :

 Arrays.asList("a1", "a2", "b1", "c2", "c1") .parallelStream() .filter(s -> { System.out.format("filter: %s [%s]\n", s, Thread.currentThread().getName()); return true; }) .map(s -> { System.out.format("map: %s [%s]\n", s, Thread.currentThread().getName()); return s.toUpperCase(); }) .forEach(s -> System.out.format("forEach: %s [%s]\n", s, Thread.currentThread().getName())); 

, (thread) (stream):

 filter: b1 [main] filter: a2 [ForkJoinPool.commonPool-worker-1] map: a2 [ForkJoinPool.commonPool-worker-1] filter: c2 [ForkJoinPool.commonPool-worker-3] map: c2 [ForkJoinPool.commonPool-worker-3] filter: c1 [ForkJoinPool.commonPool-worker-2] map: c1 [ForkJoinPool.commonPool-worker-2] forEach: C2 [ForkJoinPool.commonPool-worker-3] forEach: A2 [ForkJoinPool.commonPool-worker-1] map: b1 [main] forEach: B1 [main] filter: a1 [ForkJoinPool.commonPool-worker-3] map: a1 [ForkJoinPool.commonPool-worker-3] forEach: A1 [ForkJoinPool.commonPool-worker-3] forEach: C1 [ForkJoinPool.commonPool-worker-2] 

, (threads) ForkJoinPool . , (thread).

sort :

 Arrays.asList("a1", "a2", "b1", "c2", "c1") .parallelStream() .filter(s -> { System.out.format("filter: %s [%s]\n", s, Thread.currentThread().getName()); return true; }) .map(s -> { System.out.format("map: %s [%s]\n", s, Thread.currentThread().getName()); return s.toUpperCase(); }) .sorted((s1, s2) -> { System.out.format("sort: %s <> %s [%s]\n", s1, s2, Thread.currentThread().getName()); return s1.compareTo(s2); }) .forEach(s -> System.out.format("forEach: %s [%s]\n", s, Thread.currentThread().getName())); 

:

 filter: c2 [ForkJoinPool.commonPool-worker-3] filter: c1 [ForkJoinPool.commonPool-worker-2] map: c1 [ForkJoinPool.commonPool-worker-2] filter: a2 [ForkJoinPool.commonPool-worker-1] map: a2 [ForkJoinPool.commonPool-worker-1] filter: b1 [main] map: b1 [main] filter: a1 [ForkJoinPool.commonPool-worker-2] map: a1 [ForkJoinPool.commonPool-worker-2] map: c2 [ForkJoinPool.commonPool-worker-3] sort: A2 <> A1 [main] sort: B1 <> A2 [main] sort: C2 <> B1 [main] sort: C1 <> C2 [main] sort: C1 <> B1 [main] sort: C1 <> C2 [main] forEach: A1 [ForkJoinPool.commonPool-worker-1] forEach: C2 [ForkJoinPool.commonPool-worker-3] forEach: B1 [main] forEach: A2 [ForkJoinPool.commonPool-worker-2] forEach: C1 [ForkJoinPool.commonPool-worker-1] 

, sort main . sort Stream API Arrays , Java 8, — Arrays.parallelSort() . , , — :

“”, Arrays.sort.

reduce . , . , :

 List<Person> persons = Arrays.asList( new Person("Max", 18), new Person("Peter", 23), new Person("Pamela", 23), new Person("David", 12)); persons .parallelStream() .reduce(0, (sum, p) -> { System.out.format("accumulator: sum=%s; person=%s [%s]\n", sum, p, Thread.currentThread().getName()); return sum += p.age; }, (sum1, sum2) -> { System.out.format("combiner: sum1=%s; sum2=%s [%s]\n", sum1, sum2, Thread.currentThread().getName()); return sum1 + sum2; }); 

, : , , :

 accumulator: sum=0; person=Pamela; [main] accumulator: sum=0; person=Max; [ForkJoinPool.commonPool-worker-3] accumulator: sum=0; person=David; [ForkJoinPool.commonPool-worker-2] accumulator: sum=0; person=Peter; [ForkJoinPool.commonPool-worker-1] combiner: sum1=18; sum2=23; [ForkJoinPool.commonPool-worker-1] combiner: sum1=23; sum2=12; [ForkJoinPool.commonPool-worker-2] combiner: sum1=41; sum2=35; [ForkJoinPool.commonPool-worker-2] 

, . , ( ), .

, ForkJoinPool , JVM. , (threads), .

Java 8 . . , , (Martin Fowler) Collection Pipelines .

JavaScript, Stream.js — JavaScript Java 8 Streams API. , Java 8 Tutorial ( ) Java 8 Nashorn Tutorial .

, , . GitHub . , .