Java8之Stream用法

一、静态工厂方法

1.of

        Stream<Object> of=Stream.of(1,2,3,"r");
        Stream<String> o=Stream.of("1","2","3");

2.generate 产生一个无限长度的Stream,不同时间点产生的值可能不同,一般会配合limite、filter限制长度,否则会无限生成下去

源码:

generate(Supplier<T> s)

示例一:

       Stream<Object> generate1= Stream.generate(new Supplier<Object>() {
            @Override
            public Object get() {
                return Math.random();
            }
        });

示例二:

Stream.generate(() -> Math.random())
                .limit(10)
                .forEach(item -> System.out.println(item));

3.iterate 返回一个无限长度的Stream,根据传入的seed值,通过方法f产生一个无限、连续、有序的Stream值

一般也和limite、filter配置使用，否则会无限产生数据

源码:

public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)

示例一:

        Stream.iterate(1, new UnaryOperator<Integer>() {
            @Override
            public Integer apply(Integer integer) {
                return null;
            }
        });

示例二：

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

二、Collection接口和数组默认stream方法

2.1 Collection默认的转换Stream方法

    default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
    }

示例:

        List<String> asList=Arrays.asList("a","b","c","d");

        asList.stream()
                .forEach(item -> System.out.println(item));

2.2 数组转换Stream的方法,支持基本类型和自定义类型

示例:

        int[] aaa=new int[]{1,2,3,4,5};
        Arrays.stream(aaa)
                .forEach(item -> System.out.println(item));

4. concat连接两个Stream合并

源码:

public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)

示例：

 Stream<Object> of=Stream.of(1,2,3,"r");
        Stream<String> o=Stream.of("1","2","3");

        Stream<Object> dd=Stream.concat(of,o);

5.distinct 去重,生成新的Stream

示例:

        Stream.of(1,1,2,3,4,4,5)
                .distinct()
                .forEach(item -> System.out.println(item));

5.filter 筛选和过滤，只保留符合filter表达式的信息

        Stream.of(1,2,3,4,5)
                .filter(item -> item<3)
                .forEach(item -> System.out.println(item));

6.map 转换，接受Function类型实例，生成新的Stream

实例一:

        Stream<String> of=Stream.of("1","2","3","r");

        Stream<String> dd=of.map(new Function<String, String>() {
            @Override
            public String apply(String o) {
                return o.toUpperCase();
            }
        });
dd.forEach(item -> System.out.println(item));

实例二:

  of.map(item -> item.toUpperCase())
                .forEach(item -> System.out.println(item));

实例一和示例二是一样的，只不过示例二使用了lamda表达式

7.flatMap 对Stream进行转换，和map方法不同，flatMap不会产生新的Stream，是对原Stream进行修改

接受Funtion类型的实例

源码:

<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);

示例:

        Stream<String> of=Stream.of("1","2","3","r");

        of.flatMap(item -> Stream.of(item+"=="))
                .forEach(item -> System.out.println(item));

8.peek 接受Consumer类型的实例作为参数，生成一个包含原Stream所有元素的新Stream，同时提供一个Consumer类型的消费函数,新Stream的元素被消费前都会调用该消费函数,且首先调用该消费函数

源码:

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

示例：

        of.peek(item -> System.out.println(item+"==="))
                .forEach(item -> System.out.println(item));

输出:

1===
1
2===
2
3===
3
r===
r

9.skip 接收long类型的参数,跳过该参数长度的元素个数,假设参数是N，若原Stream中元素个数大于N，则会返回跳过N个元素之后的Stream，若原Stream的元素个数小于N则返回一个空的Stream。

源码：

Stream<T> skip(long n);

示例一：

        Stream<String> of=Stream.of("1","2","3","r");
        of.skip(2)
                .forEach(item -> System.out.println(item));

输出:

3
r

示例二：

        Stream<String> of=Stream.of("1","2","3","r");
        of.skip(10)
                .forEach(item -> System.out.println(item));

输出空集合

10. sorted 排序，默认排序或自定义Comparator

示例一：默认规则

Stream<String> of=Stream.of("6","2","5","3","4");
        of.sorted().forEach(item -> System.out.println(item));

示例二：自定义Comparator

        Stream<String> of=Stream.of("6","2","5","3","4");
        Comparator comparator=new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                return 0;
            }
        };
//lamda表达式
        of.sorted((s1,s2) -> comparator.compare(s1,s2)).forEach(item -> System.out.println(item));

示例三：

        of.sorted(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });

11.count 统计元素个数

        Stream<String> of=Stream.of("6","2","5","3","4");
            System.out.println(of.count());

12.max 取最大值，这里的取最大值实际上就是对Stream进行重新排序然后取最后一个值，具体得看排序规则。min正好相反。

示例：

Stream<Integer> of=Stream.of(6,2,5,3,4);
        System.out.println(of.max((s1,s2) -> s2-s1).get());

13. reduce   把Stream中的元素按照一定规则组合成一个新的值,即把所有元素按照某种规则进行组合操作生成一个新的值。

