List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
// 過(guò)濾、映射、收集
List<Integer> result = list.stream()
    .filter(x -> x > 3)
    .map(x -> x * 2)
    .collect(Collectors.toList()); // [8, 10, 12]
// 分組
Map<Boolean, List<Integer>> partitioned = list.stream()
    .collect(Collectors.partitioningBy(x -> x % 2 == 0)); 
// 計(jì)數(shù)
long count = list.stream().filter(x -> x > 3).count();
// 求和
int sum = list.stream().reduce(0, Integer::sum);

Map<String, Map<Integer, List<User>>> multiGroup = users.stream()
    .collect(Collectors.groupingBy(
        User::getCity,
        Collectors.groupingBy(User::getAge)
    ));

Map<Boolean, List<Integer>> partition = list.stream()
    .collect(Collectors.partitioningBy(x -> x > 3));

Collector<Integer, ?, Set<Integer>> toCustomSet = Collector.of(
    HashSet::new,
    Set::add,
    (left, right) -> { left.addAll(right); return left; }
);
Set<Integer> set = list.stream().collect(toCustomSet);

list.parallelStream()
    .filter(x -> x > 3)
    .forEach(System.out::println);

Optional<Integer> first = list.stream().filter(x -> x > 3).findFirst();
first.ifPresent(System.out::println);

default Stream<T> filter(Predicate<? super T> predicate) {
    Objects.requireNonNull(predicate);
    return new ReferencePipeline.StatelessOp<>(this, StreamShape.REFERENCE, StreamOpFlag.NOT_SORTED) {
        @Override
        Sink<T> opWrapSink(int flags, Sink<T> sink) {
            return new Sink.ChainedReference<T, T>(sink) {
                @Override
                public void accept(T t) {
                    if (predicate.test(t)) downstream.accept(t);
                }
            };
        }
    };
}

default <R> Stream<R> map(Function<? super T, ? extends R> mapper) {
    Objects.requireNonNull(mapper);
    return new ReferencePipeline.StatelessOp<>(this, StreamShape.REFERENCE, StreamOpFlag.NOT_SORTED) {
        @Override
        Sink<T> opWrapSink(int flags, Sink<R> sink) {
            return new Sink.ChainedReference<T, R>(sink) {
                @Override
                public void accept(T t) {
                    downstream.accept(mapper.apply(t));
                }
            };
        }
    };
}

List<String> sorted = list.stream()
    .distinct()
    .sorted()
    .collect(Collectors.toList());

Map<String, Optional<User>> maxAgeByCity = users.stream()
    .collect(Collectors.groupingBy(
        User::getCity,
        Collectors.maxBy(Comparator.comparingInt(User::getAge))
    ));

Map<String, Map<Integer, Long>> groupCount = users.stream()
    .collect(Collectors.groupingBy(
        User::getCity,
        Collectors.groupingBy(User::getAge, Collectors.counting())
    ));

List<String> names = users.stream()
    .map(User::getName)
    .collect(Collectors.toList());

Map<String, Integer> map = ...;
List<String> keys = map.entrySet().stream()
    .filter(e -> e.getValue() > 5)
    .map(Map.Entry::getKey)
    .collect(Collectors.toList());

IntStream intStream = IntStream.of(1, 2, 3, 4);
LongStream longStream = LongStream.range(1, 10); // [1,9]
DoubleStream doubleStream = DoubleStream.generate(Math::random).limit(5);

// value 相加
Map<String, Integer> map = list.stream()
    .collect(Collectors.toMap(
        User::getName,
        User::getScore,
        Integer::sum // 合并函數(shù)
    ));

List<String> unmodifiableList = list.stream()
    .collect(Collectors.collectingAndThen(
        Collectors.toList(),
        Collections::unmodifiableList
    ));

Map<String, Map<Integer, List<User>>> group = users.stream()
    .collect(Collectors.groupingBy(
        User::getCity,
        Collectors.groupingBy(User::getAge)
    ));

ConcurrentMap<String, Integer> concurrentMap = list.parallelStream()
    .collect(Collectors.toConcurrentMap(User::getName, User::getScore));

list.stream()
    .sorted(Comparator.comparing(User::getAge))
    .collect(Collectors.toList());

list.stream()
    .sorted(Comparator.comparing(User::getAge)
        .thenComparing(User::getName))
    .collect(Collectors.toList());

list.stream()
    .sorted(Comparator.comparing(User::getAge).reversed())
    .collect(Collectors.toList());

Set<Integer> seen = new HashSet<>();
Set<Integer> duplicates = list.stream()
    .filter(n -> !seen.add(n))
    .collect(Collectors.toSet());

int page = 2, size = 5;
List<Integer> pageList = list.stream()
    .skip((page - 1) * size)
    .limit(size)
    .collect(Collectors.toList());

long count = list.stream().filter(x -> x > 10).count();

List<Integer> merged = Stream.concat(list1.stream(), list2.stream())
    .distinct()
    .collect(Collectors.toList());

Stream<String> s = list.stream();
s.forEach(System.out::println);
// s.forEach(...) // 拋異常，不可再用

List<String> safeList = Optional.ofNullable(list)
    .orElse(Collections.emptyList());
safeList.stream()...

Map<String, List<String>> nameGroup = users.stream()
    .collect(Collectors.groupingBy(
        User::getCity,
        Collectors.mapping(User::getName, Collectors.toList())
    ));

int totalScore = users.stream()
    .collect(Collectors.reducing(0, User::getScore, Integer::sum));

List<List<Integer>> nested = Arrays.asList(
    Arrays.asList(1,2),
    Arrays.asList(3,4)
);
List<Integer> flat = nested.stream()
    .flatMap(Collection::stream)
    .collect(Collectors.toList());

Stream.ofNullable(null).count(); // 0
Stream.ofNullable("abc").count(); // 1