【java Stream流】

Stream流

获取stream流对象的方法

tip: stream流对象就是将集合或者数组的数据变成数据流，通过使用流对象的方法来进行处理

1. 单列集合

          //tip: 这里是这里集合collection对象获取stream流的方法
           ArrayList<Integer> arrayList=new ArrayList<>();
           Stream<Integer> stream = arrayList.stream(); //调用集合对象中的stream方法生成一个stream流对象
   

2. 双列集合

         //tip: 双列结合不能直接获取stream流，需要生成entryset集合才可以生成stream流对象
           HashMap<String,String> hashMap=new HashMap<>();
           Stream<Map.Entry<String, String>> stream = hashMap.entrySet().stream();
   

3. 数组

        //数组通过调用Arrays的stream方法来生成stream流对象
         Integer[] ary=new Integer[5];
         Stream<Integer> stream = Arrays.stream(ary);
   

4. 零散数据

        //调用Stream类的静态方法of来生成strea流对象
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4);
   

stream流对象的中间方法

tip: 中间方法的意思就是方法最终会返回stream流对象

1. filter

       //filter方法可以根据条件过滤数据流中的数据
       Stream<Integer> integerStream = Stream.of(1, 2, 3, 4);
       integerStream.filter(s -> s % 2 == 0).forEach(s-> System.out.println(s)); //打印2 4
   

2. limit和skip

       //limit就是从数据流取前若干个数据
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4);
        integerStream.limit(2).forEach(s-> System.out.println(s)); //打印 1 2
       //skip就是从数据流中跳过前若干个数据
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4);
        integerStream.skip(2).forEach(s-> System.out.println(s)); //打印 3 4
   

3. concat

       //concat是Stream类中的静态方法,可以将两个stream流对象合并
        Stream<Integer> integerStream1 = Stream.of(1, 2, 3, 4);
        Stream<Integer> integerStream2 = Stream.of(5, 6, 7, 8);
        Stream.concat(integerStream1,integerStream2).forEach(s-> System.out.println(s)); 打印 1 2 3 4 5 6 7 8
   

4. map

       //map方法可以将stream流中的数据映射为一些数据
       Stream<Integer> integerStream1 = Stream.of(1, 2, 3, 4);
           Stream<Integer> integerStream2 = Stream.of(5, 6, 7, 8);
           Stream.concat(integerStream1,integerStream2).map(new Function<Integer, String>() {
               @Override
               public String apply(Integer integer) {
                   return integer+"!";
               }
           }).forEach(s-> System.out.println(s));  //打印 1！2！3！....
       //该方法就是将 整型1转换为字符串1！
   

stream对象的终结方法

tip: 终结方法意思就是不会返回stream流对象，所以不能进行链式编程

1. forEach

        //就是对数据流的数据进行打印
         Stream.of(1, 2, 3, 4).forEach(s->sout(s)); //打印 1 2 3 4
   

2. count

         //count方法返回数据流中数据的个数
          Stream.of(1, 2, 3, 4).count().sout();  // 4
   

3. toArray

           //将数据流转换为数组
           Object[] array1 = integerStream.toArray();  //没有参数时，返回object类型数组
           Integer[] array2 = integerStream.toArray(new IntFunction<Integer[]>() {
               @Override
               public Integer[] apply(int value) {
                   return new Integer[value];
               }
           });   //通过填入匿名内部类对象来自定义数组类型
   

4. collect

          //collect 方法可以将数据流转换为对应类型的集合
           List<Integer> collect1 = integerStream1.collect(Collectors.toList());
           Set<Integer> collect2 = integerStream2.collect(Collectors.toSet());
           Map<Object, Object> collect3 = integerStream3.collect(Collectors.toMap(
   
                   new Function<Integer, Object>() {
                       @Override
                       public Object apply(Integer integer) {
                           return integer+"!";
                       }
                   }, new Function<Integer, Object>() {
                       @Override
                       public Object apply(Integer integer) {
                           return integer+"?";
                       }
                   })); //对于toMap需要传入两个匿名内部类对象来自定义 键和值
                        //colletc3中数据为 1!=1? 2!=2? .....
                        //其中在该例子中object类型也可以换成string类型（自定义）
   

tip: 无论是中间方法还是终结方法，一旦被stream流对象调用，即该stream流对象即不能被再次使用，所以一般使用链式编程

   ```java
         Stream<Integer> integerStream = Stream.of(1, 2, 3, 4);
         integerStream.filter(s -> s % 2 == 0).forEach(s-> System.out.println(s)); //打印2 4
        //则 integerStream不能再使用
   ```