参考地址: https://www.cnblogs.com/noteless/p/9511407.html

源码：三个方法

 Optional<T> reduce(BinaryOperator<T> accumulator);
 
T reduce(T identity, BinaryOperator<T> accumulator);

<U> U reduce(U identity,
                 BiFunction<U, ? super T, U> accumulator,
                 BinaryOperator<U> combiner);

方法一：

示例：假设要把各个元素相加计算和

此方法的第一个值s1是上次计算得到的值，第二个值s2是原Stream中的按照顺序(非并行时)的下一个值，第一次计算时s1和s2默认是Stream元素的前两个值。

/方式一：
        System.out.println(of.reduce(new BinaryOperator<Integer>() {
            @Override
            public Integer apply(Integer integer, Integer integer2) {
                return integer+integer2;
            }
        }).get());

        //方式二：lamda表达式
        System.out.println(of.reduce((s1,s2) -> s1+s2).get());

方法二:此方法的第一个值s1是上次计算得到的值,第二个值s2是原Stream中按照顺序的下一个值,第一次初始计算时,s1的默认值是传过来的参数,下面我传的是1，所以s1的默认初始值是1，s2的默认初始值是Stream的第一个值。

Stream<Integer> of=Stream.of(6,2,5,3,4,5);

//方式一:
System.out.println(of.reduce(1, new BinaryOperator<Integer>() {
           @Override
           public Integer apply(Integer integer, Integer integer2) {
               return integer+integer2;
           }
       }));

//方式二:lamda表达式
       System.out.println(
               of.reduce(1,(s1,s2) -> s1+s2)
       );

方法三：此方法的第三个参数是和并行有关的,第三个参数的规则如下:

规则一:combiner.apply(identity,u)==u，参数一是传入的初始化值,u是任意值

规则二：combiner.apply(u,accumulator.apply(identity,t))=accumulator.apply(u,t)

示例一(并行示例):

 List<Integer> list=Arrays.asList(6,2,5,3,4,5);

       System.out.println(list.parallelStream().reduce(0,
               new BiFunction<Integer, Integer, Integer>() {
                   @Override
                   public Integer apply(Integer integer, Integer integer2) {
                       return integer + integer2;
                   }
               },
               new BinaryOperator<Integer>() {
                   @Override
                   public Integer apply(Integer integer, Integer integer2) {
                       return integer + integer2;
                   }
               }));

方式二:lamda表达式
       System.out.println(
               list.parallelStream().reduce(1,(s1,s2) -> s1+s2,(s1,s2) -> s1+s2)
       );

若identity的值是1,则不符合上述两个规则,则计算出的和是31,应该是26

示例二（串行示例，此时参数三是否符合上述两个规则就没有影响）下例不符合上述两个规则，但是结果无误:

              List<Integer> list=Arrays.asList(6,2,5,3,4,5);

System.out.println(list.stream().reduce(1,
               new BiFunction<Integer, Integer, Integer>() {
                   @Override
                   public Integer apply(Integer integer, Integer integer2) {
                       return integer + integer2;
                   }
               },
               new BinaryOperator<Integer>() {
                   @Override
                   public Integer apply(Integer integer, Integer integer2) {
                       return integer + integer2;
                   }
               }));
       System.out.println(
               list.stream().reduce(2,(s1,s2) -> s1+s2,(s1,s2) -> s1+s2)
       );

14. allMatch 判断Stream下所有元素是否都符合某种条件

源码:

    boolean allMatch(Predicate<? super T> predicate);

示例:

        List<Integer> list=Arrays.asList(6,2,5,3,4,5);
        System.out.println(
                list.stream().allMatch(item -> item>3)
        );

15. anyMatch 判断Stream中是否有满足条件的元素，只要有一个元素满足则会返回true

源码：

    boolean anyMatch(Predicate<? super T> predicate);

示例：

      List<Integer> list=Arrays.asList(6,2,5,3,4,5);
        System.out.println(
                list.stream().anyMatch(item -> item>3)
        );

16.

findFirst 查找Stream元素中的第一个元素

源码：

    Optional<T> findFirst();

示例：

        List<Integer> list=Arrays.asList(6,2,5,3,4,5);
        System.out.println(
                list.stream().findFirst().get()
        );

17. limit 元素截取，limit(n)， 从Stream中从开头截取长度为n产生新Stream，若n的长度大于原Stream的长度，则截取原Stream的所有元素信息

源码：

    Stream<T> limit(long maxSize);

示例：

        List<Integer> list=Arrays.asList(6,2,5,3,4,5);               list.stream().limit(20).forEach(item -> System.out.println(item));

18. noneMatch 判断Stream中所有元素是否都不符合某一条件

源码：

    boolean noneMatch(Predicate<? super T> predicate);

示例：

        List<Integer> list=Arrays.asList(6,2,5,3,4,5);
        System.out.println(
                list.stream().noneMatch(item -> item>10)
        );
        //输出true
 System.out.println(
                list.stream().noneMatch(item -> item>3)
        );
//        输出false