1. Lambda
2. Streams
3. New Date and Time API
Stream jest to suma pojedynczych operacji na zbiorze wartości.
Wynikiem może być wartość prymitywna, Obiekt lub wartość viod.
(obiekt może być reprezontowany przez obiekt kolekcji takich jak: List,Set,Map itp).
Collection (lub tablica) przechowuje obiekty w pamięci, Stream wywołuje operacje na nich (nie zajmują pamięci).
Zobaczmy jak można wykonać prostą funkcję Stream zastąpując blok operacji:

  1. Integer<Integer> liczby = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
  2. int sum = 0;
  3. for(Integer liczba : liczby) {
  4.         if ( liczba%2 == 1 ) {
  5.                 int kwadrat = liczba*liczba;
  6.                 sum+=kwadrat;
  7.         }
  8. }
Cały ten blok można zrobić używając stream:
  1. int sum = liczby.stream()
  2.                 .filter(liczba -> liczba%2 == 1 ) // przekazuje tylko nieparzyste liczby dalej, odrzuca parzyste.
  3.                                                   // przekazane 1,3,5,7,9
  4.                 .map(liczba -> liczba*liczba)     // podnosi do kwadratu i zwraca dalej
  5.                                                   // przekazane 1,9,25,49,81
  6.                 .reduce(0,Integer::sum);          // sumuje od 0 + wszyskie elementy
lub to samo obliczenie używając lambdy:
  1. int sum = liczby.stream()
  2.                 .filter(liczba -> liczba%2 == 1 )
  3.                 .map(liczba -> liczba*liczba)
  4.                 .reduce(0, (liczba1,liczba2) -> liczba1 + liczba2);
możemy stworzyć również strumień na podstawie statycznej metody Stream.of, co daje ten sam efekt.
  1. int suma = Stream.of(liczby)
  2.                 .filter(liczba -> liczba%2 == 1 )
  3.                 .map(liczba -> liczba*liczba)
  4.                 .reduce(0, (liczba1,liczba2) -> liczba1 + liczba2);
Możemy użyć również wzorca projektowego budowniczego do zbudowania strumienia. Możemy również przekazywać za każdym razem strumień do zmiennej i dopiero go wywoływać.
  1. Stream<Integer> mojStream = Stream.<Integer>builder().add(1).add(2).add(3).add(4).add(5).add(6).add(7).add(8).add(9).add(10).build();
  2. Stream<Integer> nieparzystyStream = mojStream.filter(liczba -> liczba%2 == 1 );
  3. Stream<Integer> kwadratStream = mojSnieparzystyStream.map(liczba -> liczba*liczba);
  4. int suma = kwadratStream.reduce(0,Integer::sum);
możemy to wywołanie zamienić na wielowątkowe, suży do tego zamiast wywołanie stream() to parallelStream().
  1. int sum = liczby.parallelStream()
  2.                 .filter(liczba -> liczba%2 == 1 )
  3.                 .map(liczba -> liczba*liczba)
  4.                 .reduce(0,Integer::sum);
