Stream--流编程

﹏ヽ暗。殇╰゛Y 2021-08-27 13:23 292阅读 0赞

### Stream流编程 ###

Stream不是集合元素，也不是数据结构，它相当于一个 高级版本的 Iterator，不可以重复遍历里面的数据，像水一样，流过了就一去不复返。它和普通的 Iterator 不同的是，它可以并行遍历，普通的 Iterator 只能是串行，在一个线程中执行。

#### 外部迭代与内部迭代 ####

使用for等进行迭代我们叫做外部迭代，使用stream流迭代叫做内部迭代。

public class StreamDemo { 
        public static void main(String[] args) { 
            int[] nums = { 1, 2, 3};
            //外部迭代
            int sum = 0;
            for (int i : nums)
                sum += i;
            System.out.println("结果为：" + sum);
    
            //内部迭代
            int sum1 = IntStream.of(nums).sum();
            System.out.println("结果为：" + sum1);
        }
    }

#### 中间操作/终止操作和惰性求值 ####

*  中间操作：返回stream的操作
 *  终止操作：得到特定的结果
 *  惰性求值：终止没有调用的情况下，中间操作不会执行

public class StreamDemo { 
        public static void main(String[] args) { 
            int[] nums = { 1, 2, 3};
            //外部迭代
            int sum = 0;
            for (int i : nums)
                sum += i;
            System.out.println("结果为：" + sum);
    
            //内部迭代
            //map就是中间操作（返回stream的操作）
            //sum就是终止操作
            int sum1 = IntStream.of(nums).map(StreamDemo::doubleNum).sum();
            System.out.println("结果为：" + sum1);
            System.out.println("惰性求值就是终止操作没用调用的情况下，中间操作不会执行");
    
            IntStream.of(nums).map(StreamDemo::doubleNum);//未调用终止操作，中间操作不会执行
        }
    
        public static int doubleNum(int i) { 
            System.out.println("执行了乘以2");
            return i * 2;
        }
    }

#### 创建 ####

<table> 
 <thead> 
  <tr> 
   <th align="left"></th> 
   <th align="left">相关方法</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">集合</td> 
   <td align="left"><code>Collection.stream</code>/<code>parallelStream</code></td> 
  </tr> 
  <tr> 
   <td align="left">数组</td> 
   <td align="left"><code>Arrays.stream</code></td> 
  </tr> 
  <tr> 
   <td align="left">数字Stream</td> 
   <td align="left"><code>IntStream</code>/<code>LongStream.range</code>/<code>rangeClosed</code><br><code>Random.ints</code>/<code>longs</code>/<code>doubles</code></td> 
  </tr> 
  <tr> 
   <td align="left">自己创建</td> 
   <td align="left"><code>Stream.generate</code>/<code>iterate</code></td> 
  </tr> 
 </tbody> 
</table>

public class StreamDemo2 { 
        public static void main(String[] args) { 
            List<String> list = new ArrayList<>();
            
            //从集合创建
            list.stream();
            list.parallelStream();
            
            //从数组创建
            Arrays.stream(new int[]{ 2, 3, 5});
            
            //创建数字流
            IntStream.of(1, 2, 3);
            IntStream.rangeClosed(1, 10);
            
            //使用random创建一个无线流
            new Random().ints().limit(10);
            
            //自己创建
            Random random = new Random();
            Stream.generate(() -> random.nextInt()).limit(20);
        }
    }

#### 中间操作 ####

*  有状态操作：当前操作与其他操作有依赖关系。(一般而言有状态操作都是有2个参数传入)
 *  无状态操作：当前操作与其他操作没有依赖关系。

<table> 
 <thead> 
  <tr> 
   <th align="left"></th> 
   <th align="left">相关方法</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">无状态操作</td> 
   <td align="left"><code>map</code>/<code>mapToXxx</code><br><code>flatMap</code>/<code>flatMapToXxx</code><br><code>filter</code><br><code>peek</code><br><code>unordered</code></td> 
  </tr> 
  <tr> 
   <td align="left">有状态操作</td> 
   <td align="left"><code>distinct</code><br><code>sorted</code><br><code>limit</code>/<code>skip</code></td> 
  </tr> 
 </tbody> 
</table>

