Работа с потоци, част 1

1. Списък с методи на Streamкласа

Класът 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()

2. Междинни и крайни операции по Streamклас

Както можете да видите, не всички методи в tableта по-горе връщат Stream. Това е свързано с факта, че методите на Streamкласа могат да бъдат разделени на междинни (известни също като нетерминални ) методи и терминални методи.

Междинни методи

Междинните методи връщат обект, който имплементира Streamинтерфейса, и те могат да бъдат свързани заедно.

Терминални методи

Терминалните методи връщат стойност, различна от Stream.

Конвейер за извикване на метод

По този начин можете да изградите конвейер на поток, състоящ се от произволен брой междинни методи и едно извикване на терминален метод в края. Този подход ви позволява да приложите доста сложна логика, като същевременно увеличавате четливостта на codeа.

Данните в поток от данни не се променят изобщо. Верига от междинни методи е гладък (декларативен) начин за указване на конвейер за обработка на данни, който ще бъде изпълнен след извикване на терминалния метод.

С други думи, ако терминалният метод не бъде извикан, тогава данните в потока от данни не се обработват по ниHowъв начин. Едва след като се извика терминалният метод, данните започват да се обработват съгласно правилата, посочени в конвейера на потока.

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класа, където ще бъде напequals изборът според посочените критерии:

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);
   }
}

Остава да добавим code към mainметода. В момента първо извикваме initData()метода, който попълва списъка със собственици на домашни любимци в клуба. След това избираме имената на джинджифиловите котки, сортирани по възраст в низходящ ред.

Първо, нека разгледаме code, който не използва потоци за решаване на тази задача:

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);
}

Както можете да видите, codeът е много по-компактен. В допълнение, всеки ред от тръбопровода на потока е едно действие, така че те могат да се четат като изречения на английски:

.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 метода създават нови потоци от данни, което ви позволява да комбинирате потоци във вериги (or конвейери) с различна сложност.

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