IntStream,LongStream,DoubleStream to strumienie dla danych prymitywnych. Wszyskie Stream-y (IntStream,LongStream,DoubleStream,Stream<T>) dzidziczą po interface-sie BaseStream, a on dziedziczy po AutoCloseable. interface BaseStream<T, S extend BaseStream<T,S>> i posiada nastąpujące metody: void close() - zamyka strumień który zosta wywołany, tylko niektóre nieliczne strumienie muszą być zamykane. boolean isParallel() - true jeżli jest to strumień równoległy. false jeżli sekwencyjny Iterator<T> iterator() - zwraca iterator do strumienia. S onClose(Runnable handler) - zwraca nowy strumień. handler to zadanie które będzie wywołane kiedy stream jest zamykany. S parrallel() - na obecnym stream-ie zwracany jest strumieó równolegly. S sequential() - na obecnym stream-ie zwracany jest strumień sekwencyjny. Spliterator<T> spliterator - pobiera i zwraca referencję Spliterator dla strumienia. S unordered() - zwraca nieuporządkowany strumień. Interface Stream posiada nastpujące metody: <R,A> R collect(Collector<? super T,A,R> collectorFunc) - gromadzi elementy w kontenterze i je zwraca. T - to typ strumienia, R - typ strumienia wynikowego, A - typ elementu gromadzonego w kontenerze. long count() - ilość elementów w kontenerze. Stream<T> filter(Predicate<? super T> pred) - zwraca elementy spełniające warunek Predicate void forEach(Consumer<? super T> aciton) - pentla po wszystkich elementach strumiena <R> Stream<R> map(Function<? super T, ? extends R> mapFunc) - stosuje wyrażenie przekazane jako parametr i zwraca nowy strumień DoubleStream mapToDouble(ToDoubleFunction<? super T> mapFunc) - stosuje wyrażenie przekazane jako parametr zwraca DoubleStream. IntStream mapToInt(ToIntFunction<? super T> mapFunc) - stosuje wyrażenie przekazane jako parametr zwraca IntStream. LongStream mapToLong(ToLongFunction<? super T> mapFunc) - stosuje wyrażenie przekazane jako parametr zwraca LongStream. Optional<T> max(Comparator<? super T> comp) - na podstawie przekazanego komparatora zwraca maksymalny element. Optional<T> min(Comparator<? super T> comp) - na podstawie przekazanego komparatora zwraca minimalny element. T reduce(T idenityVal, BinaryOperator<T> accumulator) - pierwszy parametr metody określa początkową inicjalizację elementu, drugi element wywołują operację dla każdego elementu, taką jak sumowanie wszystkich elementów i zwrócenie wyniku T Stream<T> sorted() - zwraca strumień posortowany (naturalnie). Object[] toArray() - zwraca tablicę na podstawie strumienia IntStream interface posiada dwie metody starycze do generowania zakresu zmiennych: IntStream range(int start, int end) - zbiór [start,end) IntStream rangeClosed(int start, int end) - zbiór [start,end] Stream posiada dwie metody tworzące nieskończone strumienie: <T> Stream<T> iterate(T seed, UnaryOperator<T> f); - tworzy uporządkowany strumień <T> Stream<T> generate(Supplier<T> s); - tworzy nieuporządkowany strumień dla IntStream,LongStream,DoubleStream w zależności od typu danej mamy zamianą zmiennych T na tym prymitywny np: IntStream iterate(int seed, IntUnaryOperator f ); IntStream generate(IntSupplier<T> s); Użycie iterate:
  1. Stream<Long> longStream = Stream.iterate(1L, liczba -> liczba + 1);
aby zakończyć nieskończoną itrację możemy stworzyć limit tworzenia strumienia;
  1. longStream.limit(10);
możemy zacząć od późniejszego elementu używając metody skip(). Wywołując funkcję forEach możemy wpisać otrzymane elementy;
  1. longStream.skip(50).limit(10).forEach(System.out::println);
Użycie generate:
  1. Stream.generate(Math::random).limit(10).forEach(System.out::println);
z pominięciem 5 pierwszych:
  1. Stream.generate(Math::random).skip(5).limit(10).forEach(System.out::println);
Klasa Random zwraca strumienie typów prymitywnych - ints, longs, doubles:
  1. new Random.ints().skip(5).limit(10).forEach(System.out::println);
  1. Stream.generate(new Random()::nextInt).limit(10).forEach(System.out::println);
Pusty stream tworzymy:
  1. Stream<String> stream = Stream.empty();
  2. IntStream intStream = IntStream.empty();
Strumienie działają na kolekcjach ale również na tablicach:
  1. IntStream intStream =Arrays.stream(new int[]{1,2,3,4,5});
  2. Stream<String> strStream = Arrays.stream({"Mateusz","Michal","Magdalena","Basia","Nataila"});
Lub przez metodę Stream.of:
  1. IntStream intStream = Stream.of(new int[]{1,2,3,4,5});
  2. Stream<String> strStream = Stream.of({"Mateusz","Michal","Magdalena","Basia","Nataila"});
Streamy można również używać na plikach:
  1. try (Stream<String> stream = Files.lines(Paths.get("plikTestowy.txt"))) {
  2.         stream.forEach(System.out::println);
  3. } catch (IOException e) {
  4.         e.printStackTrace();
  5. }
