Jdk8 之 Stream流详细用法(一)
21/100
发布文章
nanshen__
未选择任何文件
new
本篇文章参考云深i不知处的文章
原文链接：https://blog.csdn.net/mu_wind/article/details/109516995
在这里插入图片描述

一、概述

Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。

Stream将要处理的元素集合看作一种流，在流的过程中，借助Stream API对流中的元素进行操作，比如：筛选、排序、聚合等。

特点：

不是数据结构，不会保存数据。
不会修改原来的数据源，它会将操作后的数据保存到另外一个对象中。
stream具有延迟执行特性，只有调用终端操作时，中间操作才会执行。

二、Stream流的创建

Stream 流可以通过集合和数组进行创建！
1、通过 java.util.Collection.stream() 方法用集合创建流

         List<String> list = Arrays.asList("a", "b", "c");
        //创建一个顺序流
        Stream<String> stream = list.stream();
        //创建一个并行流
        Stream<String> stringStream = list.parallelStream();

2、使用 java.util.Arrays.stream(T[] array) 方法用数组创建流

        int[] arra = {1, 3, 5, 6, 8};
        IntStream stream = Arrays.stream(arra);

3、使用Stream的静态方法：of()、iterate()、generate()

        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);

        Stream<Integer> limit = Stream.iterate(0, (x) -> x + 3).limit(4);
        limit.forEach(System.out::println);

        Stream<Double> limit1 = Stream.generate(Math::random).limit(3);
        limit1.forEach(System.out::println);

结果：

0
3
6
9
0.8997037806521349
0.4208955236355437
0.5905370762238087

第一种创建方式：stream和parallelStream的简单区分： stream是顺序流，由主线程按顺序对流执行操作，而parallelStream是并行流，内部以多线程并行执行的方式对流进行操作，但前提是流中的数据处理没有顺序要求。例如筛选集合中的奇数，两者的处理不同之处：
在这里插入图片描述
如果流中的数据量足够大，并行流可以加快处速度。
除了直接创建并行流，还可以通过parallel()把顺序流转换成并行流：

Optional<Integer> findFirst = list.stream()
                                .parallel().filter(x->x>6).findFirst();

三、Stream流的使用

在使用stream之前，先理解一个概念：Optional 。

Optional类是一个可以为null的容器对象。如果值存在则 isPresent()方法会返回 true，调用 get()方法会返回该对象。

3.1 遍历/匹配（foreach/find/match）

Stream也是支持类似集合的遍历和匹配元素的，只是Stream中的元素是以Optional类型存在的。Stream的遍历、匹配非常简单。
在这里插入图片描述

 List<Integer> list = Arrays.asList(7, 6, 9, 3, 8, 2, 1);

        //便利符合条件的字符串
        list.stream().filter(x -> x > 6).forEach(System.out::println);

        //匹配到第一个
        Optional<Integer> first = list.stream().filter(x -> x > 6).findFirst();

        //匹配任意（适用于并行流）
        Optional<Integer> any = list.parallelStream().filter(x -> x > 6).findAny();

        //是否包含特殊条件元素
        boolean b = list.stream().anyMatch(x -> x > 6);

        System.out.println("匹配到第一个 ==> " + first.get());
        System.out.println("匹配任意（适用于并行流） ==> " + any.get());
        System.out.println("是否包含特殊条件元素 ==> " + b);

运行结果：

7
9
8
匹配到第一个 ==> 7
匹配任意（适用于并行流） ==> 7
是否包含特殊条件元素 ==> true

3.2 筛选（filter）

筛选，是按照一定的规则校验流中的元素，将符合条件的元素提取到新的流中的操作。
在这里插入图片描述
案例一：筛选出Integer集合中大于6的元素，并打印出来

         List<Integer> list = Arrays.asList(6,7,3,8,1,2,9);
        Stream<Integer> stream = list.stream();
        stream.filter(x -> x > 7).forEach(System.out::println);

结果：

8
9

案例二：筛选员工中工资高于8000的人，并形成新的集合。形成新集合依赖collect（收集）

