Core Java. Лекция 9

Streams

Преобразуем поток в поток

blockStream squashedStream

List<Block> blocks = ...; Stream<Block> blocksStream = blocks.stream(); Stream<SquashedBlock> squashedStream = blocksStream.map(Block::squash); (Автор анимаций — Тагир Валеев, движущиеся картинки см. здесь)

Фильтруем

squashedStream filteredStream

Stream<SquashedBlock> filteredStream = squashedStream.filter(block ‑> block.getColor() != YELLOW);

Отображаем в консоль (терминальная операция)

filteredStream

filteredStream .forEach(System.out::println);

Всё вместе в одну строку

blocks.stream() .map(Block::squash) .filter(block ‑> block.getColor() != YELLOW) .forEach(System.out::println);

Ничего не напоминает?

cat file1 file2 | tr "[A-Z]" "[a-z]" | sort | tail -3

Зачем это нужно?

Map<Currency, List<Transaction>>
 transactionsByCurrencies = new HashMap<>();

for (Transaction transaction : transactions) {
 Currency currency =transaction.getCurrency();
 List<Transaction> transactionsForCurrency =
   transactionsByCurrencies.get(currency);
 if (transactionsForCurrency == null) {
  transactionsForCurrency = new ArrayList<>();
    transactionsByCurrencies.put(currency,
           transactionsForCurrency);
 }
 transactionsForCurrency.add(transaction);
}

Map<Currency,
 List<Transaction>>
 transactionsByCurr =
   transactions
   .stream()
   .collect(
     Collectors
     .groupingBy(
   Transaction
   ::getCurrency));

Три категории методов Stream API

//Создание стрима
List<String> names = menu.stream()