Klasa String odziedziczyła po CharSequence metodę chars która tworzy strumień IntStream:
  1. String str = "5 osób miało po 3 zł o 6 godzinie";
  2. str.chars().filter(litera -> !Character.isDigit((char)litera) && !Character.isWhitespace((char)litera))))
  3.            .forEach(litera -> System.out.println((char)litera));
Split może podzielić String na Stream po wybranym wyrażeniu regularnym:
  1. Pattern.compile(" ")
  2. .splitAsStream(str)
  3. .forEach(System.out::println);
Zobaczmy na przykład
  1. Stream.of(Arrays.asList(1, 2), Arrays.asList(3, 4))
  2.                 .map(List::stream)
  3.                 .forEach( n -> System.out.println(n));
Zawóci to nam pomimo tego nie zwróci nam elementów kolekcji tylko: java.util.stream.ReferencePipeline$Head@6ce253f1 java.util.stream.ReferencePipeline$Head@53d8d10a w takim wypadku chcemy użyć flatMap, co spowoduje że wszystkie elementy wprowadzone zostaną do jednego strumienia Ponieważ nie jest tym razem zwrócony kolejny strumień tylko elementy możemy również ponownie użyć funkcji map do działania na elementach:
  1. Stream.of(Arrays.asList(1, 2), Arrays.asList(3, 4))
  2.                 .flatMap(List::stream)
  3.                 .map( n -> n + 2)
  4.                 .forEach( n -> System.out.print(n));  // wypiasane zostanie: 3456
kolejny przykład:
  1. System.out.print(Stream.of("Mateusz", "Michal", "Magdalena", "Basia", "Nataila")
  2.                 .flatMap(name -> IntStream.range(0, name.length())
  3.                 .mapToObj(name::charAt))
  4.                 .filter(ch -> ch == 'a' || ch == 'A')
  5.                 .count()
  6.         );  // wypisana zostanie liczba 10
Przykład jak generować nową listę:
  1. List<Integer> kolekcja = Stream.of(asList(1, 2), asList(3, 4)) // Stream of List<Integer>
  2.             .flatMap(List::stream)   // map zwróciłoby dwa obiekty stream
  3.             .map(integer -> integer + 1)
  4.             .collect(Collectors.toList());  // obiekty przekazane są do listy
posortowana lista:
  1. List<Integer> kolekcja = Stream.of(asList(1, 2), asList(1, 2, 3, 4)) // Stream of List<Integer>
  2.             .flatMap(List::stream)   // map zwróciłoby dwa obiekty stream
  3.             .map(integer -> integer + 1)
  4.             .sorted()   // sortowanie
  5.             .collect(Collectors.toList());  // obiekty przekazane są do listy
  6. System.out.println(kolekcja); // [2, 2, 3, 3, 4, 5]
albo kolekcję niepowtarzających się elementów Set:
  1. List<Integer> kolekcja = Stream.of(asList(1, 2), asList(1, 2, 3, 4)) // Stream of List<Integer>
  2.             .flatMap(List::stream)   // map zwr�ci�oby dwa obiekty stream
  3.             .map(integer -> integer + 1)
  4.             .collect(Collectors.toSet());  // obiekty przekazane s� do listy
Dla klasy String:
  1. List<String> startM = Stream.of("Mateusz", "Michal", "Magdalena", "Basia", "Nataila")
  2.         .filter(p -> p.startsWith("M"))
  3.         .collect(Collectors.toList());  
  4. System.out.println(startM);  // [Mateusz, Michal, Magdalena]
Kolekcja posortowana bez powtarzania się elemetnów:
  1. SortedSet<String> startM = Stream.of("Mateusz", "Michal", "Magdalena", "Basia", "Nataila")
  2.         .filter(p -> p.startsWith("M"))
  3.         .collect(Collectors.toCollection(TreeSet::new));  
  4. System.out.println(startM);  // [Magdalena, Mateusz, Michal]
