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

Stream1. कक्षा के तरीकों की सूची

क्लास को डेटा स्ट्रीम की चेन बनानाStream आसान बनाने के लिए बनाया गया था । इसे प्राप्त करने के लिए, कक्षा में ऐसी विधियाँ हैं जो नई वस्तुओं को लौटाती हैं।Stream<T>Stream

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

यहाँ वर्ग के तरीके हैं Stream(केवल सबसे बुनियादी वाले):

Stream<T> of()

Stream<T> generate()

Stream<T> concat()

Stream<T> filter()

Stream<T> distinct()

Stream<T> sorted()

Stream<T> peek()

Stream<T> limit(n)

Stream<T> skip(n)

Stream<R> map()

Stream<R> flatMap()

boolean anyMatch()

boolean allMatch()

boolean noneMatch()

Optional<T> findFirst()

Optional<T> findAny()

Optional<T> min()

Optional<T> max()

long count()

R collect()

Stream2. वर्ग द्वारा मध्यवर्ती और टर्मिनल संचालन

जैसा कि आप देख सकते हैं, उपरोक्त तालिका में सभी विधियां a वापस नहीं करती हैं Stream। यह इस तथ्य से संबंधित है कि वर्ग के तरीकों को मध्यवर्ती ( गैर-टर्मिनल के रूप में भी जाना जाता है ) विधियों और टर्मिनल विधियों Streamमें विभाजित किया जा सकता है ।

मध्यवर्ती तरीके

इंटरमीडिएट विधियां एक ऑब्जेक्ट लौटाती हैं जो Streamइंटरफ़ेस को लागू करती है, और उन्हें एक साथ जंजीर किया जा सकता है।

टर्मिनल तरीके

टर्मिनल विधियाँ एक के अलावा कोई मान लौटाती हैं Stream।

विधि कॉल पाइपलाइन

इस प्रकार, आप किसी भी इंटरमीडिएट विधियों और अंत में एक टर्मिनल विधि कॉल वाली एक स्ट्रीम पाइपलाइन बना सकते हैं। कोड पठनीयता को बढ़ाते हुए, यह दृष्टिकोण आपको जटिल तर्क को लागू करने देता है।

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

दूसरे शब्दों में, यदि टर्मिनल विधि को नहीं कहा जाता है, तो डेटा स्ट्रीम में डेटा किसी भी तरह से संसाधित नहीं होता है। टर्मिनल विधि को कॉल करने के बाद ही स्ट्रीम पाइपलाइन में निर्दिष्ट नियमों के अनुसार डेटा संसाधित होना शुरू हो जाता है।

stream()
  .intemediateOperation1()
  .intemediateOperation2()
  ...
  .intemediateOperationN()
  .terminalOperation();

मध्यवर्ती और टर्मिनल विधियों की तुलना:

आइए एक उदाहरण देखें।

मान लीजिए कि हमारे पास पशु प्रेमियों के लिए एक क्लब है। कल क्लब जिंजर कैट डे मनाएगा। क्लब में पालतू जानवरों के मालिक हैं, जिनमें से प्रत्येक के पास पालतू जानवरों की एक सूची है। वे बिल्लियों तक ही सीमित नहीं हैं।

कार्य: कल के "पेशेवर अवकाश" के लिए उनके लिए व्यक्तिगत ग्रीटिंग कार्ड बनाने के लिए आपको सभी अदरक बिल्लियों के सभी नामों की पहचान करने की आवश्यकता है। ग्रीटिंग कार्ड्स को बिल्ली की उम्र के अनुसार क्रमबद्ध किया जाना चाहिए, सबसे पुराने से लेकर सबसे कम उम्र तक।

सबसे पहले, हम इस कार्य को हल करने में सहायता के लिए कुछ कक्षाएं प्रदान करते हैं:

public enum Color {
   WHITE,
   BLACK,
   DARK_GREY,
   LIGHT_GREY,
   FOXY,
   GREEN,
   YELLOW,
   BLUE,
   MAGENTA
}

public abstract class Animal {
   private String name;
   private Color color;
   private int age;

   public Animal(String name, Color color, int age) {
      this.name = name;
      this.color = color;
      this.age = age;
   }

   public String getName() {
      return name;
   }

   public Color getColor() {
      return color;
   }

   public int getAge() {
      return age;
   }
}

public class Cat extends Animal {
   public Cat(String name, Color color, int age) {
      super(name, color, age);
   }
}

public class Dog extends Animal {
   public Dog(String name, Color color, int age) {
      super(name, color, age);
   }
}

public class Parrot extends Animal {
   public Parrot(String name, Color color, int age) {
      super(name, color, age);
   }
}

public class Pig extends Animal {
   public Pig(String name, Color color, int age) {
      super(name, color, age);
   }
}

public class Snake extends Animal {
   public Snake(String name, Color color, int age) {
      super(name, color, age);
   }
}

