java8集合的新特性_流(Stream)

最新推荐文章于 2024-04-28 18:26:07 发布
最新推荐文章于 2024-04-28 18:26:07 发布
阅读量598 收藏 1
点赞数
分类专栏： java基础 文章标签： java 数据库 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/adminwxc/article/details/131002870
版权

java集合Stream流的详细介绍及使用

1、什么是Stream流

Java8提供的stream API可以让程序员像操作数据库一样操作集合。Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。同时它提供串行和并行两种模式进行汇聚操作，并发模式能够充分利用多核处理器的优势，使用 fork/join 并行方式来拆分任务和加速处理过程。通常编写并行代码很难而且容易出错, 但使用 Stream API 无需编写一行多线程的代码，就可以很方便地写出高性能的并发程序。

2、Stream流的特性

a、stream不存储数据，而是按照特定的规则对数据进行计算，一般会输出结果。
b、stream不会改变数据源，通常情况下会产生一个新的集合或一个值。
c、stream具有延迟执行特性，只有调用终端操作时，中间操作才会执行。

3、创建流

    @Test
    public void test(){//创建流
        List<String> list = new ArrayList<>();
        //获取一个顺序流  可以理解成异步 把一个内容分成多个数据块，使用同一个线程按顺序处理每个数据块的流。
        Stream<String> stream = list.stream(); //获取一个顺序流
        //获取一个并行流  可以理解成同步 把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。
        Stream<String> parallelStream = list.parallelStream();
    }

4、基础用法

4.1、遍历(循环)foreach

    @Test
    public void test2(){//遍历循环
        List<Integer> list = Arrays.asList(1,2,3,4,5);
        System.out.println("所有元素：");
        list.stream().forEach( o -> { //o表示循环的对象(根据集合类型  集合类型是对象则o是对象  集合类型是某个字符串  o则是字符串)
            System.out.println(o);
        });
    }

执行结果：
在这里插入图片描述

4.2、过滤(筛选)filter、findFirst

    @Test
    public void test3(){//过滤(筛选)filter、findFirst、findAny
        //filter 过滤
        List<Integer> list = Arrays.asList(1,2,3,4,5);
        System.out.println("大于2的元素：");
        //遍历集合里大于2的每一个元素
        list.stream().filter(x-> x > 2).forEach(System.out::println);

        //findFirst 用于获取第一个满足条件的元素
        System.out.println("获取第一个小于4的元素：");
        Optional<Integer> first = list.stream().filter(x -> x < 4).findFirst();
        System.out.println(first.get());
    }

执行结果：
在这里插入图片描述

4.3、映射(map/flatMap)

映射，可以将一个流的元素按照一定的映射规则映射到另一个流中。分为map和flatMap：
a、map：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
b、flatMap：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。

创建User实体：

package com;

import lombok.Data;

@Data
public class User {

    private String name;

    private Integer age;

    public User(String name,Integer age){
        this.name = name;
        this.age = age;
    }

}

实例：

    @Test
    public void test4(){//映射(map/flatMap)
        List<User> userList = new ArrayList<>();
        userList.add(new User("张三",18));
        userList.add(new User("李四",28));
        userList.add(new User("王五",38));

        //筛选出年龄大于18的员工名称 将User user 映射成o
        List<String> collect = userList.stream()
                //o 表示声明的对象名称 这里 o 相当于 User o = new User() 这里o可以随意命名遵守变量命名规范即可。
                .filter(o -> o.getAge() > 18)
                .map(User::getName)
                .collect(Collectors.toList());

        collect.forEach(System.out::println);

        List<String> list = Arrays.asList("a-s-d-f", "1-3-5-7");
        List<String> listNew = list.stream().flatMap(x -> {
            // 将每个元素转换成一个stream
            String[] split = x.split("-");
            Stream<String> y = Arrays.stream(split);
            return y;
        }).collect(Collectors.toList());

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

    }

执行结果：
在这里插入图片描述

4.4、聚合（max/min/count)

1、count：返回流中元素的总个数
2、max：返回流中元素最大值
3、min：返回流中元素最小值

实例：

    @Test
    public void test5(){//聚合（max/min/count)
        List<User> userList = new ArrayList<>();
        userList.add(new User("张三",18));
        userList.add(new User("李四",28));
        userList.add(new User("王五",38));
        Optional<String> max = userList.stream().max(Comparator.comparing(User::getAge)).map(User::getName);
        Optional<String> min = userList.stream().min(Comparator.comparing(User::getAge)).map(User::getName);
        long count = userList.stream().filter(user -> user.getAge() > 18).count();
        System.out.println("年龄最大的用户："+max.get());
        System.out.println("年龄最小的用户："+min.get());
        System.out.println("年龄大于18的用户数量："+count);
    }