Optional został stworzony aby nie wystąpowały nullpointer-y w programach:
  1. Optional<String> opt = Stream.of("Mateusz", "Michal", "Magdalena", "Basia", "Nataila")
  2.         .max((n1, n2) -> n1.compareTo(n2));
  3. if ( opt.isPresent() ) { // sprawdza czy wartość istnieje
  4.         System.out.print("Maksymalna wartość to:" + opt.get());
  5. } else {
  6.         System.out.print("Nie znaleziono wartości");
  7. }
opt.get() - pobiera wartość z Optional-a. Klasa optional posiada trzy metody statyczne do stworzenia obiektu: <T> Optional<T> empty() - tworzy pusty objekt <T> Optional<T> of(T value) - przekazuje wartość do obiektu, jeżeli value = null zgłaszany wyjątek NullPointerException. <T> OptionalT> ofNullable(T value) - przekazuje wartość do obiektu, jeżeli value = null, tworzony jest pusty Optional i inne metody do jego obsługi: T get() - zwraca wartość obiektu Optional T orElse(T defaultValue) - zwraca wartość obiektu Optional, jeżeli jest pusty to defaultValue: Foo x = opt.orElse( new Foo() ); T orElseGet(Supplier<? extends T> defaultSupplier) - zwraca wartość obiektu Optional, jeżeli jest pusty to wyrażenie defaultSupplier: Foo y = opt.orElseGet( Foo::new ); <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X extends Throwable - zwraca wartość obiektu Optional, jeżeli jest pusty to zwraca wybrany wyjątek: Foo y = opt.orElseThrow(Exception::new); Dane statystyczne:
  1. class Produkt {
  2.     private double cena;
  3.     public Produkt(double cena) {
  4.         this.cena = cena;
  5.     }
  6.     public double getCena() {
  7.         return cena;
  8.     }
  9. }
  1. public class StaticClass {
  2.  
  3.     public static void main(String[] args) {
  4.         List<Produkt> produkty = new ArrayList<>();
  5.         produkty.add(new Produkt(15));
  6.         produkty.add(new Produkt(5.5));
  7.         produkty.add(new Produkt(3));
  8.         produkty.add(new Produkt(1));
  9.  
  10.         DoubleSummaryStatistics stats = produkty.stream().collect(
  11.                 Collectors.summarizingDouble(Produkt::getCena));
  12.  
  13.         System.out.println("Liczba elementów:" +  stats.getCount());      // 4
  14.         System.out.println("Średnia:" + stats.getAverage());    // 6.125
  15.         System.out.println("Najwiekszy element:" + stats.getMax());        // 15
  16.         System.out.println("Najmniejszy element:" + stats.getMin());        // 1
  17.         System.out.println("Suma:" + stats.getSum());        // 24.5
  18.     }
  19. }
Do tworzenie map na podstawie metod używamy (java.util.stream.Collectors):
  1. static <T,K,U> Collector<T,?,Map<K,U>> toMap(Function<? super T,? extends K> keyMapper,
  2.                                                                           Function<? super T,? extends U> valueMapper)
  1. class User {
  2.     private int id;
  3.     private String name;
  4.     public User(int id, String name) {
  5.         this.id = id;
  6.         this.name = name;
  7.     }
  8.     public int getId() {
  9.         return id;
  10.     }
  11.     public String getName() {
  12.         return name;
  13.     }
  14. }
  1. public class ObjectToMap {
  2.  
  3.     public static void main(String[] args) {
  4.         List<User> users = new ArrayList<>();
  5.         users.add(new User(1, "Mateusz"));
  6.         users.add(new User(2, "Magdalena"));
  7.         users.add(new User(3, "Mateusz"));
  8.         users.add(new User(4, "Mateusz"));
  9.         users.add(new User(5, "Michal"));
  10.  
  11.         Map<Integer, String> idToNameMap = users
  12.                 .stream()
  13.                 .collect(Collectors.toMap(User::getId, User::getName));
  14.         System.out.println(idToNameMap);
  15.         // {1=Mateusz, 2=Magdalena, 3=Mateusz, 4=Mateusz, 5=Michal}
  16.     }
  17. }