private static List<Person> personList = new ArrayList<Person>();

    static {
        personList.add(new Person("Tom", 8900, 28, "male", "New York"));
        personList.add(new Person("Jack", 7000, 18, "male", "Washington"));
        personList.add(new Person("Lily", 7800, 8, "female", "Washington"));
        personList.add(new Person("Anni", 8200, 38, "female", "New York"));
        personList.add(new Person("Owen", 9500, 48, "male", "New York"));
        personList.add(new Person("Alisa", 7900, 68, "female", "New York"));
    }

    @Test
    public void getSalary() {
        List<String> collect = personList.stream()
                .filter(x -> x.getSalary() > 8000)
                .map(Person::getName)
                .collect(Collectors.toList());
        System.out.println("高于8000薪资到人员信息  ==>  " + collect);
    }
}

结果：

高于8000薪资到人员信息 ==> [Tom, Anni, Owen]

3.3 聚合（max/min/count)

max、min、count这些字眼你一定不陌生，没错，在mysql中我们常用它们进行数据统计。Java stream中也引入了这些概念和用法，极大地方便了我们对集合、数组的数据统计工作。
在这里插入图片描述
案例一：获取String集合中最长的元素。

    @Test
    public void listString() {
        List<String> list = Arrays.asList("adnm", "admmt", "pot", "xbangd", "weoujgsd");

        Optional<String> max = list.stream()
                .max(Comparator.comparing(String::length));
        System.out.println("最长的字符串 ==> " + max.get());
    }

结果：

最长的字符串 ==> weoujgsd

案例二：获取Integer集合中的最大值。

@Test
    public void listInteger() {
        List<Integer> list = Arrays.asList(7, 6, 9, 4, 11, 6);

        Optional<Integer> max = list.stream().max(Integer::compareTo);

        Optional<Integer> max1 = list.stream().max(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.compareTo(o2);
            }
        });

        System.out.println("自然排序的最大值 ==> " + max.get());
        System.out.println("自定义排序的最大值 ==> " + max1.get());
    }

结果：

自然排序的最大值 ==> 11
自定义排序的最大值 ==> 11

案例三：获取员工工资最高的人。

    private static List<Person> personList = new ArrayList<Person>();

    static {
        personList.add(new Person("Tom", 8900, 28, "male", "New York"));
        personList.add(new Person("Jack", 7000, 18, "male", "Washington"));
        personList.add(new Person("Lily", 7800, 8, "female", "Washington"));
        personList.add(new Person("Anni", 8200, 38, "female", "New York"));
        personList.add(new Person("Owen", 9500, 48, "male", "New York"));
        personList.add(new Person("Alisa", 7900, 68, "female", "New York"));
    }

    @Test
    public void getMaxSalary() {
        Optional<Person> max = personList.stream()
                .max(Comparator.comparingInt(Person::getSalary));

        System.out.println("最高薪资到人员信息  ==>  " + max.get());
    }

结果：

最高薪资到人员信息 ==> Person(name=Owen, salary=9500, age=48, sex=male, area=New York)

案例四：计算Integer集合中大于6的元素的个数。

    @Test
    public void listIntegerCount() {
        List<Integer> list = Arrays.asList(7, 6, 9, 4, 11, 6);
        long count = list.stream().filter(x -> x > 6).count();

        System.out.println("list中大于6的元素个数 ==> " + count);
    }

结果：

list中大于6的元素个数 ==> 3

3.4 映射(map/flatMap)

映射，可以将一个流的元素按照一定的映射规则映射到另一个流中。分为map和flatMap：

map:接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
flatMap:接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。

在这里插入图片描述

案例一：英文字符串数组的元素全部改为大写。整数数组每个元素+3。

    @Test
    public void map() {
        String[] strArr = { "abcd", "bcdd", "defde", "fTr" };
        List<Integer> intList = Arrays.asList(1, 3, 5, 7, 9, 11);

        List<String> collect = Arrays.stream(strArr).map(String::toUpperCase).collect(Collectors.toList());
        List<Integer> collect1 = intList.stream().map(x -> x + 3).collect(Collectors.toList());

        System.out.println("每个元素大写：" + collect);
        System.out.println("每个元素+3：" + collect1);
    }

结果：

