[Java基础] Jdk8 - Steam

2019-11-17 本文已影响0人 LCN233

[Java基础] Jdk8 - Steam

1. Stream 是什么?

Stream 是对集合（Collection）对象功能的增强。它专注于对集合对象各种高效的聚合操作（aggregate operation）[注: 和数据库中的聚合函数类似，如求平均值，最大值，前几个等操作]，或者大批量数据操作 (bulk data operation)。

2. Stream 的特点

Stream不存储数据
Stream 不是集合元素，它不是数据结构并不保存数据，它是有关算法和计算。如果硬要说的话，它更像一个高级版本的 Iterator。我们平时使用的 Iterator，只能显式地一个一个遍历元素并对元素进行我们想要的操作。但是 Stream，只要给出需要对其包含的元素执行什么操作，比如 "过滤掉长度大于 10 的字符串"，Stream 会隐式地在内部进行遍历，做出相应的数据转换。
Stream不改变源数据
当我们将一个集合转为 Stream，然后对 Stream 进行的任何操作，我们的数据源不会受到任何影响。
Stream 具有延迟执行的特性。 Stream 流的很多操作如 filter，map 等中间操作(intermediate operations，返回值还是一个 Stream，因此可以通过链式调用将中间操作串联起来)是延迟执行的，只有到最终操作(terminal operation，只能返回void或者一个非stream的结果)才会将操作顺序执行。

public void filter(Student stu) {
    System.out.println("开始过滤");
    return stu.getScore() > 80;
}

public void test() {
    
    List<Student> stuList = new ArrayList<>();

    stuList.add(new Student(21));
    stuList.add(new Student(21));
    stuList.add(new Student(21));

    // 此处的 filter 就是我们说的 中间操作
    Stream<Student> stream = stuList.stream().filter(this::filter);
    System.out.println("准备开始了");
    // collect 就是我们说的终点操作
    List<Student> stus =  stream.collect(Collectors.toList());
}


// 通过日志可知： filter方法是在 collect 执行时才会执行

/** 
 *  输出日志：   
 *  准备开始了
 *  开始过滤
 *  开始过滤    
 *  开始过滤
 */

对于 Stream 的聚合、消费或收集操作只能进行一次，再次操作会报错


    // generate 不断生成字符串，Limit(20) 限制 20 条。
    Stream<String> stream = Stream.generate(()->"user").limit(20);
    // 正常执行
    stream.forEach(System.out::println);

    // 报错：同一个stream对象只能进行一次
    stream.forEach(System.out::println);

Steam 的数据源本身可以是无限的。除了上面说的中间操作和最终操作，其中还有一种短路操作(short-circuiting)。

对于一个中间操作，如果它接受的是一个无限大的 Stream，但返回一个有限的新 Stream，比如 limit(限制前多少个)
对于一个最终操作，如果它接受的是一个无限大的 Stream，但能在有限的时间计算出结果，比如findFirst(找第一个)

3. Stream 的使用

1. Stream 的创建

(1) List 转为Stream


    List<Student> stuList = new ArrayList<>();

    // 普通的流
    Stream<Student> stream = stuList.stream();

    // 并行流
    Stream<String> stream1 = strs.parallelStream();

(2) 2.通过数组创建


    // 基本类型
    int[] arr = new int[]{1，2，34，5};
    IntStream intStream = Arrays.stream(arr);

    // 引用类型
    Student[] studentArr = new Student[]{new Student("s1"，29)，new Student("s2"，27)};
    Stream<Student> studentStream = Arrays.stream(studentArr);

(3) 数据集合


    Stream<Student> stream = Stream.of(new Student("小红"，20)，new Student("小明"，10));

    Student[] studentArr = new Student[]{new Student("s1"，29)，new Student("s2"，27)};
    Student[] studentArr2 = new Student[]{new Student("s1"，29)，new Student("s2"，27)};

    // Stream.of  里面的数据类型是什么，那么返回的Stream的泛型就是什么
    Stream<Student[]> stream01 = Stream.of(studentArr，studentArr2);

(4) 创建空的流

    
    // 创建 空的流
    Stream<Student> s = Stream.empty();

    Stream<Integer> s = Stream.empty();

(5) 创建无限流

    
    // 通过limit 截取需要的个数
    Stream.generate(()->new Student("name"，10)).limit(20).forEach(System.out::println);

(6) 创建规律的无限流


    // 0: 基点，从0开始，生成 0，1，2，3 ...顺序的10个
    Stream.iterate(0，x->x+1).limit(10).forEach(System.out::println);

    // 0：基点，从0开始，生成 0，0，0  10个数
    Stream.iterate(0，x->x).limit(10).forEach(System.out::println);

2.Stream转为集合

(1) toList(): 转为List

    List<Student> list = stuList.stream().collect(Collectors.toList());

(2) toMap(): 转为Map

    // 参数1： key  参数2： value  参数三: 当map的key相同时：如何处理  s--> 新的值(s遍历的值)  a--> 已有的和新的值key相同的对象(已有的值) 
    Map<Integer，String> map = Arrays.stream(students).collect(toMap(Student::getScore，Student::getName，(s，a)->{
            return s + a ;
    }));