public class Owner {
   private String name;
   private List<Animal> pets = new ArrayList<>();

   public Owner(String name) {
      this.name = name;
   }

   public List<Animal> getPets() {
      return pets;
   }
}

अब आइए उस Selectorवर्ग पर नजर डालते हैं, जहां निर्दिष्ट मानदंडों के अनुसार चयन किया जाएगा:

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Selector {
   private static List<Owner> owners;

   private static void initData() {
      final Owner owner1 = new Owner("Ronan Turner");
      owner1.getPets().addAll(List.of(
            new Cat("Baron", Color.BLACK, 3),
            new Cat("Sultan", Color.DARK_GREY, 4),
            new Dog("Elsa", Color.WHITE, 0)
      ));

      final Owner owner2 = new Owner("Scarlet Murray");
      owner2.getPets().addAll(List.of(
            new Cat("Ginger", Color.FOXY, 7),
            new Cat("Oscar", Color.FOXY, 5),
            new Parrot("Admiral", Color.BLUE, 3)
      ));

      final Owner owner3 = new Owner("Felicity Mason");
      owner3.getPets().addAll(List.of(
            new Dog("Arnold", Color.FOXY, 3),
            new Pig("Vacuum Cleaner", Color.LIGHT_GREY, 8)
      ));

      final Owner owner4 = new Owner("Mitchell Stone");
      owner4.getPets().addAll(List.of(
            new Snake("Mr. Boa", Color.DARK_GREY, 2)
      ));

      final Owner owner5 = new Owner("Jonathan Snyder");
      owner5.getPets().addAll(List.of(
            new Cat("Fisher", Color.BLACK, 16),
            new Cat("Zorro", Color.FOXY, 14),
            new Cat("Margo", Color.WHITE, 3),
            new Cat("Brawler", Color.DARK_GREY, 1)
      ));

      owners = List.of(owner1, owner2, owner3, owner4, owner5);
   }
}

mainविधि में कोड जोड़ने के लिए क्या रहता है । वर्तमान में, हम पहले उस initData()विधि को कॉल करते हैं, जो क्लब में पालतू जानवरों के मालिकों की सूची को भरती है। फिर हम घटते क्रम में उनकी उम्र के आधार पर छांटे गए अदरक बिल्लियों के नामों का चयन करते हैं।

सबसे पहले, आइए कोड देखें जो इस कार्य को हल करने के लिए धाराओं का उपयोग नहीं करता है:

public static void main(String[] args) {
   initData();

   List<String> findNames = new ArrayList<>();
   List<Cat> findCats = new ArrayList<>();
   for (Owner owner : owners) {
      for (Animal pet : owner.getPets()) {
         if (Cat.class.equals(pet.getClass()) && Color.FOXY == pet.getColor()) {
            findCats.add((Cat) pet);
         }
      }
   }

   Collections.sort(findCats, new Comparator<Cat>() {
      public int compare(Cat o1, Cat o2) {
         return o2.getAge() - o1.getAge();
      }
   });

   for (Cat cat : findCats) {
      findNames.add(cat.getName());
   }

   findNames.forEach(System.out::println);
}

अब आइए एक विकल्प देखें:

public static void main(String[] args) {
   initData();

   final List<String> findNames = owners.stream()
           .flatMap(owner -> owner.getPets().stream())
           .filter(pet -> Cat.class.equals(pet.getClass()))
           .filter(cat -> Color.FOXY == cat.getColor())
           .sorted((o1, o2) -> o2.getAge() - o1.getAge())
           .map(Animal::getName)
           .collect(Collectors.toList());

   findNames.forEach(System.out::println);
}

जैसा कि आप देख सकते हैं, कोड बहुत अधिक कॉम्पैक्ट है। इसके अलावा, स्ट्रीम पाइपलाइन की प्रत्येक पंक्ति एक क्रिया है, इसलिए उन्हें अंग्रेजी में वाक्यों की तरह पढ़ा जा सकता है:

.flatMap(owner -> owner.getPets().stream())

.filter(pet -> Cat.class.equals(pet.getClass()))

.filter(cat -> Color.FOXY == cat.getColor())

.sorted((o1, o2) -> o2.getAge() - o1.getAge())

.map(Animal::getName)

.collect(Collectors.toList())

3. धाराएँ बनाना

कक्षा Streamमें तीन विधियाँ हैं जिन्हें हमने अभी तक कवर नहीं किया है। इन तीन विधियों का उद्देश्य नए सूत्र बनाना है।

Stream<T>.of(T obj)तरीका

विधि of()एक धारा बनाती है जिसमें एक तत्व होता है। आमतौर पर इसकी आवश्यकता तब होती है, जब कोई फ़ंक्शन Stream<T>तर्क के रूप में ऑब्जेक्ट लेता है, लेकिन आपके पास केवल Tऑब्जेक्ट होता है। फिर आप आसानी से और आसानी से एक तत्व वाली धाराof() प्राप्त करने के लिए विधि का उपयोग कर सकते हैं ।

