Java 8 Stream

代码搬动工程师

已于 2022-05-20 23:02:37 修改

阅读量560

点赞数

文章标签： java

于 2021-05-12 17:20:18 首次发布

本文链接：https://blog.csdn.net/m0_56565321/article/details/116709572

版权

匹配（findFirst/findAny）

判断（anyMatch/allMatch/noneMatch）

映射（map/flatMap）

转特殊流（mapToInt/mapToDouble/mapToLong/flatMapToDouble/flatMapToInt/flatMapToLong）

收集器（collect）

1.归集(toList/toSet/toMap)

2.统计(count/averaging)

3.分组(partitioningBy/groupingBy)（groupingBy不太理解，以后有时间可以去研究研究）

Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据，循环往下处理，最后得出结果。

什么是 Stream？

Stream（流）是一个来自数据源的元素队列并支持聚合操作

元素是特定类型的对象，形成一个队列。 Java中的Stream并不会存储元素，而是按需计算。
数据源 流的来源。可以是集合，数组，I/O channel，产生器generator 等。
聚合操作 类似于jquery的处理方式。也有点类似于thinkphp的处理。

Stream的创建

1.集合创建（List）

//List<Integer> interList = Arrays.asList(1, 2);
List<Integer> interList = new ArrayList<>();
interList.add(1);
interList.add(2);
//顺序流
Stream<Integer> stream = interList.stream();
stream.forEach(System.out::println);

//顺序流转并行流
Stream<Integer> parallelStream2 = stream.parallel();

//并行流
Stream<Integer> parallelStream = interList.parallelStream();
parallelStream.forEach(System.out::println);

//并行流转顺序流
Stream<Integer> stream2 =parallelStream.sequential();

2. 数组创建

Integer[] aa = {5,4,3,2,1};
//默认所有数据写入流
//Stream<Integer> IntergerStream = Arrays.stream(aa);
//可以部分写入流
Stream<Integer> IntergerStream = Arrays.stream(aa,1,aa.length);
//java 基本数据类型数组创建流(其他类型包含double、long创建流(部分创建流))
int[] intList = {5,4,3,2,1};
IntStream intStream = Arrays.stream(intList);

3.静态方法创建

/**
 * 源码如下，使用很方便
 * public static<T> Stream<T> of(T... values) {
 *    return Arrays.stream(values);
 * }
 */
Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);

//返回有序无限连续 Stream由函数的迭代应用产生 f至初始元素 seed ，产生 Stream包括 seed ， f(seed) ， f(f(seed)) ，等
Stream<Integer> stream2 = Stream.iterate(0, (x) -> x + 3).limit(4);

//返回无限顺序无序流，其中每个元素由提供的 Supplier 。
Stream<Double> stream3 = Stream.generate(Math::random).limit(3);
stream3.forEach(System.out::println);

//返回一个空的顺序 Stream 
Stream<Integer> stream4 = Stream.empty();

Stream方法

循环（forEach）

可用于迭代流中的每一个元素

List<String> list = new ArrayList<>();
list.add("好");
list.add("好的");

list.stream().forEach(System.out::println)

循环打印每一个元素

排重（distinct）

通过流中元素的 hashCode() 和 equals() 去除重复元素（牛B）

List<String> list = new ArrayList<>();
list.add("好");
list.add("好");

list.stream().distinct().forEach(System.out::println);

限制（limit）

获取指定数量的流

List<String> list = new ArrayList<>();
list.add("好");
list.add("好");

list.stream().limit(1).forEach(System.out::println);

排序（sorted）

对流进行排序，一下三条排序方法等价。

List<Student> list = new ArrayList<>();
        list.add(new Student(5,"风"));
        list.add(new Student(4,"风"));
        list.add(new Student(9,"风"));
        list.add(new Student(8,"风"));
        list.add(new Student(20,"风"));

list.stream().sorted((x,y)->x.getId()-y.getId()).forEach(System.out::println);

list.stream().sorted(Comparator.comparing(Student::getId)).forEach(System.out::println);

list.stream().sorted(Comparator.comparing(student -> student.getId())).forEach(item->System.out.println(item));

public static class Student{
        public Integer id;

        public String name;

        public Student(Integer id,String name){
            this.id = id;
            this.name = name;
        }

        public Integer getId() {
            return id;
        }

        public void setId(Integer id) {
            this.id = id;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        @Override
        public String toString() {
            return "Student{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    '}';
        }
    }

筛选（filter）

通过筛选过滤掉不必须要元素

List<String> list = new ArrayList<>();
list.add("真");
list.add("的");
list.add("好");
list.stream().filter(item->item.equals("好")).forEach(System.out::println);