public class StreamDemo3 { 
        public static void main(String[] args) { 
            String str = "my name is 007";
    
            //打印每个单词的长度
            Stream.of(str.split(" "))
                    .map(s -> s.length())
                    .forEach(System.out::println);
    
            //长度大于2
            Stream.of(str.split(" "))
                    .filter(s -> s.length() > 2)
                    .map(s -> s.length())
                    .forEach(System.out::println);
    
            //flatMap A -> B属性（是个集合），最终得到所有的A元素里面的所有B属性集合
            //intStream/longStream并不是Stream的子类，所以要进行装箱boxed
            Stream.of(str.split(" "))
                    .flatMap(s -> s.chars().boxed())
                    .forEach(i -> System.out.print((char)i.intValue()));
    
            System.out.println("");
    
            //peek用于debug，是个中间操作，用法和forEach基本一致，但forEach是终止操作
            Stream.of(str.split(" ")).peek(System.out::print).forEach(System.out::print);//打印两次
    
    
            System.out.println("");
    
            //limit使用，主要用于无线流
            new Random().ints()
                    .filter(i -> i > 100 && i < 10000)
                    .limit(10)
                    .forEach(System.out::println);
    
        }
    }

#### 终止操作 ####

*  非短路操作：需要等待所有结果都计算完毕才终止流
 *  短路操作：不需要等待所有结果都计算完毕才终止流

<table> 
 <thead> 
  <tr> 
   <th align="left"></th> 
   <th align="left">相关方法</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">非短路操作</td> 
   <td align="left"><code>forEach</code>/<code>forEachOrdered</code><br><code>collect</code>/<code>toArray</code><br><code>reduce</code><br><code>min</code>/<code>max</code>/<code>count</code></td> 
  </tr> 
  <tr> 
   <td align="left">短路操作</td> 
   <td align="left"><code>findFirst</code>/<code>findAny</code><br><code>allMatch</code>/<code>anyMatch</code>/<code>noneMatch</code></td> 
  </tr> 
 </tbody> 
</table>