Ale spróbujmy zrobić mapowanie w drugą stronę, gdzie klucz jest dublowany, czyli name jako klucz, id jako wartość:
  1. public class ObjectToMap2 {
  2.  
  3.     public static void main(String[] args) {
  4.         List<User> users = new ArrayList<>();
  5.         users.add(new User(1, "Mateusz"));
  6.         users.add(new User(2, "Magdalena"));
  7.         users.add(new User(3, "Mateusz"));
  8.         users.add(new User(4, "Mateusz"));
  9.         users.add(new User(5, "Michal"));
  10.  
  11.         Map<String, Integer> idToNameMap = users
  12.                 .stream()
  13.                 .collect(Collectors.toMap(User::getName,User::getId));
  14.         System.out.println(idToNameMap);
  15.     }
  16. }
dostajemy wyjątek: Exception in thread "main" java.lang.IllegalStateException: Duplicate key 1 w takim wypadku musimy użyć drugiego wywołania dla tworzenia map, z uwzględnieniem konfliktów:
  1. static <T,K,U> Collector<T,?,Map<K,U>> toMap(Function<? super T,? extends K> keyMapper,
  2.                                              Function<? super T,? extends U> valueMapper,
  3.                                              BinaryOperator<U> mergeFunction)
w naszym przykładzie zamienimy id na String aby pokazać jak kleić wartości:
  1. class User {
  2.     private String id;
  3.     private String name;
  4.     public User(String id, String name) {
  5.         this.id = id;
  6.         this.name = name;
  7.     }
  8.     public String getId() {
  9.         return id;
  10.     }
  11.     public String getName() {
  12.         return name;
  13.     }
  14. }
  1. public class JavaApplicationTest {
  2.  
  3.     public static void main(String[] args) {
  4.         List<User> users = new ArrayList<>();
  5.         users.add(new User("1", "Mateusz"));
  6.         users.add(new User("2", "Magdalena"));
  7.         users.add(new User("3", "Mateusz"));
  8.         users.add(new User("4", "Mateusz"));
  9.         users.add(new User("5", "Michal"));
  10.  
  11.         Map<String, String> idToNameMap = users
  12.                 .stream()
  13.                 .collect(Collectors.toMap(User::getName,User::getId, (oldValue,newValue) -> String.join(", ", oldValue, newValue)));
  14.         System.out.println(idToNameMap);
  15.         //{Michal=5, Magdalena=2, Mateusz=1, 3, 4}
  16.     }
  17. }
Wyrażenie (oldValue,newValue) -> String.join(", ", oldValue, newValue) jest wywołane tylko gdy są te same klucze. Dla pierwzszego konfliktu dla klucza Mateusz wartość w mapie jest "1" (oldValue) i wartość z którą jest konflikt to 3. Zrobiony jest z tego join oddzielony przecinkiem. Czyli "1, 3" i to jest teraz przechowywane w mapie. Dla kolejnego konfliktu klucza "Mateusz" w mapie przechowywane jest "1, 3" (oldValue) i "4" jako (newValue), połączone to jest w jedną wartość "1, 3, 4". Możemy użyć mapowania do liczenia elementów powtarzających się:
  1. public class JavaApplicationTest {
  2.  
  3.     public static void main(String[] args) {
  4.         List<User> users = new ArrayList<>();
  5.         users.add(new User("1", "Mateusz"));
  6.         users.add(new User("2", "Magdalena"));
  7.         users.add(new User("3", "Mateusz"));
  8.         users.add(new User("4", "Mateusz"));
  9.         users.add(new User("5", "Michal"));
  10.  
  11.         Map<String, Integer> idToNameMap = users
  12.                 .stream()
  13.                 .collect(Collectors.toMap(User::getName, (count) -> 1, (oldValue,newValue) -> ++oldValue));
  14.         System.out.println(idToNameMap);
  15.         // {Michal=1, Magdalena=1, Mateusz=3}
  16.     }
  17. }
Collectors.joining służy do zwracania z kolekcji jednego stringa połączonego w wartości: joining(): połączone jeden String do drugiego:
  1. public class JavaApplicationTest {
  2.  
  3.     public static void main(String[] args) {
  4.         List<User> users = new ArrayList<>();
  5.         users.add(new User("1", "Mateusz"));
  6.         users.add(new User("2", "Magdalena"));
  7.         users.add(new User("3", "Mateusz"));
  8.         users.add(new User("4", "Mateusz"));
  9.         users.add(new User("5", "Michal"));
  10.  
  11.         String nameToString = users
  12.                 .stream()
  13.                 .map(User::getName)
  14.                 .collect(Collectors.joining());
  15.         System.out.println(nameToString);
  16.         // MateuszMagdalenaMateuszMateuszMichal
  17.     }
  18. }