执行结果：
在这里插入图片描述

4.5、归约(reduce)

归约：把一个流缩减成一个值，能实现对集合求和、求乘积和求最值操作。
实例：

   @Test
    public void test6(){//归约(reduce)
        List<User> userList = new ArrayList<>();
        userList.add(new User("张三",18));
        userList.add(new User("李四",28));
        userList.add(new User("王五",38));

        //求所有人年龄总和
        Optional<Integer> min = userList.stream().map(User::getAge).reduce(Integer::min);
        Optional<Integer> max = userList.stream().map(User::getAge).reduce(Integer::max);
        Optional<Integer> sum = userList.stream().map(User::getAge).reduce(Integer::sum);
        System.out.println("年龄最小："+min.get());
        System.out.println("年龄最大："+max.get());
        System.out.println("年龄总和："+sum.get());
    }

执行结果：
在这里插入图片描述

4.6、收集(collect)

收集：可以说是内容最繁多、功能最丰富的部分了。从字面上去理解，就是把一个流收集起来，最终可以是收集成一个值也可以收集成一个新的集合。
实例：

 @Test
    public void test7(){//收集(collect)
        List<User> userList = new ArrayList<>();
        userList.add(new User("张三",18));
        userList.add(new User("李四",28));
        userList.add(new User("王五",38));
        //获取年龄大于18的List集合
        List<User> toList = userList.stream().filter(user -> user.getAge() > 18).collect(Collectors.toList());
        //获取年龄大于18的set集合
        Set<User> toSet = userList.stream().filter(user -> user.getAge() > 18).collect(Collectors.toSet());
        //获取年龄大于18的map集合
        Map<Integer, User> toMap = userList.stream().filter(user -> user.getAge() > 18).collect(Collectors.toMap(User::getAge, user -> user));
        //获取年龄集合
        List<Integer> ageList = userList.stream().map(o -> o.getAge()).collect(Collectors.toList());
        //获取姓名集合
        List<String> nameList = userList.stream().map(o -> o.getName()).collect(Collectors.toList());
        System.out.println("年龄大于18的List集合:"+toList);
        System.out.println("获取年龄大于18的set集合:"+toSet);
        System.out.println("获取年龄大于18的map集合:"+toMap);
        System.out.println("年龄集合:"+ageList);
        System.out.println("姓名集合:"+nameList);
    }

执行结果：
在这里插入图片描述

4.7、统计(count/averaging)

Collectors提供了一系列用于数据统计的静态方法：
计数：count
平均值：averagingInt、averagingLong、averagingDouble
最值：maxBy、minBy
求和：summingInt、summingLong、summingDouble
统计以上所有：summarizingInt、summarizingLong、summarizingDouble
实例：

   @Test
    public void test8(){//统计(count/averaging)
        List<User> userList = new ArrayList<>();
        userList.add(new User("张三",18));
        userList.add(new User("李四",28));
        userList.add(new User("王五",38));

        //员工总数
        Long count = userList.stream().collect(Collectors.counting());
        // 平均年龄
        Double average = userList.stream().collect(Collectors.averagingDouble(User::getAge));
        // 最高年龄
        Optional<Integer> max = userList.stream().map(User::getAge).collect(Collectors.maxBy(Integer::compare));
        // 年龄之和
        Integer sum = userList.stream().collect(Collectors.summingInt(User::getAge));
        // 一次性统计所有信息,包含前面五种
        DoubleSummaryStatistics collect = userList.stream().collect(Collectors.summarizingDouble(User::getAge));

        System.out.println("员工总数：" + count);
        System.out.println("员工平均年龄：" + average);
        System.out.println("员工年龄总和：" + sum);
        System.out.println("员工年龄所有统计：" + collect);
    }

执行结果：
在这里插入图片描述

4.8、分组(partitioningBy/groupingBy)

