Stream流

Stream流的介绍

               String流是jdk1.8的新特性，作用是方便操作集合和数组，可以多个操作连接起来。

如何获得Stream流对象

               Set集合获取Stream流对象方式和list集合获取的方式一样，双列集合要先获取单列集合才可以获取Stream流对象

 public static void main(String[] args){
        //创建一个集合
        List<Integer> list = List.of(1, 5, 6, 1, 2, 3);
        //集合对象.stream()   就获取Stream流对象了
        Stream<Integer> stream = list.stream();
    }

    

    数组获得Stream的方式

  //数组获得Stream流的方式是通过Stream的静态方法of来获得
        Stream<Integer> arr1 = Stream.of(42,356,89,89,756);

 

 Stream流常用方法介绍

Stream<T>  filter(Predicate<T>   predicate)	根据条件过滤不符合条件的数据      延迟方法
long   count()	获取流中元素的个数              终结方法
Stream<T>  limit(long  maxSize)	获取前面maxSize个元素           延迟方法
Stream<T>  skip(long n)	跳过前n个元素                           延迟方法
Stream<R>  map(Function<T,R>  mapper)	将流中的元素从T类型转为R类型并保存在新的流中   延迟方法
void  forEach(Consumer<T>  con)	逐一处理流中的数据             终结方法
static  <T>  Stream<T>  concat(Stream<T>  a,Stream<T>  b)	把两个流的数据合并到一个流当中，那两个流就不能使用

        注意：调用了终结方法的流就不能在继续使用了，终结方法和延迟方法的区别，如果一个流东西调用了一个方法，返回值为一个流东西，那么那个方法就是延迟方法，返回值为其他的那么那个方法就是终结方法

          

   fiter方法使用

        List<Integer> list = List.of(1, 5, 6, 1, 2, 3);
        Stream<Integer> stream = list.stream();
    /*
     //使用匿名类部类  filter里面的参数为 Predicate的实现类
    Stream<Integer> stream1 = stream.filter(new Predicate<Integer>() {
            @Override
            //如果该方法返回true就表示这个数符合条件，就会把这个元素保存到返回值那个流里面
            public boolean test(Integer integer) {
                return integer>3;
            }
        });

        */
    //使用lambda表达式完成
        Stream<Integer> stream1 = stream.filter(e->e>5);

 

 map方法使用

  List<Integer> list = List.of(1, 5, 6, 1, 2, 3);
        Stream<Integer> stream = list.stream();
     /*
        匿名类部类实现
      // 使用map方法里面要哦传入一个Function函数接口的实现类，第一个泛型为你调用这个方法的Stream流的参数类型
        //第二个泛型为，你要把第一个参数转为什么类型
        Stream<String> stream1 =  stream.map(new Function<Integer, String>() {
            @Override
            public String apply(Integer integer) {
                //把int类型转为String类型如何返回，然后保存到一个新的流中
                return integer.toString();
            }
        });*/

     //lambda表达式实现
        Stream<String> stream1 =  stream.map(i->i.toString());

forEach方法使用

   List<Integer> list = List.of(1, 5, 6, 1, 2, 3);
        Stream<Integer> stream = list.stream();
       /* //使用匿名类部类实现   forEach方法里面要传入一个Consumer函数式接口的实现类，消费数据
        stream.forEach(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) {
                //forEach方法会把Stream流每一个元素传入这个方法
                System.out.println(integer);
            }
        });*/

     /*  //使用lambda表达式完成
        stream.forEach(i->{
            System.out.println(i);
        });*/

     //使用方法引用完成
        stream.forEach(System.out::println);

        

Stream流的分类

                串行流： 在当前线程中按顺序执行（不开线程）

                并行流：多个线程一起执行（开启多个线程一起执行）

 

 获取并行流方式      

        List<Integer> list = List.of(1, 5, 6, 1, 2, 3);
        
        //获取方式1：间接获取并行流
        Stream<Integer> stream = list.stream();
        //调用 stream的 parallel方法获取并行流
      Stream<Integer> stream1 =  stream.parallel();
        
      //获取方式二：直接获取  直接调用集合的 parallelStream方法获取并行流
        Stream<Integer> integerStream = list.parallelStream();

 

收集一个Stream流的数据，存储到list集合中

        List<Integer> list = List.of(1, 5, 6, 1, 2, 3);
        Stream<Integer> stream = list.stream();
        //如果要把流的数据存储到一个set集合就调用 Collection.toSet() 方法
      List<Integer> list1 =  stream.collect(Collectors.toList());

 

搜集一个Stream流的数据，存储到一个数组里面

        List<Integer> list = List.of(1, 5, 6, 1, 2, 3);
        Stream<Integer> stream = list.stream();
        //把Stream流的数据存储到一个指定类型的数组里面
        stream.toArray(Integer[]::new);