所有函数：

allMatch 和 anyMatch

/**
 * allMatch 和 anyMatch
 * 这个并不是过滤数据用的，而只是获取一个判断结果
 *
 * 注意：这个函数一个Stream只能调用一次，调用一次后，这个Stream就调用close，也就是流就会关闭了，
 * 如果还要使用，那么需要再开辟一个
 */
@Test
public void allMatchAndAnyMatchTest(){
    List<Integer> integerList = Arrays.asList(1,2,3,123,12,41);
    Stream<Integer> stream = integerList.stream();

    //true
    show(stream.allMatch(t->t>0));

    Stream<Integer> stream1 = integerList.stream();
    //false
    show(stream1.allMatch(t->t>8));

    Stream<Integer> stream3 = integerList.stream();
    //true
    show(stream3.anyMatch(t->t>8));

    Stream<Integer> stream4 = integerList.stream();
    //false
    show(stream4.anyMatch(t->t>400));
}

builder

/**
 * Stream居然还有建造者模式，数据是空的
 */
@Test
public void builderTest(){
    Stream<Object> stringStream = Stream.builder().build();
    stringStream.forEach(Out::show);
}

collect

/**
 * collect 这个算是流的终止操作符
 */
@Test
public void collectTest(){
    List<Integer> integerList = Arrays.asList(1,2,3,123,12,41);
    integerList.stream().collect(Collectors.toList()).forEach(Out::show);
}

contact

/**
 * static contact 连接两个流的操作
 */
@Test
public void contactTest(){
    List<Integer> list = Arrays.asList(1,2,3);
    List<Integer> list2 = Arrays.asList(3,123,12,41);

    Stream.concat(list.stream(), list2.stream()).forEach(Out::show);
}

count

/**
 * count
 */
@Test
public void CountTest(){
    List<Integer> list = Arrays.asList(1,2,3);
    show(list.stream().count());
}

distinct

/**
 * distinct 数据流的唯一性
 */
@Test
public void distinctTest(){
    List<Integer> list = Arrays.asList(1,2,3);
    List<Integer> list2 = Arrays.asList(3,123,12,41);

    Stream.concat(list.stream(), list2.stream()).distinct().forEach(Out::show);
}

dropWhile

/**
 * dropWhile
 * 排序后的数据流，这个判断仅判断一次，一旦遇到不满足，则后面的就不再判断，和takeWhile相似
 */
@Test
public void dropWhileTest(){
    Stream.of(12,3,4,65,4).sorted(Comparator.reverseOrder()).dropWhile(t->t>5).forEach(Out::show);
}

skip

/**
 * skip 跳过前面多少个元素
 */
@Test
public void skipTest(){
    List<Integer> list = Arrays.asList(1,2,3,123,12,41);
    list.stream().skip(3).forEach(Out::show);
}

limit

/**
 * limit 保留流中的从前往后的多少个元素
 */
@Test
public void limitTest(){
    List<Integer> list = Arrays.asList(1,2,3,123,12,41);
    list.stream().limit(4).forEach(Out::show);
}

empty

/**
 * static empty 返回一个空的集合
 */
@Test
public void emptyTest(){
    Stream.empty().forEach(Out::show);
}

filter

/**
 * filter 过滤对应的数据
 */
@Test
public void filterTest(){
    List<Integer> list = Arrays.asList(1,2,3,123,12,41);
    list.stream().filter(t->t>10).forEach(Out::show);
}

findAny

/**
 * findAny 主要用于过滤后查找某一个数据
 */
@Test
public void findAnyTest(){
    List<Integer> list = Arrays.asList(1,2,3,123,12,41);
    show(list.stream().filter(t->t==14).findAny().orElse(0));
}

findFirst

/**
 * findFirst
 */
@Test
public void findFirstTest(){
    List<Integer> list = Arrays.asList(1,2,3,123,12,41);
    show(list.stream().filter(t->t>14).findFirst().orElse(0));
}

flatMap

/**
 * flatMap 主要用于将List< List< >> 这种多重嵌套转换为一层，跟CompletableFuture.thenCompose比较像
 */
@Test
public void flatMapTest(){
    List<Integer> list1 = Arrays.asList(1,2);
    List<Integer> list2 = Arrays.asList(1,2);
    List<Integer> list3 = Arrays.asList(1,2);

    List<List<Integer>> lists = List.of(list1, list2, list3);
    List<Integer> result = lists.stream().flatMap(Collection::stream).collect(Collectors.toList());
}