(3) toSet(): 转为Set

    Set<Student> set = Arrays.stream(students).collect(toSet());

(4) toArray(): 转为Array

    Student[] s = Arrays.stream(students).toArray(Student[]::new);

(5) toCollection(): 转为指定的Collection对象

    HashSet<Student> s = Arrays.stream(students).collect(toCollection(HashSet::new));

3.对流的操作

1.筛选

(1) filter(): 条件过滤

    // filter里面的lambda表达式 返回一个Boolean值，如果为true 将这个对象保留
    stuList.stream().filter(x -> x.getScore() > 80).collect(Collectors.toList());

(2) distinct()：去重


    // stuList中重复的项会被去掉
    stuList.stream().distinct().collect(Collectors.toList());

2.截取

(1) limit(): 截取前几个

    // 获取stuList中的前3个
    stuList.stream().limit(3L).collect(Collectors.toList());

(2) skip(): 跳过前几个

    
    // 去掉stuList中的前3个
    stuList.stream().skip(3L).collect(Collectors.toList());

3.转换(映射)

(1) map(): 对象转换

    
    List<Student> stus = stuList.stream().collect(Collectors.toList());

    // 通过map 将 输出结果转为 List<String>  值为每个对象的 name属性
    List<String> strList = stuList.stream().map(item -> item.getName()).collect(Collectors.toList);

(2) flatMap(): 将每个值转换成另一个流，然后将所有的流连起来

    
    String[] arr1 = {"a"，"b"，"c"，"d"};
    String[] arr2 = {"e"，"f"，"c"，"d"};

     // 返回结果 List<String[]> 
    Stream.of(arr1，arr2).collect(Collectors.toList);

     //  返回结果 List<String>  2个数组合并成1个
    Stream.of(arr1，arr2).flatMap(Arrays::stream).collect(Collectors.toList());

4.查找

(1) findFirst(): 查找第一个


    // orElse(): 如果数据没有返回 nothing
    String str = Stream.of(arr).parallel().filter(x -> x.length() > 3).findFirst().orElse("nothing");

(2) findAny(): 查找一个(findFirst() 返回的是第一个，findAny() 不一定返回第一个)

    Optional<String> optional = Stream.of(arr).parallel().filter(x -> x.length() > 3).findAny();
    optional.ifPresent(System.out::println);

5.匹配

(1) anyMatch(): 是否包含匹配元素

    Boolean aBoolean = Stream.of(arr).anyMatch(x->x.startsWith("a"));

(2)allMatch()：是否全部符合

    // 有一个不符合就false
    Boolean aBoolean = Stream.of(arr).allMatch(x->x.startsWith("a"));

(3)noneMatch(): 是否存在不符合条件

    // 是否存在 不大于10的
    Boolean result = Stream.of(1，2，3，4，5).noneMatch( x -> x > 10);

6.遍历

(1) forEach(): 对流的数据进行遍历操作

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

7.流数据操作

(1) peek(): 对流中的每个数据进行需要的操作

    //对数据里面的每一项减去 100
    stuList.stream().peek(item -> item.setScore(item.getScore() - 100)).collect(toList());

8.流合并

(1) concat(): 2个相同类型的流进行合并


    Stream<String> stream1 = Stream.of(arr1);
    Stream<String> stream2 = Stream.of(arr2);

    Stream.concat(stream1，stream2).distinct().forEach(System.out::println);

9.规约(将流中的数据，按照需要，归并成一个值)

(1) reduce(): 归并操作的函数

    // 求和   参数1 提供给归并操作的起始值，参数2: 数据的处理方式，结果返回一个值
    int sum1 = numbers.stream().reduce(0，(a，b) -> a + b);

    int sum2 = numbers.stream().reduce(0，Integer::sum);

10.数学操作

(1) sorted(): 排序


    // 按照comparing里面的值进行顺序排序
    stuList.stream().sorted(Comparator.comparing(Student::getScore)).collect(Collectors.toList);

    // 逆序排序
    stuList.stream().sorted(Comparator.comparing(Student::getScore).reversed()).collect(Collectors.toList);

(2) max()/min(): 最大值/最小值

    // max 返回了Optional<T>
    Stream.of(arr).max(Comparator.comparing(String::length)).ifPresent(System.out::println);

    // min 返回了Optional<T>
    Stream.of(arr).min(Comparator.comparing(String::length)).ifPresent(System.out::println);

(3) count(): 统计

    int count = Stream.of(arr).count();

11.分组

(1) groupingBy(): 按照条件进行分组

    
    // 按照 相同的score一组 进行分组
    Map<Integer，List<Student>> groups = list.stream().collect(Collectors.groupingBy(Student::getScore));


    // 2级分组
    Map<Integer，Map<String，List<Student>>> twoGroup = list.stream()
                .collect(Collectors.groupingBy(Student::getScore，Collectors.groupingBy(Student::getName)));

    // 可以继续多级分组


    // 第二个参数也可以传递其他参数 Long : 个数
    Map<Integer，Long> groups = students.stream().collect(Collectors.groupingBy(Student::getScore，Collectors.counting()));   

    // Long 这一组的总分数
    Map<Integer，Integer> groups = students.stream().collect(Collectors.groupingBy(Student::getScore，summingInt(Student::getScore)));    

    // 是否有最大值
    Map<String，Optional<Student>> = students.stream().collect(Collectors.groupingBy(Student::getScore，maxBy(Comparator.comparing(Student::getScore)))); 

    // 转为Set
    Map<String，Set<Integer>> = students.stream().collect(Collectors.groupingBy(Student::getScore，mapping(Student::getScore，toSet())));