实例：

    @Test
    public void test9(){//分组
        List<User> userList = new ArrayList<>();
        userList.add(new User("张三",18));
        userList.add(new User("李四",28));
        userList.add(new User("王五",38));

        //是否大于18分组
        Map<Boolean, List<User>> partitioningBy = userList.stream().collect(Collectors.partitioningBy(user -> user.getAge() > 18));
        //按照年龄分组
        Map<Integer, List<User>> groupingBy = userList.stream().collect(Collectors.groupingBy(User::getAge));
        //多条件分组
        Map<Integer, Map<String, List<User>>> collect = userList.stream().collect(Collectors.groupingBy(User::getAge, Collectors.groupingBy(User::getName)));
        System.out.println("partitioningBy:"+partitioningBy);
        System.out.println("groupingBy:"+groupingBy);
        System.out.println("collect:"+collect);

    }

执行结果：
在这里插入图片描述

4.9、接合(joining)

joining:可以将stream中的元素用特定的连接符（没有的话，则直接连接）连接成一个字符串。
实例：

    @Test
    public void test10(){
        List<User> userList = new ArrayList<>();
        userList.add(new User("张三",18));
        userList.add(new User("李四",28));
        userList.add(new User("王五",38));
        //将所有人名称用，隔开
        String collect = userList.stream().map(User::getName).collect(Collectors.joining(","));
        System.out.println(collect);
    }

执行结果：
在这里插入图片描述

4.10、排序(sorted)

实例：

    @Test
    public void test11(){
        List<User> userList = new ArrayList<>();
        userList.add(new User("张三",18));
        userList.add(new User("王五",38));
        userList.add(new User("李四",28));
        //按照年龄排序隔开
        String sorted = userList.stream().sorted(Comparator.comparing(User::getAge)).map(User::getName).collect(Collectors.joining(","));
        String sorted2 = userList.stream().sorted(Comparator.comparing(User::getAge).reversed()).map(User::getName).collect(Collectors.joining(","));
        System.out.println("正序："+sorted);
        System.out.println("倒序："+sorted2);
    }

执行结果：
在这里插入图片描述

5、代码案例(全)

5.1 实体

package com;

import lombok.Data;

@Data
public class User {

    private String name;

    private Integer age;

    public User(String name,Integer age){
        this.name = name;
        this.age = age;
    }

}

5.2 测试类

import com.User;
import org.junit.Test;

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * Stream流的常见用法
 */
public class StreamDemo {

    @Test
    public void test(){//创建流
        List<String> list = new ArrayList<>();
        //获取一个顺序流  可以理解成异步 把一个内容分成多个数据块，使用同一个线程按顺序处理每个数据块的流。
        Stream<String> stream = list.stream(); //获取一个顺序流
        //获取一个并行流  可以理解成同步 把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。
        Stream<String> parallelStream = list.parallelStream();
    }

    @Test
    public void test2(){//遍历循环
        List<Integer> list = Arrays.asList(1,2,3,4,5);
        System.out.println("所有元素：");
        list.stream().forEach( o -> { //o表示循环的对象(根据集合类型  集合类型是对象则o是对象  集合类型是某个字符串  o则是字符串)
            System.out.println(o);
        });
    }

    @Test
    public void test3(){//过滤(筛选)filter、findFirst
        //filter 过滤
        List<Integer> list = Arrays.asList(1,2,3,4,5);
        System.out.println("大于2的元素：");
        //遍历集合里大于2的每一个元素
        list.stream().filter(x-> x > 2).forEach(System.out::println);

        //findFirst 用于获取第一个满足条件的元素
        System.out.println("获取第一个小于4的元素：");
        Optional<Integer> first = list.stream().filter(x -> x < 4).findFirst();
        System.out.println(first.get());
    }

    @Test
    public void test4(){//映射(map/flatMap)
        List<User> userList = new ArrayList<>();
        userList.add(new User("张三",18));
        userList.add(new User("李四",28));
        userList.add(new User("王五",38));

        //筛选出年龄大于18的员工名称 将User user 映射成o
        List<String> collect = userList.stream()
                //o 表示声明的对象名称 这里 o 相当于 User o = new User() 这里o可以随意命名遵守变量命名规范即可。
                .filter(o -> o.getAge() > 18)
                .map(User::getName)
                .collect(Collectors.toList());

        collect.forEach(System.out::println);

        List<String> list = Arrays.asList("a-s-d-f", "1-3-5-7");
        List<String> listNew = list.stream().flatMap(x -> {
            // 将每个元素转换成一个stream
            String[] split = x.split("-");
            Stream<String> y = Arrays.stream(split);
            return y;
        }).collect(Collectors.toList());

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

    }