forEachOrdered

/**
 * forEachOrdered 查询数据
 * 与forEach 的区别在于在并行运行的时候，forEach是并行乱序的，而forEachOrdered还是有顺序的
 */
@Test
public void forEachOrderedTest(){
    List<Integer> list = Arrays.asList(1,2,3,123,12,41);

    list.stream().parallel().forEach(Out::show);
    tab();
    list.stream().parallel().forEachOrdered(Out::show);
}

generate

/**
 * generate 用于生成流数据
 * 但是这个函数生成的数据是无限的，因此必须用limit进行限制，该函数主要用于生成自己的流
 */
@Test
public void generateTest(){
    Random seed = new Random();
    Supplier<Integer> random = seed::nextInt;
    Stream.generate(random).limit(12).forEach(Out::show);

    //函数会一直执行，直到limit限制，否则会一直阻塞
    Stream.generate(()->23).limit(12).forEach(Out::show);
}

iterate

/**
 * iterate 用于生成流数据
 */
@Test
public void iterateTest(){
    //方法1
    Stream.iterate(0, a->a+2).limit(3).forEach(Out::show);

    //方法2
    Stream.iterate(0, r->r<8, a->a+2).limit(7).forEach(Out::show);
}

max

/**
 * max
 */
@Test
public void maxTest(){
    show(Stream.iterate(0, a->a+1).limit(12).max(Comparator.comparingInt(a -> a)).get());
}

noneMatch

/**
 * noneMatch 测试
 */
@Test
public void noneMatchTest(){
    show(Stream.iterate(0, a->a+1).limit(12).noneMatch(a->a>3));
    show(Stream.iterate(0, a->a+1).limit(12).noneMatch(a->a>30));
}

of

/**
 * of 测试
 */
@Test
public void ofTest(){
    Stream.of(12).forEach(Out::show);
    tab();
    Stream.of(12,3,4,65,4).forEach(Out::show);
}

ofNullable

/**
 * ofNullable
 * 与of 区别在于ofNullable是能够存放null
 */
@Test
public void ofNullableTest(){
    Stream.ofNullable(12).forEach(Out::show);
    Stream.ofNullable(null).forEach(Out::show);
}

peek

/**
 * peek
 * 这个是返回一个新的流，但是并没有对流中的数据进行操作，和map的区别在于map会生成一个新的数据流
 * peek和foreach的区别在于peek是中间数据，而forEach是Stream终结流函数
 */
@Test
public void peekTest(){
    Stream.of(12,3,4,65,4)
        .peek(t->{
            show(" - "+t+" - ");
        })
        .filter(t->t>6)
        .peek(t->{
            show(" * "+t+" * ");
        })
        .forEach(Out::show);
}

reduce

/**
 * reduce 用法
 * reduce 这个其实是相当于将那些流全部进行汇总之后进行操作
 */
@Test
public void reduceTest(){
    show(Stream.of(12,3,4,65,4).reduce(1, (a, b)->a+b));
    show(Stream.of(12,3,4,65,4).reduce((a, b)->a+b));
}

sorted

/**
 * sorted
 * 默认升序
 */
@Test
public void sortedTest(){
    Stream.of(12,3,4,65,4).sorted().forEach(Out::show);
    Stream.of(12,3,4,65,4).sorted(Comparator.reverseOrder()).forEach(Out::show);
}

takeWhile

/**
 * takeWhile java9
 * 该函数用于对排序后的数据进行过滤，从头排序，直到不满足条件，这个并不是过滤所有的，跟函数dropWhile
 */
@Test
public void takeWhileTest(){
    Stream.of(12,3,4,65,4).sorted(Comparator.reverseOrder()).takeWhile(t->t>5).forEach(Out::show);
}

toArray

/**
 * toArray
 * 将数据流转换为数组
 */
@Test
public void toArrayTest(){
    //方法1
    Object[] objects = Stream.of(12,3,4,65,4).toArray();
    Arrays.stream(objects).forEach(Out::show);

    //方法2
    Integer[] integers = Stream.of(12,3,4,65,4).toArray(Integer[]::new);
    Arrays.stream(integers).forEach(Out::show);
}

<br />

注意：

1.java9的这个dropWhite函数和filter函数有什么区别

这个函数需要排序，排序后，这两个函数都是遇到一次不满足的，则不再向后过滤，所以性能稍微会高一点<br />