//Промежуточные операции
  .filter(d -> d.getCalories() > 300
  .map(Dish::getName)
  .limit(3)

//Терминальная операция
  .collect(Collectors.toList());

Создание стрима

//Пустого
Stream<Foo> stream0 = Stream.empty();

//Перечислением элементов
Stream<String> stream1 =
         Stream.of("gently", "down", "the", "stream");
//Из массива
Stream<String> stream2 =
         Arrays.stream("gently down the stream".split(" "));
//Из коллекции
List<String> strings = ...
Stream<String> stream3 = strings.stream();

//Из API
Path path = Paths.get(...);
Stream<Path> stream4 = Files.list(path);

Конкатенация стримов

Stream<Foo> s1 = ...;
Stream<Foo> s2 = ...;
Stream<Foo> s = Stream.concat(s1, s2);

Порождение стримов (generate)

//С помощью генератора
Stream<Double> randoms =
    Stream.generate(Math::random);

          //ХОТЯ ЛУЧШЕ
          DoubleStream doubles =
            ThreadLocalRandom.current().doubles()

Порождение стримов (iterate)

//Итеративно
Stream<Integer> integers =
    Stream.iterate(0, x -> x + 1);

          //ХОТЯ ЛУЧШЕ
          IntStream range = IntStream.range(0, 1000);

Что будет в этом стриме?

    Stream.iterate(new int[]{0, 1},
                   t -> new int[]{t[1], t[0] + t[1]})
    .mapToInt(t -> t[0]);

Spliterator: самый общий способ создания стрима

public interface Spliterator<T> {
  boolean tryAdvance(Consumer<? super T> action);
  Spliterator<T> trySplit();
  long estimateSize();
  int characteristics();
}

StreamSupport.stream(Spliterator<T> spliterator, boolean parallel)

Ветвление сплитераторов

Ветвление сплитераторов

Характеристики сплитератора

Промежуточные итоги

Преобразования стримов в стримы: получение «головы» и «хвоста»

//методы интерфейса Stream

//голова
Stream<T> limit(long maxSize)
Stream<T> takeWhile(Predicate<? super T> predicate)

//хвост
Stream<T> skip(long n)
Stream<T> dropWhile(Predicate<? super T> predicate)

filter

Stream<T> filter( Predicate<? super T> predicate);

map

<R> Stream<R> map(Function<? super T, ? extends R> mapper); IntStream mapToInt( ToIntFunction<? super T> mapper); LongStream mapToLong( ToLongFunction<? super T> mapper); DoubleStream mapToDouble( ToDoubleFunction<? super T> mapper);

flatMap

Path path = ...
Pattern separator = Pattern.compile("\\s");
try(Stream<String> lines = Files.lines(path, StandardCharsets.UTF_8)) {
    //НЕ ТО, что нам надо!
    //Stream<Stream<String>> streamStream =
    //                  lines.map(separator::splitAsStream);

    //ТО, что нам надо!
    Stream<String> words = lines.flatMap(separator::splitAsStream);
    words.forEach(System.out::println);
}

/*А также:
  flatMapToDouble
  flatMapToInt
  flatMapToLong
  */

distinct

//Внутренний Set

Stream.of(1, 5, 8, 7, 8, 5, 9, 9)
    .distinct()
    .forEach(System.out::println);

//Выведет 1, 5, 8, 7, 9

Что произойдёт при выполнении такого кода?

ThreadLocalRandom.current().ints(1, 10)
  .distinct()
  .forEach(System.out::println);

sorted

//Внутренний отсортированный список

Stream.of(1, 5, 8, 7, 8, 5, 9, 9)
    .sorted()
    .forEach(System.out::println);

//Выведет 1, 5, 5, 7, 8, 8, 9, 9

//Не имеет смысла для бесконечных стримов

peek — отладочный метод

Stream<T> peek(Consumer<? super T> action);

Терминальные операции

//Предъяви первый элемент
Optional<T> findFirst();
//Предъяви любой элемент
Optional<T> findAny();

//Проверь, удовлетворяет ли условию...
//...какой-то
boolean anyMatch(Predicate<? super T> predicate);
//...все
boolean allMatch(Predicate<? super T> predicate);
//...никакой
boolean noneMatch(Predicate<? super T> predicate);

//КОРОТКИЕ ЗАМЫКАНИЯ!

forEach

void forEach(Consumer<? super T> action);

reduce (with identity)

Ассоциативная функция + "identity value" Промежуточные результаты — immutable values Вопрос: назовите примеры ассоциативных операций в математике? T reduce(T identity, BinaryOperator<T> accumulator);

Parallel reduce

reduce без identity

identity не нужно, но и результата может не получиться (если стрим пустой) Optional<T> reduce( BinaryOperator<T> accumulator);

Готовые редьюсы

collect: самый гибкий метод сборки результатов

<R, A> R collect(Collector<? super T, A, R> collector);

Интерфейс Collector<T, A, R>

public interface Collector<T, A, R> {
  Supplier<A> supplier();
  BiConsumer<A, T> accumulator();
  Function<A, R> finisher();
  BinaryOperator<A> combiner();
  Set<Characteristics> characteristics();
}

//например:
class ToListCollector<T> implements
   Collector<T, List<T>, List<T>>

Характеристики коллектора

Промежуточные выводы

Наиболее употребимые коллекторы

//java.util.stream.Collectors
Collector<T, ?, List<T>> toList()
Collector<T, ?, Set<T>> toSet()
Collector<T, ?, C extends Collection<T>>
  toCollection(Supplier<C> collectionFactory)

//Пример применения
Stream<Foo> myStream = ...
List<Foo> list = myStream.collect(Collectors.toList());

Собирание в мапы

Collector<T, ?, Map<K,U>> toMap(
  Function<? super T, ? extends K> keyMapper,
  Function<? super T, ? extends U> valueMapper)

//Пример применения
Stream<Person> people = ...
Map<Integer, Person> idToPerson = people.collect(
  Collectors.toMap(Person::getId, p->p);

Вариации на тему сборки в коллекции

Строка с разделителями

static Collector<CharSequence, ?, String> joining()

//Пример использования
menuStream.map(Dish::getName).collect(Collectors.joining(", ");

//Не забываем про то, что это же можно сделать и без стримов:
static String join(CharSequence delimiter,
            Iterable<? extends CharSequence> elements)

Группировки

Map<Dish.Type, List<Dish>> dishesByType =
  menu.stream().collect(Collectors.groupingBy(Dish::getType));

Downstream Collectors

Map<Dish.Type, Map<Dish.CaloricLevel, List<Dish>>>
  dishesByTypeAndCaloricLevel =
    menu.stream().collect(Collectors
      .groupingBy(Dish::getType,
         Collectors.groupingBy(Dish::getCaloricLevel)));

Но мы можем не только группировать в цепочке!

Map<Dish.Type, Long> typesCount =
  menu.stream().collect(Collectors
    .groupingBy(Dish::getType, Collectors.counting()));

Набор downstream collectors

/*Всё это уже есть в стримах, но нам надо применить это
к "разветвлённому" стриму.*/


/*"Терминальные"*/
counting()
summingInt(ToIntFunction<? super T> mapper)
summingLong(ToLongFunction<? super T> mapper)
summingDouble(ToDoubleFunction<? super T> mapper)
maxBy(Comparator<? super T> comparator)
minBy(Comparator<? super T> comparator)

Downstream collectors—​продолжение

/*С возможностью продолжить цепочку*/
filtering(Predicate<? super T> predicate, downstream)
mapping(Function<? super T, ? extends U> mapper, downstream)
flatMapping(Function<? super T,
  ? extends Stream<? extends U>> mapper, downstream)

/*Адаптор*/
collectingAndThen(Collector<T,A,R> downstream,
  Function<R,RR> finisher)

Когда может быть нужен collectingAndThen?

Map<Dish.Type, Dish> mostCaloricByType =
  menu.stream()
     .collect(Collectors.groupingBy(Dish::getType,
       collectingAndThen( //<-----АДАПТОР
         Collectors.maxBy(Comparator
                   .comparingInt(Dish::getCalories),
         //maxBy возвращает Optional
       Optional::get)));

Параллельные стримы

Optional: Контейнер, который содержит объект. Или не содержит.

Optional<T> — как стрим из 0 или 1 элемента

//Создание
Optional.empty(); //пустой
Optional.of(x); //NPE если x == null
Optional.ofNullable(x); //пустой или с x-ом

//Расчехление
o.get();
o.orElse(other);
o.orElseGet(()->calcOther());
o.orElseThrow(()->new IllegalStateException());

Optional.map

Optional<Insurance> optInsurance = Optional.ofNullable(insurance);
Optional<String> name = optInsurance.map(Insurance::getName);

Optional.flatMap

Optional<Person> person = ...

//person.map(Person::getCar) вернёт Optional<Optional<Car>>!!

String insuranceName = person.flatMap(Person::getCar)
                             .flatMap(Car::getInsurance)
                             .map(Insurance::getName)
                             .orElse("Unknown");

Optional.filter

String insuranceName = person.filter(p -> p.getAge() >= minAge)
                             .flatMap(Person::getCar)
                             .flatMap(Car::getInsurance)
                             .map(Insurance::getName)
                             .orElse("Unknown");

Правила использования Optional

if (o.isPresent())
  o.get().someMethod();

if (o != null)
  o.someMethod();

Правила использования Optional

Когда стримы использовать не нужно

Что не так?

collection.stream().forEach(...)

Что не так?

collection.stream().collect(Collectors.toList())
collection.stream().collect(Collectors.toSet())

/*так эффективнее*/
new ArrayList<>(collection)
new HashSet<>(collection)

Что не так?

collection.stream().max(Comparator.naturalOrder()).get()

/*То же самое, с меньшим количеством мусора*/
Collections.max(collection)

Что хотел сказать автор?

stream.sorted(comparator).findFirst()

stream.min(comparator)

Как улучшить?

stream.collect(Collectors.counting())

/*Коллекторы counting(), maxBy(), minBy(), reducing(), mapping(), ...
нужны лишь как вторичные в каскадных операциях groupingBy*/
stream.count()

Что не так?!

collection.stream().count()

/*Без пересчёта элементов один за другим!*/
collection.size()

Как улучшить?

listOfLists.stream().flatMap(List::stream).count()

/*Число элементов каждого подсписка известно!*/
listOfLists.stream().mapToInt(List::size).sum()

Как улучшить?

stream.filter(condition).findFirst().isPresent()

/*Зачем сам элемент, если надо лишь проверить наличие?*/
stream.anyMatch(condition)

Как улучшить?

stream.filter(condition).anyMatch(x -> true)
stream.map(condition).anyMatch(b -> b)
stream.map(condition).anyMatch(Boolean::booleanValue)
stream.map(condition).anyMatch(Boolean.TRUE::equals)

/*Замысловатые вариации на простую тему*/
stream.anyMatch(condition)

Как улучшить?!

if(stream.filter(condition).count() > 0)

/*В этом примере ещё хуже, чем в предыдущих,
т. к. обходится весь стрим целиком! А решение то же:*/
if(stream.anyMatch(condition))

Как улучшить?!

if(stream.count() > 2)

/*Нам ведь неважно, сколько их, если их больше двух?*/
stream.limit(3).count()

Выводы