    @Test
    public void test5(){//聚合（max/min/count)
        List<User> userList = new ArrayList<>();
        userList.add(new User("张三",18));
        userList.add(new User("李四",28));
        userList.add(new User("王五",38));
        Optional<String> max = userList.stream().max(Comparator.comparing(User::getAge)).map(User::getName);
        Optional<String> min = userList.stream().min(Comparator.comparing(User::getAge)).map(User::getName);
        long count = userList.stream().filter(user -> user.getAge() > 18).count();
        System.out.println("年龄最大的用户："+max.get());
        System.out.println("年龄最小的用户："+min.get());
        System.out.println("年龄大于18的用户数量："+count);
    }

    @Test
    public void test6(){//归约(reduce)
        List<User> userList = new ArrayList<>();
        userList.add(new User("张三",18));
        userList.add(new User("李四",28));
        userList.add(new User("王五",38));

        //求所有人年龄总和
        Optional<Integer> min = userList.stream().map(User::getAge).reduce(Integer::min);
        Optional<Integer> max = userList.stream().map(User::getAge).reduce(Integer::max);
        Optional<Integer> sum = userList.stream().map(User::getAge).reduce(Integer::sum);
        System.out.println("年龄最小："+min.get());
        System.out.println("年龄最大："+max.get());
        System.out.println("年龄总和："+sum.get());
    }

    @Test
    public void test7(){//收集(collect)
        List<User> userList = new ArrayList<>();
        userList.add(new User("张三",18));
        userList.add(new User("李四",28));
        userList.add(new User("王五",38));
        //获取年龄大于18的List集合
        List<User> toList = userList.stream().filter(user -> user.getAge() > 18).collect(Collectors.toList());
        //获取年龄大于18的set集合
        Set<User> toSet = userList.stream().filter(user -> user.getAge() > 18).collect(Collectors.toSet());
        //获取年龄大于18的map集合
        Map<Integer, User> toMap = userList.stream().filter(user -> user.getAge() > 18).collect(Collectors.toMap(User::getAge, user -> user));
        //获取年龄集合
        List<Integer> ageList = userList.stream().map(o -> o.getAge()).collect(Collectors.toList());
        //获取姓名集合
        List<String> nameList = userList.stream().map(o -> o.getName()).collect(Collectors.toList());
        System.out.println("年龄大于18的List集合:"+toList);
        System.out.println("获取年龄大于18的set集合:"+toSet);
        System.out.println("获取年龄大于18的map集合:"+toMap);
        System.out.println("年龄集合:"+ageList);
        System.out.println("姓名集合:"+nameList);
    }

    @Test
    public void test8(){//统计(count/averaging)
        List<User> userList = new ArrayList<>();
        userList.add(new User("张三",18));
        userList.add(new User("李四",28));
        userList.add(new User("王五",38));

        //员工总数
        Long count = userList.stream().collect(Collectors.counting());
        // 平均年龄
        Double average = userList.stream().collect(Collectors.averagingDouble(User::getAge));
        // 最高年龄
        Optional<Integer> max = userList.stream().map(User::getAge).collect(Collectors.maxBy(Integer::compare));
        // 年龄之和
        Integer sum = userList.stream().collect(Collectors.summingInt(User::getAge));
        // 一次性统计所有信息,包含前面五种
        DoubleSummaryStatistics collect = userList.stream().collect(Collectors.summarizingDouble(User::getAge));

        System.out.println("员工总数：" + count);
        System.out.println("员工平均年龄：" + average);
        System.out.println("员工年龄总和：" + sum);
        System.out.println("员工年龄所有统计：" + collect);
    }

    @Test
    public void test9(){//分组
        List<User> userList = new ArrayList<>();
        userList.add(new User("张三",18));
        userList.add(new User("李四",28));
        userList.add(new User("王五",38));

        //是否大于18分组
        Map<Boolean, List<User>> partitioningBy = userList.stream().collect(Collectors.partitioningBy(user -> user.getAge() > 18));
        //按照年龄分组
        Map<Integer, List<User>> groupingBy = userList.stream().collect(Collectors.groupingBy(User::getAge));
        //多条件分组
        Map<Integer, Map<String, List<User>>> collect = userList.stream().collect(Collectors.groupingBy(User::getAge, Collectors.groupingBy(User::getName)));
        System.out.println("partitioningBy:"+partitioningBy);
        System.out.println("groupingBy:"+groupingBy);
        System.out.println("collect:"+collect);

    }