joining(CharSequence delimiter): połączony jeden String do drugiego rozdzielony seperatorem:
  1. public class JavaApplicationTest {
  2.  
  3.     public static void main(String[] args) {
  4.         List<User> users = new ArrayList<>();
  5.         users.add(new User("1", "Mateusz"));
  6.         users.add(new User("2", "Magdalena"));
  7.         users.add(new User("3", "Mateusz"));
  8.         users.add(new User("4", "Mateusz"));
  9.         users.add(new User("5", "Michal"));
  10.  
  11.         String nameToString = users
  12.                 .stream()
  13.                 .map(User::getName)
  14.                 .collect(Collectors.joining(", "));
  15.         System.out.println(nameToString);
  16.         // Mateusz, Magdalena, Mateusz, Mateusz, Michal
  17.     }
  18. }
joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix) połaczony jeden String do drugiego rozdzielony seperatorem, zaczęty prefix i zakończony suffix:
  1. public class JavaApplicationTest {
  2.  
  3.     public static void main(String[] args) {
  4.         List<User> users = new ArrayList<>();
  5.         users.add(new User("1", "Mateusz"));
  6.         users.add(new User("2", "Magdalena"));
  7.         users.add(new User("3", "Mateusz"));
  8.         users.add(new User("4", "Mateusz"));
  9.         users.add(new User("5", "Michal"));
  10.  
  11.         String nameToString = users
  12.                 .stream()
  13.                 .map(User::getName)
  14.                 .collect(Collectors.joining(", ", "Start:",":Koniec"));
  15.         System.out.println(nameToString);
  16.         // Start:Mateusz, Magdalena, Mateusz, Mateusz, Michal:Koniec
  17.     }
  18. }
Wyrażenie Collectors.groupingBy:
  1. class Produkt {
  2.     private String name;
  3.     private double cena;
  4.     public Produkt(String name, double cena) {
  5.         this.name = name;
  6.         this.cena = cena;
  7.     }
  8.     public String getName() {
  9.         return name;
  10.     }
  11.     public double getCena() {
  12.         return cena;
  13.     }
  14.     @Override
  15.     public String toString() {
  16.         return name + "(" + cena + ")";
  17.     }
  18. }
  1. public class JavaApplicationTest {
  2.  
  3.     public static void main(String[] args) {
  4.         List<Produkt> produkty = new ArrayList<>();
  5.         produkty.add(new Produkt("Banan",3.99));
  6.         produkty.add(new Produkt("Jablko",1.99));
  7.         produkty.add(new Produkt("Winogrona",4.99));
  8.         produkty.add(new Produkt("Banan",3.99));
  9.         produkty.add(new Produkt("Jablko",1.99));
  10.         produkty.add(new Produkt("Banan",3.99));
  11.  
  12.         Map<String, List<Produkt>> groupByNameMap
  13.                 = produkty.stream().collect(Collectors.groupingBy(Produkt::getName));
  14.  
  15.         System.out.println(groupByNameMap);
  16.         //{Winogrona=[Winogrona(4.99)],
  17.         //Banan=[Banan(3.99), Banan(3.99), Banan(3.99)],
  18.         //Jablko=[Jablko(1.99), Jablko(1.99)]}      
  19.  
  20.         Map<String, Long> result =
  21.                 produkty.stream().collect(
  22.                         Collectors.groupingBy(
  23.                                 Produkt::getName, Collectors.counting()
  24.                         )
  25.                 );
  26.  
  27.         System.out.println(result);
  28.         //{Winogrona=1, Banan=3, Jablko=2}
  29.  
  30.         Map<String, Double> sum = produkty.stream().collect(
  31.                 Collectors.groupingBy(Produkt::getName, Collectors.summingDouble(Produkt::getCena)));
  32.  
  33.         System.out.println(sum);
  34.         // {Winogrona=4.99, Banan=11.97, Jablko=3.98}
  35.  
  36.         Map<Double, Set<String>> resultSet
  37.                 = produkty.stream().collect(
  38.                         Collectors.groupingBy(Produkt::getCena,
  39.                                 Collectors.mapping(Produkt::getName, Collectors.toSet())
  40.                         )
  41.                 );
  42.  
  43.         System.out.println(resultSet);
  44.         // {1.99=[Jablko], 4.99=[Winogrona], 3.99=[Banan]}
  45.    }
  46. }