每个元素大写：[ABCD, BCDD, DEFDE, FTR]
每个元素+3：[4, 6, 8, 10, 12, 14]

案例二：将员工的薪资全部增加1000。

 private static List<Person> personList = new ArrayList<Person>();

    static {
        personList.add(new Person("Tom", 8900, 28, "male", "New York"));
        personList.add(new Person("Jack", 7000, 18, "male", "Washington"));
        personList.add(new Person("Lily", 7800, 8, "female", "Washington"));
        personList.add(new Person("Anni", 8200, 38, "female", "New York"));
        personList.add(new Person("Owen", 9500, 48, "male", "New York"));
        personList.add(new Person("Alisa", 7900, 68, "female", "New York"));
    }

    @Test
    public void saveSalary() {

        List<Person> collect = personList.stream().map(person -> {
            person.setSalary(person.getSalary() + 1000);
            return person;
        }).collect(Collectors.toList());
        collect.forEach(System.out::println);
    }

结果：

Person(name=Tom, salary=9900, age=28, sex=male, area=New York)
Person(name=Jack, salary=8000, age=18, sex=male, area=Washington)
Person(name=Lily, salary=8800, age=8, sex=female, area=Washington)
Person(name=Anni, salary=9200, age=38, sex=female, area=New York)
Person(name=Owen, salary=10500, age=48, sex=male, area=New York)
Person(name=Alisa, salary=8900, age=68, sex=female, area=New York)

案例三：将两个字符数组合并成一个新的字符数组。

    @Test
    public void str() {
        List<String> list = Arrays.asList("m,k,l,a", "1,3,5,7");

        List<String> collect = list.stream().flatMap(s -> {
            String[] split = s.split(",");
            Stream<String> stream = Arrays.stream(split);
            return stream;
        }).collect(Collectors.toList());

        System.out.println("处理前的集合：" + list);
        System.out.println("处理后的集合：" + collect);
    }

结果：

处理前的集合：[m,k,l,a, 1,3,5,7]
处理后的集合：[m, k, l, a, 1, 3, 5, 7]

本篇文章参考云深i不知处的文章
原文链接：https://blog.csdn.net/mu_wind/article/details/109516995
在这里插入图片描述

一、概述
Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。

Stream将要处理的元素集合看作一种流，在流的过程中，借助Stream API对流中的元素进行操作，比如：筛选、排序、聚合等。

特点：

不是数据结构，不会保存数据。
不会修改原来的数据源，它会将操作后的数据保存到另外一个对象中。
stream具有延迟执行特性，只有调用终端操作时，中间操作才会执行。
二、Stream流的创建
Stream 流可以通过集合和数组进行创建！
1、通过 java.util.Collection.stream() 方法用集合创建流

     List<String> list = Arrays.asList("a", "b", "c");
    //创建一个顺序流
    Stream<String> stream = list.stream();
    //创建一个并行流
    Stream<String> stringStream = list.parallelStream();

2、使用 java.util.Arrays.stream(T[] array) 方法用数组创建流

    int[] arra = {1, 3, 5, 6, 8};
    IntStream stream = Arrays.stream(arra);

3、使用Stream的静态方法：of()、iterate()、generate()

    Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);

    Stream<Integer> limit = Stream.iterate(0, (x) -> x + 3).limit(4);
    limit.forEach(System.out::println);

    Stream<Double> limit1 = Stream.generate(Math::random).limit(3);
    limit1.forEach(System.out::println);

结果：

0
3
6
9
0.8997037806521349
0.4208955236355437
0.5905370762238087

第一种创建方式：stream和parallelStream的简单区分： stream是顺序流，由主线程按顺序对流执行操作，而parallelStream是并行流，内部以多线程并行执行的方式对流进行操作，但前提是流中的数据处理没有顺序要求。例如筛选集合中的奇数，两者的处理不同之处：
在这里插入图片描述
如果流中的数据量足够大，并行流可以加快处速度。
除了直接创建并行流，还可以通过parallel()把顺序流转换成并行流：

Optional findFirst = list.stream()

                            .parallel().filter(x->x>6).findFirst();

三、Stream流的使用
在使用stream之前，先理解一个概念：Optional 。

Optional类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。

