JShell में Java 9: टर्मिनल स्ट्रीम ऑपरेशंस (reduce, max, min, collect)

JShell Java 9 का REPL टूल है जो स्ट्रीम API का इंटरैक्टिव अन्वेषण करने के लिए उत्कृष्ट है। टर्मिनल ऑपरेशंस एक स्ट्रीम पाइपलाइन का उपभोग करते हैं और एक परिणाम (गैर-स्ट्रीम) उत्पन्न करते हैं - वे पाइपलाइन को ट्रिगर करते हैं।

टर्मिनल ऑपरेशंस अवलोकन

JShell सत्र: मूल लेख से उदाहरण

jshell> IntStream.range(1, 11).reduce(0, (n1, n2) -> n1 + n2)
$1 ==> 55

jshell> List.of(23, 12, 34, 53).stream().max()
|  Error: method max requires Comparator
|  List.of(23, 12, 34, 53).stream().max();
|  ^----------------------------------^

jshell> List.of(23, 12, 34, 53).stream().max((n1, n2) -> Integer.compare(n1, n2))
$2 ==> Optional[53]

jshell> $2.isPresent()
$3 ==> true

jshell> List.of(23, 12, 34, 53).stream().max((n1, n2) -> Integer.compare(n1, n2)).get()
$4 ==> 53

jshell> List.of(23, 12, 34, 53).stream().filter(e -> e%2==1).forEach(e -> System.out.println(e))
23
53

jshell> List.of(23, 12, 34, 53).stream().filter(e -> e%2==1).collect(Collectors.toList())
$6 ==> [23, 53]

jshell> List.of(23, 12, 34, 53).stream().min((n1, n2) -> Integer.compare(n1, n2)).get()
$8 ==> 12

विस्तृत टर्मिनल ऑपरेशंस उदाहरण

reduce - रिडक्शन

jshell> // पहचान मान के साथ (समांतर-सुरक्षित)
jshell> List.of(1,2,3,4,5).stream().reduce(0, (a,b) -> a+b)
$1 ==> 15

jshell> // पहचान के बिना (Optional लौटाता है)
jshell> List.of(1,2,3,4,5).stream().reduce((a,b) -> a+b)
$2 ==> Optional[15]

jshell> // तीन-आर्ग संस्करण: पहचान, संचयक, कम्बाइनर
jshell> List.of(1,2,3,4,5).parallelStream()
   ...>     .reduce(0, (a,b) -> a+b, (a,b) -> a+b)
$3 ==> 15

jshell> // स्ट्रिंग जोड़
jshell> List.of("a","b","c").stream().reduce("", (a,b) -> a+b)
$4 ==> "abc"

min/max - तुलना के साथ

jshell> // Comparator आवश्यक (प्राकृतिक क्रम के लिए)
jshell> List.of(23, 12, 34, 53).stream().max(Integer::compare)
$1 ==> Optional[53]

jshell> List.of(23, 12, 34, 53).stream().min(Integer::compare)
$2 ==> Optional[12]

jshell> // ऑब्जेक्ट्स के लिए
jshell> List.of("apple", "banana", "cherry").stream().max(String::compareTo)
$3 ==> Optional[cherry]

jshell> // कस्टम Comparator
jshell> record Person(String name, int age) {}
jshell> List.of(new Person("A",30), new Person("B",25)).stream()
   ...>     .max(Comparator.comparing(Person::age))
$4 ==> Optional[Person[name=A, age=30]]

collect - संचय

jshell> import static java.util.stream.Collectors.*
|  imported java.util.stream.Collectors.*

jshell> // सूची में
jshell> List.of(1,2,3,4,5).stream().collect(toList())
$1 ==> [1, 2, 3, 4, 5]

jshell> // सेट में (डुप्लिकेट हटाता है)
jshell> List.of(1,2,2,3,3,3).stream().collect(toSet())
$2 ==> [1, 2, 3]

jshell> // मैप में
jshell> List.of("a","bb","ccc").stream().collect(toMap(s->s, s->s.length()))
$3 ==> {a=1, bb=2, ccc=3}

jshell> // जोड़ना
jshell> List.of("a","b","c").stream().collect(joining(","))
$4 ==> "a,b,c"

jshell> // ग्रुपिंग
jshell> List.of(1,2,3,4,5,6).stream().collect(groupingBy(n -> n%2))
$5 ==> {0=[2, 4, 6], 1=[1, 3, 5]}

jshell> // पार्टीशनिंग
jshell> List.of(1,2,3,4,5,6).stream().collect(partitioningBy(n -> n%2==0))
$6 ==> {false=[1, 3, 5], true=[2, 4, 6]}

jshell> // सारांश सांख्यिकी
jshell> List.of(1,2,3,4,5).stream().collect(summarizingInt(i -> i))
$7 ==> IntSummaryStatistics{count=5, sum=15, min=1, average=3.0, max=5}

मैचिंग और फाइंडिंग

jshell> List.of(1,2,3,4,5).stream().anyMatch(n -> n > 3)
$1 ==> true

jshell> List.of(1,2,3,4,5).stream().allMatch(n -> n > 0)
$2 ==> true

jshell> List.of(1,2,3,4,5).stream().noneMatch(n -> n < 0)
$3 ==> true

jshell> List.of(1,2,3,4,5).stream().findFirst()
$4 ==> Optional[1]

jshell> List.of(1,2,3,4,5).parallelStream().findAny()
$5 ==> Optional[3]  // कोई भी तत्व

forEach - साइड इफेक्ट्स

jshell> List.of("a","b","c").stream().forEach(System.out::print)
abc

jshell> // इंडेक्स के साथ
jshell> List.of("a","b","c").stream()
   ...>     .collect(Collectors.toList())
   ...>     .forEach(System.out::println);
a
b
c

प्राइमिटिव स्ट्रीम स्पेशलाइजेशन

jshell> // IntStream - बॉक्सिंग से बचाता है
jshell> IntStream.range(1, 101).sum()
$1 ==> 5050

jshell> IntStream.of(1,2,3,4,5).average()
$2 ==> OptionalDouble[3.0]

jshell> IntStream.of(1,2,3,4,5).summaryStatistics()
$3 ==> IntSummaryStatistics{count=5, sum=15, min=1, average=3.0, max=5}

jshell> // LongStream, DoubleStream समान

सामान्य नुकसान

• max()/min() के लिए Comparator आवश्यक: प्राकृतिक क्रम के लिए Integer::compare का उपयोग करें
• Optional संचालन: .get() से पहले .isPresent() जांचें या .orElse() उपयोग करें
• reduce पहचान: समांतर स्ट्रीम्स के लिए तीन-आर्ग संस्करण का उपयोग करें
• forEach क्रम: समांतर स्ट्रीम्स में अनिश्चित क्रम
• स्ट्रीम पुनः उपयोग नहीं किया जा सकता: टर्मिनल ऑपरेशन के बाद स्ट्रीम बंद हो जाती है

सर्वोत्तम अभ्यास

• मेथड रेफरेंस पसंद करें: Integer::compare (a,b) -> a-b से बेहतर
• प्राइमिटिव स्ट्रीम्स का उपयोग करें: IntStream, LongStream, DoubleStream बॉक्सिंग से बचाते हैं
• Collectors लाइब्रेरी: सामान्य संचय पैटर्न के लिए समृद्ध सेट
• समांतरता: बड़े डेटासेट्स के लिए .parallelStream() लेकिन ओवरहेड पर विचार करें