public class StreamDemo4 { 
        public static void main(String[] args) { 
            String str = "my name is 007";
    
            //并行流使用forEach
            str.chars().parallel().forEach(i -> System.out.print((char)i));
            System.out.println();
            //并行流使用forEachOrdered,保证了顺序
            str.chars().parallel().forEachOrdered(i -> System.out.print((char)i));
    
            System.out.println();
            //收集到list
            List<String> list = Stream.of(str.split(" ")).collect(Collectors.toList());
            System.out.println(list);
    
            //使用reduce拼接字符串
            Optional<String> optional = Stream.of(str.split(" ")).reduce((s1, s2) -> s1 + "|" + s2);
            System.out.println(optional.orElse(""));
    
            //带初始值的reduce
            String reduce = Stream.of(str.split(" ")).reduce("", (s1, s2) -> s1 + "|" + s2);
            System.out.println(reduce);
    
            //求所有单词总长度
            Integer length = Stream.of(str.split(" ")).map(s -> s.length())
                    .reduce(0, (s1, s2) -> s1 + s2);
            System.out.println(length);
    
            //求最长单词
            Optional<String> max = Stream.of(str.split(" ")).max((s1, s2) -> s1.length() - s2.length());
            System.out.println(max.get());
    
    
            OptionalInt first = new Random().ints().findFirst();
            System.out.println(first.getAsInt());
        }

#### 并行流 ####

并行流使用的线程池: ForkJoinPool.commonPool  
默认的线程数是 当前机器的cpu个数  
使用这个属性可以修改默认的线程数

IntStream.range(1, 100).parallel().peek(StreamDemo5::debug).count();

public class StreamDemo5 { 
        public static void main(String[] args) { 
            //调用parallel产生一个并行流
            //IntStream.range(1, 100).parallel().peek(StreamDemo5::debug).count();
    
            //现在要实现一个这样的效果：
            // IntStream.range(1, 100)
            // //调用parallel产生并行流
            // .parallel().peek(StreamDemo5::debug)
            // //调用sequential产生串行流
            // .sequential().peek(StreamDemo5::debug2)
            // .count();
            //结论：多次调用parallel/sequential，以最后一次调用为准
    
            //并行流使用的线程池：ForkJoinPool.commonPool
            //默认线程数：当前机器的cpu个数
            //IntStream.range(1, 100).parallel().peek(StreamDemo5::debug).count();
    
            //使用自己的线程池，放置任务阻塞
            ForkJoinPool pool = new ForkJoinPool(20);
            pool.submit(() -> IntStream.range(1, 100)
                    .parallel()
                    .peek(StreamDemo5::debug)
                    .count());
            pool.shutdown();
    
            //防止主线程退出
            synchronized (pool) { 
                try { 
                    pool.wait();
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            }
    
    
        }
    
    
        public static void debug(int i) { 
            System.out.println(Thread.currentThread().getName() + "debug " + i);
            try { 
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
        }
    
        public static void debug2(int i) { 
            System.err.println("debug " + i);
            try { 
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
        }
    }

#### 收集器 ####

将处理后的流收集到集合中

package pers.zhang.stream;
    
    import java.util.*;
    import java.util.stream.Collectors;
    
    /** * @Author: acton_zhang * @Date: 2020/3/24 5:06 下午 * @Version 1.0 */
    public class StreamDemo6 { 
        public static void main(String[] args) { 
            // 测试数据
            List<Student> students = Arrays.asList(
                    new Student("小明", 10, Gender.MALE, Grade.ONE),
                    new Student("大明", 9, Gender.MALE, Grade.THREE),
                    new Student("小白", 8, Gender.FEMALE, Grade.TWO),
                    new Student("小黑", 13, Gender.FEMALE, Grade.FOUR),
                    new Student("小红", 7, Gender.FEMALE, Grade.THREE),
                    new Student("小黄", 13, Gender.MALE, Grade.ONE),
                    new Student("小青", 13, Gender.FEMALE, Grade.THREE),
                    new Student("小紫", 9, Gender.FEMALE, Grade.TWO),
                    new Student("小王", 6, Gender.MALE, Grade.ONE),
                    new Student("小李", 6, Gender.MALE, Grade.ONE),
                    new Student("小马", 14, Gender.FEMALE, Grade.FOUR),
                    new Student("小刘", 13, Gender.MALE, Grade.FOUR));
    
    
            //得到所有学生的年龄列表
            //s -> s.getAge() -----> Student::getAge,不会多生成一个类似lambda$0这样的函数
            Set<Integer> collect = students.stream()
                    .map(Student::getAge)
                    //.collect(Collectors.toList());
                    .collect(Collectors.toCollection(TreeSet::new));//可以指定集合类型
            System.out.println(collect);
    
    
            //统计汇总信息
            IntSummaryStatistics collect1 = students.stream().collect(Collectors.summarizingInt(Student::getAge));
            System.out.println(collect1);
    
            //分块
            Map<Boolean, List<Student>> collect2 = students.stream().collect(Collectors.partitioningBy(s -> s.getGender() == Gender.MALE));
            System.out.println(collect2);
    
            //分组
            Map<Grade, List<Student>> collect3 = students.stream().collect(Collectors.groupingBy(Student::getGrade));
            System.out.println(collect3);
    
            //得到所有班级学生的个数
            Map<Grade, Long> collect4 = students.stream()
                    .collect(Collectors.groupingBy(Student::getGrade, Collectors.counting()));
            System.out.println(collect4);
        }
    }
    
    /** * 学生 对象 */
    class Student { 
        /** * 姓名 */
        private String name;
    
        /** * 年龄 */
        private int age;
    
        /** * 性别 */
        private Gender gender;
    
        /** * 班级 */
        private Grade grade;
    
        public Student(String name, int age, Gender gender, Grade grade) { 
            super();
            this.name = name;
            this.age = age;
            this.gender = gender;
            this.grade = grade;
        }
    
        public String getName() { 
            return name;
        }
    
        public void setName(String name) { 
            this.name = name;
        }
    
        public int getAge() { 
            return age;
        }
    
        public void setAge(int age) { 
            this.age = age;
        }
    
        public Grade getGrade() { 
            return grade;
        }
    
        public void setGrade(Grade grade) { 
            this.grade = grade;
        }
    
        public Gender getGender() { 
            return gender;
        }
    
        public void setGender(Gender gender) { 
            this.gender = gender;
        }
    
        @Override
        public String toString() { 
            return "[name=" + name + ", age=" + age + ", gender=" + gender
                    + ", grade=" + grade + "]";
        }
    
    }
    
    /** * 性别 */
    enum Gender { 
        MALE, FEMALE
    }
    
    /** * 班级 */
    enum Grade { 
        ONE, TWO, THREE, FOUR;
    }