    @Test
    public void test10(){
        List<User> userList = new ArrayList<>();
        userList.add(new User("张三",18));
        userList.add(new User("李四",28));
        userList.add(new User("王五",38));
        //将所有人名称用，隔开
        String collect = userList.stream().map(User::getName).collect(Collectors.joining(","));
        System.out.println(collect);
    }

    @Test
    public void test11(){
        List<User> userList = new ArrayList<>();
        userList.add(new User("张三",18));
        userList.add(new User("王五",38));
        userList.add(new User("李四",28));
        //按照年龄排序隔开
        String sorted = userList.stream().sorted(Comparator.comparing(User::getAge)).map(User::getName).collect(Collectors.joining(","));
        String sorted2 = userList.stream().sorted(Comparator.comparing(User::getAge).reversed()).map(User::getName).collect(Collectors.joining(","));
        System.out.println("正序："+sorted);
        System.out.println("倒序："+sorted2);
    }

}
ㅤㅤ 诚ㅤㅤ
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
37 | Java 8流（Stream）
微信号：RunsenLiu
01-24 5737
流是一种用于处理数据的抽象概念，它允许你以一种声明性的方式对数据进行操作。流可以执行一系列的操作来过滤、转换、组合和汇总数据，而不需要显式的循环。流通常用于集合（例如List、Set、Map等）、数组或I/O操作。
Java8处理集合的优雅姿势之Stream
08-26
Java8处理集合的优雅姿势之Stream Java8中引入的Stream API是处理集合的优雅姿势，它提供了一种声明式的方式来处理数据，使程序员能够写出高效率、干净、简洁的代码。本文将详细介绍Stream的基本概念、特性、创建...
Java8 新特性——Stream流
weixin_47203903的博客
12-08 1007
流Stream，可以让你以一种声明的方式处理数据。Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。Stream（流）是一个来自数据源的元素队列并支持聚合操作和以前的Collection操作不同， Stream操作还有两个基础的特征：Stream提供以下功能：在 Java 8 中, 集合接口有两个方法来生成流：stream(
Java 8新特性Stream API与Collectors：探索List集合的高效转换与聚合
最新发布
程序猿的博客
04-28 263
在Java 8中，Stream API的引入极大地提升了对集合数据处理的灵活性和效率，而Collectors类更是为数据的收集和聚合提供了强大的工具。本文将深入探讨如何利用List集合.stream().collect()这一链式调用，实现集合数据的高效转换与聚合，为你的编程之旅增添一抹亮色。
Java基础篇 | Java8流式编程
分享思想，留下痕迹。
10-24 4858
Stream（流）是 Java 8 引入的一个新的抽象概念，它代表着一种处理数据的序列。简单来说，Stream 是一系列元素的集合，这些元素可以是集合、数组、I/O 资源或者其他数据源。Stream API 提供了丰富的操作方法，可以对 Stream 中的元素进行各种转换、过滤、映射、聚合等操作，从而实现对数据的处理和操作。Stream API 的设计目标是提供一种高效、可扩展和易于使用的方式来处理大量的数据。
java8新特性之流（Stream）操作总结
心藏_的博客
08-30 2306
java8新特新之Stream流的操作总结
详细讲解新特性Stream流的使用
m0_64416017的博客
07-01 376
从0到100玩转stream流的概念以及使用，让代码更加优雅
Java8新特性Stream流实例详解
08-29
Java8新特性Stream流实例详解 Java 8 中引入了 Stream 流，用于操作数据源（集合、数组等）所生成的元素序列。Stream 流是数据渠道，具有声明性、可复合、可并行三个特性，使得 Stream 操作更简洁、更灵活、高效。...
java8新特性 stream流的方式遍历集合和数组操作
08-18
Java 8 新特性 Stream 流的方式遍历集合和数组操作 Java 8 中引入了 Stream 流的概念，旨在提供一种更加优雅的方式来遍历集合和数组。Stream 流可以看作是一种 lazy 的数据结构，它可以对集合和数组进行遍历、过滤...
java8新特性Lambda与stream视频教程-文档和代码.rar
10-25
Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以...
Java8新特性Stream的完全使用指南
08-19
Java8新特性Stream的完全使用指南 Stream是Java 1.8版本开始提供的一个接口，主要提供对数据集合使用流的方式进行操作，流中的元素不可变且只会被消费一次，所有方法都设计成支持链式调用。使用Stream API可以极大...
java8 stream四大接口_【JDK8特性】Stream接口详解
weixin_33295562的博客
02-28 733
一、概念普及Java8新添加了一个特性：流Stream。Stream让开发者能够以一种声明的方式处理数据源(集合、数组等)，它专注于对数据源进行各种高效的聚合操作(aggregate operation)和大批量数据操作 (bulk data operation)。Stream API将处理的数据源看做一种Stream(流)，Stream(流)在Pipeline(管道)中传输和运算，支持的运算包含...
Java8新特性之stream流
m0_51014049的博客
03-16 189
Java 8引入的Stream API提供了一种新的处理集合的方式，它可以使代码更加简洁和易读，同时还可以通过并行处理来提高程序的性能。
Java 基础进阶篇（十二）：Stream 流常用方法总结
秀岩的博客
05-07 5099
一、Stream流概述 二、获取 Stream 流 2.1 集合获取 Stream 流 2.2 数组获取 Stream 流 三、中间方法 四、终结方法 五、Stream流的综合应用
Java8新特性：StreamAPI（超详解）
weixin_52533007的博客
03-31 7520
用于操作数据源（集合、数组等）所生成的元素序列。“集合讲的是数据，Stream讲的是计算！Stream关注的是对数据的运算，与CPU打交道，集合关注的是数据的存储，与内存打交道。Stream 自己不会存储元素。Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
Java8 stream流之分组 groupingBy 的使用
热门推荐
suge大帝的博客
06-10 4万+
使用stream流可以让我们的代码看上去很简洁，本文举例了 按照班级分组、分组再过滤、统计分组后人数、嵌套分组、分组排序...
Java8新特性Stream详解
程序员Forlan的博客
12-13 1572
本文详细介绍了Java中的Stream API，包括Stream的定义，操作分类以及具体操作方法。同时，通过综合使用示例，展示了Stream在实际问题解决中的能力。
Java8新特性-Stream
qq_39093474的博客
04-27 473
Stream作为Java8的一大亮点，它与java.io包里的和是完全不同的概念，Stream是对集合的包装，通常和Lambda一起使用，使用stream可以支持许多操作，如 map, filter, limit, sorted, count, min, max, sum, collect 等等。流（Stream)到底是什么呢？是数据渠道，用于操作数据源（集合，数组等）所生成的元素序列。集合讲的是数据，流讲的是计算。Java8中的lambda。
java 集合stream流 详解
u012758488的博客
08-10 2781
Stream distinct() 返回由该流的去重（根据Object.equals(Object) ）之后的不同元素组成的流。static Stream concat(Stream a, Stream b) 合并a和b两个流为一个流。使用默认方法stream()生成流， default Stream stream()中间操作的意思是,执行完此方法之后,Stream流依然可以继续执行其他操作。对数据使用Stream流的方式操作完毕后,可以把流中的数据收集到集合中。...
java 8 的新特性 stream流的使用
05-05
Java 8引入了Stream API，它是一种新的处理集合的方式，可以用更简洁、更易读的代码处理集合数据。Stream API提供了非常方便的、高效的数据处理方式，包括筛选、排序、映射、归约等。 下面是一些Stream的常用操作： 1. filter()：筛选符合条件的元素 ```java List<String> list = Arrays.asList("apple", "orange", "banana", "pear", "peach"); List<String> result = list.stream().filter(str -> str.contains("e")).collect(Collectors.toList()); ``` 2. map()：将元素转换成其他形式或提取信息 ```java List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5); List<Integer> result = nums.stream().map(num -> num * num).collect(Collectors.toList()); ``` 3. sorted()：对元素进行排序 ```java List<Integer> nums = Arrays.asList(5, 3, 1, 2, 4); List<Integer> result = nums.stream().sorted().collect(Collectors.toList()); ``` 4. distinct()：去重 ```java List<Integer> nums = Arrays.asList(1, 2, 3, 3, 4, 4, 5); List<Integer> result = nums.stream().distinct().collect(Collectors.toList()); ``` 5. limit()：截取流中前n个元素 ```java List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5); List<Integer> result = nums.stream().limit(3).collect(Collectors.toList()); ``` 6. skip()：跳过流中前n个元素 ```java List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5); List<Integer> result = nums.stream().skip(3).collect(Collectors.toList()); ``` 7. reduce()：将流中元素归约为一个值 ```java List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5); int result = nums.stream().reduce(0, (a, b) -> a + b); ``` 这些操作只是Stream API中的一部分，还有很多其他操作可以使用。Stream API可以让我们更加方便地处理集合数据，提高开发效率。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值