Core Java. Лекция 9

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

//Создание стрима
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);

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

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

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

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)

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
  */

//Внутренний 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);

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

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

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

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

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

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

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

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

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

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

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


/*"Терминальные"*/
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)

/*С возможностью продолжить цепочку*/
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)

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

//Создание
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<Insurance> optInsurance = Optional.ofNullable(insurance);
Optional<String> name = optInsurance.map(Insurance::getName);

Optional<Person> person = ...

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

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

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

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

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

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

stream.sorted(comparator).findFirst()

stream.collect(Collectors.counting())

collection.stream().count()

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

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

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)

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

if(stream.count() > 2)