public interface Stream<T> extends BaseStream<T, Stream<T>> 

public interface BaseStream<T, S extends BaseStream<T, S>> extends AutoCloseable

// demo 用法：计算红色的权重和
int sum = widgets.stream().filter(w -> w.getColor() == RED).mapToInt(w -> w.getWeight()).sum();

Iterator<T> iterator(); // 流迭代器
Spliterator<T> spliterator(); // 流拆分器
boolean isParallel(); // 如果要执行终端操作，则返回此流是否并行执行
S sequential(); // 返回一个顺序流。 如果流已经是顺序的，返回自身
S parallel(); // 返回一个并行流。 如果流已经是并行的，返回自身
S unordered(); // 返回一个无序流。 如果流已经是无序的，返回自身
S onClose(Runnable closeHandler); // 返回具有附加关闭处理程序的等效流。 关闭处理程序在流上调用 close 方法时运行，并按添加顺序执行。
void close(); // 继承AutoCloseable接口，override方法

int longestStringLengthStartingWithA
        = strings.stream()
              .filter(s -> s.startsWith("A"))
              .mapToInt(String::length)
              .max();

int longest = 0;
for(String str : strings){
    if(str.startsWith("A")){// 1. filter(), 保留以A开头的字符串
        int len = str.length();// 2. mapToInt(), 转换成长度
        longest = Math.max(len, longest);// 3. max(), 保留最长的长度
    }
}

void accept(U u){
    1. 使用当前Sink包装的回调函数处理u
    2. 将处理结果传递给流水线下游的Sink
}

// Stream.map()，调用该方法将产生一个新的Stream
public final <R> Stream<R> map(Function<? super P_OUT, ? extends R> mapper) {
    ...
    return new StatelessOp<P_OUT, R>(this, StreamShape.REFERENCE,
                                 StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override /*opWripSink()方法返回由回调函数包装而成Sink*/
        Sink<P_OUT> opWrapSink(int flags, Sink<R> downstream) {
            return new Sink.ChainedReference<P_OUT, R>(downstream) {
                @Override
                public void accept(P_OUT u) {
                    R r = mapper.apply(u);// 1. 使用当前Sink包装的回调函数mapper处理u
                    downstream.accept(r);// 2. 将处理结果传递给流水线下游的Sink
                }
            };
        }
    };
}

// Stream.sort()方法用到的Sink实现
class RefSortingSink<T> extends AbstractRefSortingSink<T> {
    private ArrayList<T> list;// 存放用于排序的元素
    RefSortingSink(Sink<? super T> downstream, Comparator<? super T> comparator) {
        super(downstream, comparator);
    }
    @Override
    public void begin(long size) {
        ...
        // 创建一个存放排序元素的列表
        list = (size >= 0) ? new ArrayList<T>((int) size) : new ArrayList<T>();
    }
    @Override
    public void end() {
        list.sort(comparator);// 只有元素全部接收之后才能开始排序
        downstream.begin(list.size());
        if (!cancellationWasRequested) {// 下游Sink不包含短路操作
            list.forEach(downstream::accept);// 2. 将处理结果传递给流水线下游的Sink
        }
        else {// 下游Sink包含短路操作
            for (T t : list) {// 每次都调用cancellationRequested()询问是否可以结束处理。
                if (downstream.cancellationRequested()) break;
                downstream.accept(t);// 2. 将处理结果传递给流水线下游的Sink
            }
        }
        downstream.end();
        list = null;
    }
    @Override
    public void accept(T t) {
        list.add(t);// 1. 使用当前Sink包装动作处理t，只是简单的将元素添加到中间列表当中
    }
}

// AbstractPipeline.wrapSink()
// 从下游向上游不断包装Sink。如果最初传入的sink代表结束操作，
// 函数返回时就可以得到一个代表了流水线上所有操作的Sink。
final <P_IN> Sink<P_IN> wrapSink(Sink<E_OUT> sink) {
    ...
    for (AbstractPipeline p=AbstractPipeline.this; p.depth > 0; p=p.previousStage) {
        sink = p.opWrapSink(p.previousStage.combinedFlags, sink);
    }
    return (Sink<P_IN>) sink;
}

// AbstractPipeline.copyInto(), 对spliterator代表的数据执行wrappedSink代表的操作。
final <P_IN> void copyInto(Sink<P_IN> wrappedSink, Spliterator<P_IN> spliterator) {
    ...
    if (!StreamOpFlag.SHORT_CIRCUIT.isKnown(getStreamAndOpFlags())) {
        wrappedSink.begin(spliterator.getExactSizeIfKnown());// 通知开始遍历
        spliterator.forEachRemaining(wrappedSink);// 迭代
        wrappedSink.end();// 通知遍历结束
    }
    ...
}

// 错误的收集方式
ArrayList<String> results = new ArrayList<>();
stream.filter(s -> pattern.matcher(s).matches())
      .forEach(s -> results.add(s));  // Unnecessary use of side-effects!
// 正确的收集方式
List<String>results =
     stream.filter(s -> pattern.matcher(s).matches())
             .collect(Collectors.toList());  // No side-effects!