collect(Collectors.groupingBy(Produkt::getName)) - grupuje po Produkt::getName, dodaje do listy ten same obiekt czyli Produkt. Collectors.groupingBy(Produkt::getName, Collectors.counting()); - wylicza wystąpienia tego samego Produkt::getName. Collectors.groupingBy(Produkt::getName, Collectors.summingDouble(Produkt::getCena)) - sumuje te same Produkt::getName Collectors.groupingBy(Produkt::getCena, Collectors.mapping(Produkt::getName, Collectors.toSet()) - grupowanie po cenie, nie powtarza się nazwa, ale gdybyśmy dodali produkty.add(new Produkt("Arbuz", 3.99)); to byłoby: {1.99=[Jablko], 4.99=[Winogrona], 3.99=[Banan, Arbuz]} Mapowanie na true i false używając Collectors.partitioningBy:
  1. static <T> Collector<T,?,Map<Boolean,List<T>>> partitioningBy(Predicate<? super T> predicate)
wybierając warunek logiczny określamy jakie elementy trafią do tablicy false i true:
  1. public class JavaApplicationTest {
  2.  
  3.     public static void main(String[] args) {
  4.         List<Produkt> produkty = new ArrayList<>();
  5.         produkty.add(new Produkt("Banan", 3.99));
  6.         produkty.add(new Produkt("Jablko", 1.99));
  7.         produkty.add(new Produkt("Winogrona", 4.99));
  8.         produkty.add(new Produkt("Banan", 3.99));
  9.         produkty.add(new Produkt("Jablko", 1.99));
  10.         produkty.add(new Produkt("Arbuz", 3.99));
  11.  
  12.        
  13.         Map<Boolean, List<Produkt>> wiecejNiz2 = produkty.stream()
  14.                     .collect(Collectors.partitioningBy(s -> s.getCena() > 2));
  15.         System.out.println(wiecejNiz2);
  16.         //{false=[Jablko(1.99), Jablko(1.99)],
  17.         //true=[Banan(3.99), Winogrona(4.99), Banan(3.99), Arbuz(3.99)]}
  18.     }
  19. }
kolejne wyrażenie może nam rzutować dane pole np na jedną nazwę używając łączenia String-u.
  1. static <T,D,A> Collector<T,?,Map<Boolean,D>>
  2. partitioningBy(Predicate<? super T> predicate, Collector<?
  3. super T,A,D> downstream)
  1. public class JavaApplicationTest {
  2.  
  3.     public static void main(String[] args) {
  4.         List<Produkt> produkty = new ArrayList<>();
  5.         produkty.add(new Produkt("Banan", 3.99));
  6.         produkty.add(new Produkt("Jablko", 1.99));
  7.         produkty.add(new Produkt("Winogrona", 4.99));
  8.         produkty.add(new Produkt("Banan", 3.99));
  9.         produkty.add(new Produkt("Jablko", 1.99));
  10.         produkty.add(new Produkt("Arbuz", 3.99));
  11.  
  12.        
  13.         Map<Boolean, String> wiecejNiz2Name = produkty.stream()
  14.                     .collect(Collectors.partitioningBy(s -> s.getCena() > 2,
  15.                             Collectors.mapping(Produkt::getName, Collectors.joining(", "))));
  16.         System.out.println(wiecejNiz2Name);
  17.         //{false=Jablko, Jablko, true=Banan, Winogrona, Banan, Arbuz}
  18.     }
  19. }
collectingAndThen wykonuje dodatkową zmianą stream-u i zwraca wartość.
  1. public class JavaApplicationTest {
  2.  
  3.     public static void main(String[] args) {
  4.         List<Produkt> produkty = new ArrayList<>();
  5.         produkty.add(new Produkt("Banan", 3.99));
  6.         produkty.add(new Produkt("Jablko", 1.99));
  7.         produkty.add(new Produkt("Winogrona", 4.99));
  8.         produkty.add(new Produkt("Banan", 3.99));
  9.         produkty.add(new Produkt("Jablko", 1.99));
  10.         produkty.add(new Produkt("Arbuz", 3.99));
  11.  
  12.         String najdrozsze = produkty.stream().collect(
  13.                 Collectors.collectingAndThen(
  14.                         Collectors.maxBy(Comparator.comparing(Produkt::getCena)),
  15.                         (Optional<Produkt> emp) ->
  16.                                 emp.isPresent() ? emp.get().getName() + "(" + emp.get().getCena() + ")"  
  17.                                         : "none"));
  18.  
  19.         System.out.println("Najdroższy produkt to: " + najdrozsze); //Winogrona(4.99)
  20.     }
  21. }
Stream API udostępnia kilka operacji znajdowania i dopasowania elementów. boolean allMatch(Predicate<? super T> predicate) - true jeśli wszystko pasuje boolean anyMatch(Predicate<? super T> predicate) - tru jeśli co najmniej jeden pasuje boolean noneMatch(Predicate<? super T> predicate) - true jeśli żaden nie pasuje Optional<T> findAny() - zwraca jakikowiek element ze strumienia Optional<T> findFirst() - zwraca pierwszy element ze strumienia
  1. public class JavaApplicationTest {
  2.  
  3.     public static void main(String[] args) {
  4.         List<Produkt> produkty = new ArrayList<>();
  5.         produkty.add(new Produkt("Banan", 3.99));
  6.         produkty.add(new Produkt("Jablko", 1.99));
  7.         produkty.add(new Produkt("Winogrona", 4.99));
  8.         produkty.add(new Produkt("Banan", 3.99));
  9.         produkty.add(new Produkt("Jablko", 1.99));
  10.         produkty.add(new Produkt("Arbuz", 3.99));
  11.  
  12.         boolean cenaPonizej4 = produkty.stream()
  13.                 .allMatch((p) -> p.getCena() < 4);
  14.         System.out.println("Ceny poniżej 4zł: " + cenaPonizej4); // false
  15.        
  16.         boolean cenaPonizej6 = produkty.stream()
  17.                 .allMatch((p) -> p.getCena() < 6);
  18.         System.out.println("Ceny poniżej 6zł: " + cenaPonizej6);   // true
  19.  
  20.         boolean cenaPonizej2
  21.                 = produkty.stream()
  22.                         .anyMatch((p) -> p.getCena() < 2);
  23.         System.out.println("Istnieje cena ponizej 2:" +  cenaPonizej2); // true
  24.  
  25.         boolean cenaPonizej1
  26.                 = produkty.stream()
  27.                         .noneMatch((p) -> p.getCena() < 1);
  28.         System.out.println("Nie istnieje cena ponizej 1:" +  cenaPonizej1); // true
  29.  
  30.         Optional<Produkt> cenaPonizej2Opt = produkty.stream()
  31.                 .filter((p) -> p.getCena() < 2)
  32.                 .findAny();
  33.         if (cenaPonizej2Opt.isPresent()) {
  34.             System.out.println("Cena ponizej 2 to: " + cenaPonizej2Opt.get()); // Jablko(1.99)
  35.         } else {
  36.             System.out.println("Nie ma ceny ponizej 2");
  37.         }
  38.  
  39.         Optional<Produkt> cenaPonizej2Optfirst = produkty.stream()
  40.                 .filter((p) -> p.getCena() < 2)
  41.                 .findFirst();
  42.         if (cenaPonizej2Optfirst.isPresent()) {
  43.             System.out.println("Cena ponizej 2 to: " + cenaPonizej2Optfirst.get()); //Jablko(1.99)
  44.         } else {
  45.             System.out.println("Nie ma ceny ponizej 2");
  46.         }
  47.     }
  48.  
  49. }
created by freelancer.java.org.pl © 2020