धाराओं के साथ काम करना, भाग 3

1. जाँच करना

मुझे लगता है कि आप पहले से ही डेटा स्ट्रीम को एक साथ चेन करने के तरीके सीखने से ऊब गए होंगे। आप अंततः डेटा के साथ कुछ करना चाहते हैं।

कक्षा Streamमें तीन मानक विधियाँ हैं जो धाराएँ नहीं बनाती हैं, बल्कि जाँचती हैं कि उनमें किस प्रकार का डेटा है। ये विधियां हैं: anyMatch(), allMatch(), और noneMatch().

boolean anyMatch(rule)तरीका

यह विधि जाँचती है कि क्या धारा में कम से कम एक तत्व है जो विधि को पारित नियम को संतुष्ट करता है। यदि ऐसा कोई तत्व है, तो विधि वापस आ जाती है true, अन्यथा false।

उदाहरण

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
boolean result = stream.anyMatch(x -> x > 0);

true

Stream<Integer> stream = Stream.of(1, -2, 3, -4, 5);
boolean result = stream.anyMatch(x -> x > 0);

true

Stream<Integer> stream = Stream.of(1, -2, 3, -4, 5);
boolean result = stream.filter(x -> x < 0).anyMatch(x -> x > 0);

false

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

बूलियन ऑलमैच (नियम) विधि

यह विधि जाँचती है कि धारा में सभी तत्व नियम से मेल खाते हैं (जिसे विधेय के रूप में भी जाना जाता है)। नियम विधि के तर्क के रूप में पारित किया गया है:

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
boolean result = stream.allMatch(x -> x > 0);

true

Stream<Integer> stream = Stream.of(1, -2, 3, -4, 5);
boolean result = stream.allMatch(x -> x > 0);

false

Stream<Integer> stream = Stream.of(1, -2, 3, -4, 5);
boolean result = stream.filter(x -> x < 0).allMatch(x -> x < 0);

true

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

बूलियन नोमैच (नियम) विधि

विधि noneMatch()जाँचती है कि क्या धारा में कोई तत्व नहीं है जो पारित नियम से मेल खाता हो। यह विधि के विपरीत जैसा है anyMatch()।

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
boolean result = stream.noneMatch(x -> x > 0);

false

Stream<Integer> stream = Stream.of(1, -2, 3, -4, 5);
boolean result = stream.noneMatch(x -> x > 0);

false

Stream<Integer> stream = Stream.of(1, -2, 3, -4, 5);
boolean result = stream.filter(x -> x < 0).noneMatch(x -> x > 0);

true

2. उपयोगिता वर्ग: Optionalवर्ग

nullकभी-कभी प्रोग्रामर के लिए संदर्भों के साथ काम करना बहुत असुविधाजनक होता है । उदाहरण के लिए, मान लीजिए कि आप दो तारों की तुलना कर रहे हैं। यदि दोनों चर नहीं हैं null, तो आप बस कॉल कर सकते हैं s1.equals(s2), और सब कुछ काम करेगा। लेकिन अगर s1हो सकता है null, तो आपको एक से बचने के लिए कोड लिखना होगा जो इस स्थिति को संभालता है NullPointerException।

इसलिए प्रोग्रामर Optional<T>यूटिलिटी क्लास लेकर आए। इसका कोड मोटे तौर पर इस तरह दिखता है:

class Optional<Type>
{
   private final Type value;
   private Optional() { this.value = null;}
   private Optional(value) { this.value = value;}
   public static <Type> Optional<Type> of(Type value)
   {
      return new Optional<Type>(value);
   }

   public boolean isPresent()
   {
      return value != null;
   }

   public boolean isEmpty()
   {
      return value == null;
   }

   public Type get()
   {
      if (value == null)
      {
         throw new NoSuchElementException();
      }
      return value;
   }

   public Type orElse(Type other)
   {
      return value != null ? value : other;
   }

   public Type orElseThrow()
   {
      if (value == null)
      {
         throw new NoSuchElementException();
      }
      return value;
   }
}

इस वर्ग का उद्देश्य केवल एक टी ऑब्जेक्ट (किसी ऑब्जेक्ट का संदर्भ जिसका प्रकार टी है) को स्टोर करना है। Optional<T>किसी वस्तु के अंदर वस्तु संदर्भ हो सकता है null।

यह वर्ग प्रोग्रामरों को थोड़ा सुंदर कोड लिखने देता है। आइए तुलना करें:

public void printString(String s)
{
   Optional<String> str = Optional.ofNullable(s);
   System.out.println(str.orElse(""));
}

public void printString(String s)
{
   String str = s != null ? s : "";
   System.out.println(str)
}

विधि का उपयोग करके एक Optionalवस्तु की तुलना हमेशा दूसरी Optionalवस्तु से की जा सकती है equals, भले ही वे nullसंदर्भों को संग्रहीत करते हों।

सीधे शब्दों में कहें, तो Optionalकक्षा आपको "सुंदर" चेक लिखने देती है nullऔर "सुंदर" क्रियाएं उस घटना में लिखती है जब कोई Optionalऑब्जेक्ट एक nullमान संग्रहीत करता है।

3. तत्वों का पता लगाना

चलिए Streamकक्षा में वापस आते हैं। कक्षा Streamमें 4 और विधियाँ हैं जो आपको एक धारा में तत्वों की खोज करने देती हैं। ये तरीके हैं findFirst(), findAny(), min(), और max().

Optional<T> findFirst()तरीका

विधि findFirst()केवल धारा में पहला तत्व लौटाती है। बस इतना ही करता है।

यहां ध्यान देने वाली अधिक दिलचस्प बात यह है कि यह विधि किसी वस्तु को वापस नहीं करती है T, बल्कि एक Optional<T>आवरण वस्तु है। nullयह सुनिश्चित करता है कि किसी वस्तु को खोजने में विफल होने के बाद विधि कभी वापस नहीं आएगी ।

उदाहरण:

ArrayList<String> list = new ArrayList<String>();
Collections.addAll(list, "Hello", "how's", "life?");
String str = list.stream().findFirst().get(); // Hello

अधिक स्पष्टता के लिए, आइए अंतिम पंक्ति को कई पंक्तियों में विभाजित करें:

ArrayList<String> list = new ArrayList<String>();
Collections.addAll(list, "Hello", "how's", "life?");

Stream<String> stream = list.stream();
Optional<String> result = stream.findFirst();
String str = result.get(); // Hello

अंतिम विधि केवल वस्तु के get()अंदर संग्रहीत मान को पुनः प्राप्त करती है ।Optional

Optional<T> findAny()तरीका

विधि findAny()किसी भी तत्व को धारा से लौटाती है और वहीं समाप्त होती है। यह विधि समान है findFirst(), लेकिन यह समानांतर संचालन में उपयोग की जाने वाली धाराओं के लिए बहुत अच्छी है।

समानांतर में धाराओं को संसाधित करते समय, यह हो सकता है कि धारा के कुछ हिस्से में पहले से ही एक तत्व पाया गया हो, लेकिन यह अभी तक स्पष्ट नहीं है कि यह पहला है या नहीं।

यदि कई तत्व सभी फ़िल्टर से मेल खाते हैं, और प्रोग्रामर के लिए उनमें से सबसे पहले प्राप्त करना महत्वपूर्ण है, तो विधि वह findFirst()है जिसे कहा जाना चाहिए। यदि प्रोग्रामर जानता है कि वास्तव में 0 या 1 तत्व सभी फ़िल्टर से मेल खाएगा, तो यह केवल कॉल करने के लिए पर्याप्त है findAny()- और यह तेज़ होगा।

Optional<T> min(Comparator<T>)तरीका

विधि धारा में सभी तत्वों की तुलना करने के लिए min()एक वस्तु का उपयोग करती है और न्यूनतम तत्व लौटाती है। comparatorएक तुलनित्र वस्तु को परिभाषित करने का सबसे सुविधाजनक तरीका लैम्ब्डा फ़ंक्शन है।

सबसे छोटी स्ट्रिंग खोजने का उदाहरण:

ArrayList<String> list = new ArrayList<String>();
Collections.addAll(list, "Hello", "how's", "life?");
String min = list.stream().min( (s1, s2)-> s1.length()-s2.length() ).get();

Optional<T> max(Comparator<T>)तरीका

विधि धारा में सभी तत्वों की तुलना करने के लिए max()एक वस्तु का उपयोग करती है और अधिकतम तत्व लौटाती है। comparatorएक तुलनित्र वस्तु को परिभाषित करने का सबसे सुविधाजनक तरीका लैम्ब्डा फ़ंक्शन है।

सबसे लंबी स्ट्रिंग की खोज का उदाहरण:

ArrayList<String> list = new ArrayList<String>();
Collections.addAll(list, "Hello", "how's", "life?");
String max = list.stream().max( (s1, s2)-> s1.length()-s2.length() ).get();