3.1 遍历/匹配（foreach/find/match）
Stream也是支持类似集合的遍历和匹配元素的，只是Stream中的元素是以Optional类型存在的。Stream的遍历、匹配非常简单。
在这里插入图片描述

List list = Arrays.asList(7, 6, 9, 3, 8, 2, 1);

    //便利符合条件的字符串
    list.stream().filter(x -> x > 6).forEach(System.out::println);

    //匹配到第一个
    Optional<Integer> first = list.stream().filter(x -> x > 6).findFirst();

    //匹配任意（适用于并行流）
    Optional<Integer> any = list.parallelStream().filter(x -> x > 6).findAny();

    //是否包含特殊条件元素
    boolean b = list.stream().anyMatch(x -> x > 6);

    System.out.println("匹配到第一个 ==> " + first.get());
    System.out.println("匹配任意（适用于并行流） ==> " + any.get());
    System.out.println("是否包含特殊条件元素 ==> " + b);

运行结果：

7
9
8
匹配到第一个 ==> 7
匹配任意（适用于并行流） ==> 7
是否包含特殊条件元素 ==> true

3.2 筛选（filter）
筛选，是按照一定的规则校验流中的元素，将符合条件的元素提取到新的流中的操作。
在这里插入图片描述
案例一：筛选出Integer集合中大于6的元素，并打印出来

     List<Integer> list = Arrays.asList(6,7,3,8,1,2,9);
    Stream<Integer> stream = list.stream();
    stream.filter(x -> x > 7).forEach(System.out::println);

结果：

8
9

案例二：筛选员工中工资高于8000的人，并形成新的集合。形成新集合依赖collect（收集）

private static List personList = new ArrayList();

static {
    personList.add(new Person("Tom", 8900, 28, "male", "New York"));
    personList.add(new Person("Jack", 7000, 18, "male", "Washington"));
    personList.add(new Person("Lily", 7800, 8, "female", "Washington"));
    personList.add(new Person("Anni", 8200, 38, "female", "New York"));
    personList.add(new Person("Owen", 9500, 48, "male", "New York"));
    personList.add(new Person("Alisa", 7900, 68, "female", "New York"));
}

@Test
public void getSalary() {
    List<String> collect = personList.stream()
            .filter(x -> x.getSalary() > 8000)
            .map(Person::getName)
            .collect(Collectors.toList());
    System.out.println("高于8000薪资到人员信息  ==>  " + collect);
}

}
结果：

高于8000薪资到人员信息 ==> [Tom, Anni, Owen]

3.3 聚合（max/min/count)
max、min、count这些字眼你一定不陌生，没错，在mysql中我们常用它们进行数据统计。Java stream中也引入了这些概念和用法，极大地方便了我们对集合、数组的数据统计工作。
在这里插入图片描述
案例一：获取String集合中最长的元素。

@Test
public void listString() {
    List<String> list = Arrays.asList("adnm", "admmt", "pot", "xbangd", "weoujgsd");

    Optional<String> max = list.stream()
            .max(Comparator.comparing(String::length));
    System.out.println("最长的字符串 ==> " + max.get());
}

结果：

最长的字符串 ==> weoujgsd

案例二：获取Integer集合中的最大值。

@Test

public void listInteger() {
    List<Integer> list = Arrays.asList(7, 6, 9, 4, 11, 6);

    Optional<Integer> max = list.stream().max(Integer::compareTo);

    Optional<Integer> max1 = list.stream().max(new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            return o1.compareTo(o2);
        }
    });

    System.out.println("自然排序的最大值 ==> " + max.get());
    System.out.println("自定义排序的最大值 ==> " + max1.get());
}

结果：

自然排序的最大值 ==> 11
自定义排序的最大值 ==> 11

案例三：获取员工工资最高的人。

private static List<Person> personList = new ArrayList<Person>();

static {
    personList.add(new Person("Tom", 8900, 28, "male", "New York"));
    personList.add(new Person("Jack", 7000, 18, "male", "Washington"));
    personList.add(new Person("Lily", 7800, 8, "female", "Washington"));
    personList.add(new Person("Anni", 8200, 38, "female", "New York"));
    personList.add(new Person("Owen", 9500, 48, "male", "New York"));
    personList.add(new Person("Alisa", 7900, 68, "female", "New York"));
}