Stream.iterate(1, item -> item + 1).limit(10).forEach(System.out::println); // limit

// 数组
Arrays.stream(arr).forEach(System.out::println);
// List
Arrays.asList(arr).stream().forEach(System.out::println);
// generator
Stream.generate(() -> new Random().nextInt(10)).limit(10);

<R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner);

List<Integer> ints = Lists.newArrayList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
System.out.println("ints sum is:" + ints.stream().reduce(Integer::sum).orElse(0));

List<Integer> ints = Lists.newArrayList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
System.out.println("ints sum is:" + ints.stream().reduce(100, Integer::sum));

List<Integer> ints = Lists.newArrayList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
System.out.println("ints count is:" + ints.stream().map(c -> c).count());

public synchronized Heavy getHeavy() {
    if(heavy == null) {
        heavy = new Heavy();
    }
    return heavy;
}

public class Evaluation {
    public static boolean evaluate(final int value) {
        System.out.println("evaluating ..." + value);
        simulateTimeConsumingOp(2000);
        return value > 100;
    }

    public static void eagerEvaluator(
        final boolean input1, final boolean input2) {
        System.out.println("eagerEvaluator called...");
        System.out.println("accept?: " + (input1 && input2));
    }
    //...
}
eagerEvaluator(evaluate(1), evaluate(2));
// evaluating ...1
// evaluating ...2
// eagerEvaluator called...
// accept?: false

public static void lazyEvaluator(
    final Supplier<Boolean> input1, final Supplier<Boolean> input2) {
    System.out.println("lazyEvaluator called...");
    System.out.println("accept?: " + (input1.get() && input2.get()));
}

lazyEvaluator(() -> evaluate(1), () -> evaluate(2));

// lazyEvaluator called...
// evaluating ...1
// accept?: false

@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Person {
    private Integer id;
    private String name;
    private Integer room;
    private List<String> tags;
}

Person person1 = Person.builder().id(1).name("11").room(1).tags(Lists.newArrayList("111", "aaa")).build();
Person person2 = Person.builder().id(2).name("22").room(1).tags(Lists.newArrayList("222", "bbb")).build();
Person person3 = Person.builder().id(3).name("33").room(1).tags(Lists.newArrayList("333", "ccc")).build();
Person person4 = Person.builder().id(4).name("44").room(2).tags(Lists.newArrayList("444", "ddd")).build();
Person person5 = Person.builder().id(5).name("55").room(2).tags(Lists.newArrayList("555", "eee")).build();
Person person6 = Person.builder().id(6).name("66").room(2).tags(Lists.newArrayList("666", "fff")).build();

List<Person> personList = Lists.newArrayList(person1, person2, person3, person4, person5, person6);

List<Integer> ids = personList.parallelStream().map(Person::getId).collect(Collectors.toList());
// 收集某个字段的值 [1, 2, 3, 4, 5, 6]

// {1=Person(id=1, name=11, room=1, tags=[111, aaa]),
// 2=Person(id=2, name=22, room=1, tags=[222, bbb]),
// 3=Person(id=3, name=33, room=1, tags=[333, ccc]),
// 4=Person(id=4, name=44, room=2, tags=[444, ddd]),
// 5=Person(id=5, name=55, room=2, tags=[555, eee]),
// 6=Person(id=6, name=66, room=2, tags=[666, fff])}
Map<Integer, Person> keyMap = personList.stream().collect(Collectors.toMap(Person::getId, c -> c));

// 该方法必须保证数据不可重复，如果重复会报异常
Exception in thread "main" java.lang.IllegalStateException: Duplicate key Person(id=1, name=11, room=1, tags=[111, aaa])
    at java.util.stream.Collectors.lambda$throwingMerger$114(Collectors.java:133)
    at java.util.HashMap.merge(HashMap.java:1245)
    at java.util.stream.Collectors.lambda$toMap$172(Collectors.java:1320)
    at java.util.stream.ReduceOps$3ReducingSink.accept(ReduceOps.java:169)
    at java.util.ArrayList$ArrayListSpliterator.forEachRemaining(ArrayList.java:1374)
    at java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:481)
    at java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:471)
    at java.util.stream.ReduceOps$ReduceOp.evaluateSequential(ReduceOps.java:708)
    at java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:234)
    at java.util.stream.ReferencePipeline.collect(ReferencePipeline.java:499)
    at Test.main(Test.java:65)
    
personList.add(Person.builder().id(1).name("11").room(1).tags(Lists.newArrayList("111", "aaa")).build());
Map<Integer, Person> repeat = personList.stream().collect(Collectors.toMap(Person::getId, c -> c));

List<Integer> distinctRooms = personList.stream().map(Person::getRoom).distinct().collect(Collectors.toList());
// 收集某个字段去重 [1, 2]

personList.add(Person.builder().id(1).name("11").room(1).tags(Lists.newArrayList("111", "aaa")).build());
List<Person> distinctPerson = personList.stream().distinct().collect(Collectors.toList());
// distinct基于对象的equals方法，实现去重