उदाहरण:

Stream<Integer> stream = Stream.of(1);

Stream<T> Stream.of(T obj1, T obj2, T obj3, ...)तरीका

विधि of()एक धारा बनाती है जिसमें पारित तत्व होते हैं । किसी भी संख्या में तत्वों की अनुमति है। उदाहरण:

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);

Stream<T> Stream.generate(Supplier<T> obj)तरीका

विधि generate()आपको एक नियम सेट करने देती है जिसका उपयोग अनुरोध किए जाने पर धारा के अगले तत्व को उत्पन्न करने के लिए किया जाएगा। उदाहरण के लिए, आप हर बार एक यादृच्छिक संख्या दे सकते हैं ।

उदाहरण:

Stream<Double> s = Stream.generate(Math::random);

Stream<T> Stream.concat(Stream<T> a, Stream<T> b)तरीका

विधि concat()दो पास की गई धाराओं को एक में जोड़ती है । जब डेटा पढ़ा जाता है, तो इसे पहले पहली स्ट्रीम से और फिर दूसरी स्ट्रीम से पढ़ा जाता है। उदाहरण:

Stream<Integer> stream1 = Stream.of(1, 2, 3, 4, 5);
Stream<Integer> stream2 = Stream.of(10, 11, 12, 13, 14);
Stream<Integer> result = Stream.concat(stream1, stream2);

4. डेटा फ़िल्टर करना

अन्य 6 विधियाँ नई डेटा धाराएँ बनाती हैं, जिससे आप विभिन्न जटिलता की श्रृंखलाओं (या पाइपलाइनों) में धाराओं को संयोजित कर सकते हैं।

Stream<T> filter(Predicate<T>)तरीका

यह विधि एक नई डेटा स्ट्रीम लौटाती है जो पास किए गए नियम के अनुसार स्रोत डेटा स्ट्रीम को फ़िल्टर करती है । विधि को उस वस्तु पर बुलाया जाना चाहिए जिसका प्रकार है ।Stream<T>

आप लैम्ब्डा फ़ंक्शन का उपयोग करके फ़िल्टरिंग नियम निर्दिष्ट कर सकते हैं , जिसे संकलक फिर Predicate<T>ऑब्जेक्ट में परिवर्तित कर देगा।

उदाहरण:

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

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

Stream<T> sorted(Comparator<T>)तरीका

यह विधि एक नई डेटा स्ट्रीम लौटाती है जो डेटा को स्रोत स्ट्रीम में सॉर्ट करती है । आप एक तुलनित्र में पास होते हैं , जो डेटा स्ट्रीम के दो तत्वों की तुलना करने के लिए नियम निर्धारित करता है।

Stream<T> distinct()तरीका

यह विधि एक नई डेटा स्ट्रीम लौटाती है जिसमें स्रोत डेटा स्ट्रीम में केवल अद्वितीय तत्व होते हैं । सभी डुप्लिकेट डेटा को छोड़ दिया गया है। उदाहरण:

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 2, 2, 2, 3, 4);
Stream<Integer> stream2 = stream.distinct(); // 1, 2, 3, 4, 5

Stream<T> peek(Consumer<T>)तरीका

यह विधि एक नई डेटा स्ट्रीम लौटाती है , हालांकि इसमें डेटा स्रोत स्ट्रीम के समान ही है। लेकिन जब स्ट्रीम से अगले तत्व का अनुरोध किया जाता है, तो आपके द्वारा विधि को पारित किए गए फ़ंक्शन कोpeek() इसके साथ बुलाया जाता है।

यदि आप फ़ंक्शन को विधि System.out::printlnमें पास करते हैं peek(), तो सभी ऑब्जेक्ट तब प्रदर्शित होंगे जब वे स्ट्रीम से गुजरेंगे।

Stream<T> limit(int n)तरीका

यह विधि एक नई डेटा स्ट्रीम लौटाती है जिसमें स्रोत डेटा स्ट्रीम में केवल पहले nतत्व शामिल होते हैं । अन्य सभी डेटा को खारिज कर दिया गया है। उदाहरण:

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 2, 2, 2, 3, 4);
Stream<Integer> stream2 = stream.limit(3); // 1, 2, 3

Stream<T> skip(int n)तरीका

यह विधि एक नई डेटा स्ट्रीम लौटाती है जिसमें स्रोत स्ट्रीम के समान सभी तत्व होते हैं , लेकिन पहले तत्वों को छोड़ देते हैं (अनदेखा करते हैं)। nउदाहरण:

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 2, 2, 2, 3, 4);
Stream<Integer> stream2 = stream.skip(3); // 4, 5, 2, 2, 2, 3, 4