12.分区(分组的特殊情况，k值为true/false)

(1) partitioningBy(): 按照条件进行分组

    Map<Boolean，List<Student> groups = list.stream().collect(Collectors.partitioningBy(student -> student.getScore()> 90));

13.统计(IntSummaryStatistics)

(1) 使用IntSummaryStatistics进行数学操作

    IntSummaryStatistics summaryStatistics = Arrays.stream(students).collect(Collectors.summarizingInt(Student::getScore));

    System.out.println("getAverage->"+summaryStatistics.getAverage());
    System.out.println("getMax->"+summaryStatistics.getMax());
    System.out.println("getMin->"+summaryStatistics.getMin());
    System.out.println("getCount->"+summaryStatistics.getCount());
    System.out.println("getSum->"+summaryStatistics.getSum());

4.并行流

只需要调用顺序流的 parallel() 方法，就可以将普通顺序执行的流转变为并行流

顺序流：所有的顺序按照顺序进入流，在这个数据被流过滤掉，或者输出，后下个数据才能进入流，进行处理
并行流：开启多个线程(线程数由电脑决定)，并行的处理这些数据
并行流对 sorted()，distinct() 类似的元素操作api没有影响
并行流对 sorted()，distinct() 类似的元素操作api会比顺序流耗时
并行流对数据的数据的输出是无序的，如果需要有序的输出请用：forEachOrdered

    
    // 顺序流： 0，1，2 ...
    Stream.iterate(0，x -> x + 1 ).limit(10).forEach(System.out::println);

    // 并行流： 3，1，0 ...
    Stream.iterate(0，x -> x + 1 ).limit(10).parallel().forEach(System.out::println);

    // 并行流： 0，1，2
    Stream.iterate(0，x -> x + 1 ).limit(10).parallel().forEachOrdered(System.out::println);

5.原始类型流

在数据量比较大的情况下，将基本数据类型（int，double...）包装成相应对象流的做法是低效的，因此，我们也可以直接将数据初始化为原始类型流，在原始类型流上的操作与对象流类似

原始流的生成


    DoubleStream doubleStream = DoubleStream.of(0.1，0.3，0.4);
    IntStream intStream = IntStream.of(1，3，4，5);

    // 生成 [0，100]
    IntStream intStream2 = IntStream.rangeClosed(0，100);

    // 生成 [0，100)
    IntStream intStream3 = IntStream.range(0，100);

原始流和对象流的转换

    Stream<Double> stream = doubleStream.boxed();

    DoubleStream doubleStream = stream.mapToDouble(Double::new);

6. Optional

通常聚合操作会返回一个 Optional 类型，Optional 表示一个安全(安全指的是避免直接调用返回类型的 null 值而造成空指针异常)的指定结果类型，调用 optional.isPresent() 可以判断返回值是否为空，或者直接调用 ifPresent(Consumer<? super T> consumer) 在结果部位空时进行消费操作；调用 optional.get() 获取返回值

    
    // 创建了一个空的Optional
    Optional<String> opt1 = Optional.empty();
    // false
    System.out.println(opt1.isPresent());

    // 类似给予了一个初始值
    Optional<String> opt = Optional.of("andy with u");
    // true
    System.out.println(opt.isPresent());

    // 获取Optional的默认值
    String result = opt.get();

    // 如果Optional有值进行操作
    opt.ifPresent(item -> System.out.println(item));

给 Optional 指定没有值时


    int a = Stream.of(1，3，4).filter(item -> item > 10).max(Comparator.naturalOrder()).orElse(100);

    int a = Stream.of(1，3，4).filter(item -> item > 10).max(Comparator.naturalOrder()).orElseGet(()->-1);

    int a = Stream.of(1，3，4).filter(item -> item > 10).max(Comparator.naturalOrder()).orElseThrow(RuntimeException::new);

Optional 的创建

    Optional<Student> studentOptional = Optional.of(new Student("user1"，21));

    // 转换 返回值--->Option<返回值>
    Optional<String> optionalStr = studentOptional.map(Student::getName);

    // 迭代(后者覆盖前者) 方法fn 返回 Option<String>，fn2返回Option<String> 要求返回值为 Option<T>，替代前者
    Optional<String> opt = fn().flatMap(fn2());

4. 参考

Java 8 中的 Streams API 详解

[Java基础] Jdk8 - Steam

[Java基础] Jdk8 - Steam

1. Stream 是什么?

2. Stream 的特点

3. Stream 的使用

1. Stream 的创建

2.Stream转为集合

3.对流的操作

4.并行流

5.原始类型流

6. Optional

4. 参考

猜你喜欢

热点阅读