long sum = personList.stream().mapToInt(Person::getId).sum();
double average = personList.stream().mapToInt(Person::getId).average().orElse(0.0);
int max = personList.stream().mapToInt(Person::getId).max().orElse(0);
int min = personList.stream().mapToInt(Person::getId).min().orElse(0);

// {1=[Person(id=1, name=11, room=1, tags=[111, aaa]), Person(id=2, name=22, room=1, tags=[222, bbb]), Person(id=3, name=33, room=1, tags=[333, ccc])],

// 2=[Person(id=4, name=44, room=2, tags=[444, ddd]), Person(id=5, name=55, room=2, tags=[555, eee]), Person(id=6, name=66, room=2, tags=[666, fff])]}

Map<Integer, List<Person>> roomMap = personList.stream().collect(Collectors.groupingBy(Person::getRoom));

// 分组之后再次流处理
// {1=[1], 2=[2], 3=[3], 4=[4], 5=[5], 6=[6]}
Map<Integer, List<Integer>> groupIds = personList.stream().collect(Collectors.groupingBy(Person::getId, Collectors.mapping(Person::getId, Collectors.toList())));

// {1=[[111, aaa]], 2=[[222, bbb]], 3=[[333, ccc]], 4=[[444, ddd]], 5=[[555, eee]], 6=[[666, fff]]}
Map<Integer, List<List<String>>> groupTags = personList.stream().collect(Collectors.groupingBy(Person::getId, Collectors.mapping(Person::getTags, Collectors.toList())));

System.out.println(personList.stream().reduce((c1, c2) -> {
    return Person.builder().id(c1.getId() + c2.getId()).build();
}).orElse(Person.builder().build()));
// Person(id=21, name=null, room=null, tags=null)

System.out.println(personList.stream().reduce((c1, c2) -> {
    return Person.builder().id(c1.getId() + c2.getId()).build();
}).orElse(Person.builder().build()));
// Person(id=21, name=null, room=null, tags=null)

List<Person> sortedList = personList.stream().sorted(Comparator.comparing(Person::getId).reversed()).collect(Collectors.toList());
// 按照id倒序
// [Person(id=6, name=66, room=2, tags=[666, fff]), Person(id=5, name=55, room=2, tags=[555, eee]), Person(id=4, name=44, room=2, tags=[444, ddd]), Person(id=3, name=33, room=1, tags=[333, ccc]), Person(id=2, name=22, room=1, tags=[222, bbb]), Person(id=1, name=11, room=1, tags=[111, aaa])]

String names = personList.stream().map(Person::getName).collect(Collectors.joining());
// 112233445566

String names = personList.stream().map(Person::getName).collect(Collectors.joining(","));
// 11,22,33,44,55,66

String names = personList.stream().map(Person::getName).collect(Collectors.joining(",", "{", "}"));
// {11,22,33,44,55,66}

List<String> flatMapResult = personList.stream().flatMap(inner -> inner.getTags().stream()).collect(Collectors.toList());
// [111, aaa, 222, bbb, 333, ccc, 444, ddd, 555, eee, 666, fff]

List<String> collect = personList.stream().map(Person::getTags).flatMap(Collection::stream).collect(Collectors.toList());
// [111, aaa, 222, bbb, 333, ccc, 444, ddd, 555, eee, 666, fff]

boolean b = personList.stream().anyMatch(c -> "11".equals(c.getName())); // true
boolean b = personList.stream().allMatch(c -> "11".equals(c.getName())); // false
boolean b = personList.stream().noneMatch(c -> "11".equals(c.getName())); // false

// anyMatch表示，判断的条件里，任意一个元素成功，返回true
// allMatch表示，判断条件里的元素，所有的都是，返回true
// noneMatch跟allMatch相反，判断条件里的元素，所有的都不是，返回true

List<Person> collect = personList.stream().filter(c -> "11".equals(c.getName())).collect(Collectors.toList());
// [Person(id=1, name=11, room=1, tags=[111, aaa])]

String[] arr = {"a", "b", "c", "d"};
List<String> collect = Arrays.stream(arr).peek(System.out::println).filter("c"::equals).peek(System.out::println).collect(Collectors.toList());
System.out.println(collect);

int pageSize = 2;
int page = 3;
List<Person> result = personList.stream().skip(pageSize * (page - 1))
    .limit(pageSize)
    .collect(Collectors.toList());
// [Person(id=5, name=55, room=2, tags=[555, eee]), Person(id=6, name=66, room=2, tags=[666, fff])]

IntSummaryStatistics intSummaryStatistics = personList.stream().mapToInt(Person::getId).summaryStatistics();
System.out.println(intSummaryStatistics.getMax());
System.out.println(intSummaryStatistics.getAverage());
System.out.println(intSummaryStatistics.getCount());
System.out.println(intSummaryStatistics.getMin());
System.out.println(intSummaryStatistics.getSum());

// 6
// 3.5
// 6
// 1
// 21

Stream.iterate(0, i -> i + 1).limit(bizIds.size()).forEach()