@Test
public void getMaxSalary() {
    Optional<Person> max = personList.stream()
            .max(Comparator.comparingInt(Person::getSalary));

    System.out.println("最高薪资到人员信息  ==>  " + max.get());
}

结果：

最高薪资到人员信息 ==> Person(name=Owen, salary=9500, age=48, sex=male, area=New York)

案例四：计算Integer集合中大于6的元素的个数。

@Test
public void listIntegerCount() {
    List<Integer> list = Arrays.asList(7, 6, 9, 4, 11, 6);
    long count = list.stream().filter(x -> x > 6).count();

    System.out.println("list中大于6的元素个数 ==> " + count);
}

结果：

list中大于6的元素个数 ==> 3

3.4 映射(map/flatMap)
映射，可以将一个流的元素按照一定的映射规则映射到另一个流中。分为map和flatMap：

map:接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
flatMap:接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。
在这里插入图片描述
在这里插入图片描述
案例一：英文字符串数组的元素全部改为大写。整数数组每个元素+3。

@Test
public void map() {
    String[] strArr = { "abcd", "bcdd", "defde", "fTr" };
    List<Integer> intList = Arrays.asList(1, 3, 5, 7, 9, 11);

    List<String> collect = Arrays.stream(strArr).map(String::toUpperCase).collect(Collectors.toList());
    List<Integer> collect1 = intList.stream().map(x -> x + 3).collect(Collectors.toList());

    System.out.println("每个元素大写：" + collect);
    System.out.println("每个元素+3：" + collect1);
}

结果：

每个元素大写：[ABCD, BCDD, DEFDE, FTR]
每个元素+3：[4, 6, 8, 10, 12, 14]

案例二：将员工的薪资全部增加1000。

private static List personList = new ArrayList();

static {
    personList.add(new Person("Tom", 8900, 28, "male", "New York"));
    personList.add(new Person("Jack", 7000, 18, "male", "Washington"));
    personList.add(new Person("Lily", 7800, 8, "female", "Washington"));
    personList.add(new Person("Anni", 8200, 38, "female", "New York"));
    personList.add(new Person("Owen", 9500, 48, "male", "New York"));
    personList.add(new Person("Alisa", 7900, 68, "female", "New York"));
}

@Test
public void saveSalary() {

    List<Person> collect = personList.stream().map(person -> {
        person.setSalary(person.getSalary() + 1000);
        return person;
    }).collect(Collectors.toList());
    collect.forEach(System.out::println);
}

结果：

Person(name=Tom, salary=9900, age=28, sex=male, area=New York)
Person(name=Jack, salary=8000, age=18, sex=male, area=Washington)
Person(name=Lily, salary=8800, age=8, sex=female, area=Washington)
Person(name=Anni, salary=9200, age=38, sex=female, area=New York)
Person(name=Owen, salary=10500, age=48, sex=male, area=New York)
Person(name=Alisa, salary=8900, age=68, sex=female, area=New York)

案例三：将两个字符数组合并成一个新的字符数组。

@Test
public void str() {
    List<String> list = Arrays.asList("m,k,l,a", "1,3,5,7");

    List<String> collect = list.stream().flatMap(s -> {
        String[] split = s.split(",");
        Stream<String> stream = Arrays.stream(split);
        return stream;
    }).collect(Collectors.toList());

    System.out.println("处理前的集合：" + list);
    System.out.println("处理后的集合：" + collect);
}

结果：

处理前的集合：[m,k,l,a, 1,3,5,7]
处理后的集合：[m, k, l, a, 1, 3, 5, 7]
Markdown 8474 字数 286 行数当前行 1, 当前列 0HTML 6655 字数 206 段落

Jdk8 之 Stream流详细用法(一)

一、概述

二、Stream流的创建

三、Stream流的使用

3.1 遍历/匹配（foreach/find/match）

3.2 筛选（filter）

3.3 聚合（max/min/count)

3.4 映射(map/flatMap)

热门文章

最新文章

相关电子书

相关实验场景