javaSE8-新特性-Stream&Option

\光辉岁月/2026-10-23 13:25

Java8中有两大最为重要的改变。第一个是Lambda表达式; 另外一个则是Stream API。

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

实际开发中，项目中多数数据源都来自于Mysql，Oracle等。但现在数据源可以更多了，有MongoDB，Redis等，而这些NoSQL的数据就需要Java层面去处理。

Stream和 Collection集合的区别:Collection是一种静态的内存数据结构，而Stream是有关计算的。

Stream介绍

Stream是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。"集合本质是的数据存储，Stream本质的是数据的计算!"

  1. stream自己不会存储元素。

  2. stream不会改变源对象。相反，他们会返回一个持有结果的新Stream。

  3. stream操作是延迟执行的 。与stream操作有关，因为只有终止操作，才会执行中间联操作，并产生结果(如果没有终止操作，中间的 filter、map 根本不会执行), 类似于链式调用。

Stream操作

  1. 创建Stream: 一个数据源（如:集合、数组)，获取一个流
  2. 中间操作: 一个中间操作链，对数据源的数据进行处理
  3. 终止操作(终端操作): **一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用。**如果再想使用，就必须重新在创建stream对象。

创建stream对象

java 复制代码 
public class StreamCreate_ {
    /**
     * 1.通过集合创建stream对象
     */
    @Test
    public void test1() {
        List<Employee> employees = EmployeeData.getEmployees();
        //返回一个顺序流：执行操作数据的时候，是按照数据的顺序单线程操作数据的。
        Stream<Employee> stream = employees.stream();
        //返回一个并行流：执行操作数据的时候，是按照多线程操作数据的。
        Stream<Employee> employeeStream = employees.parallelStream();
    }
    /**
     * 2.通过数组创建stream对象
     */
    @Test
    public void test2(){
        int[] i = {1,2,3,4,5};
        Double[] d = {1d,2d,3d,4d,5d};
        String[] s = {"北京", "上海", "广州"};
        Stream<String> stream1 = Arrays.stream(s);
        Stream<Double> stream2 = Arrays.stream(d);
        IntStream stream = Arrays.stream(i);
        //自定义对象
        Employee emp1 = new Employee(1001, "马化腾", 34, 6000.38);
        Employee emp2 = new Employee(1002, "马云", 32, 6010.38);
        Employee[] empArr = {emp1, emp2};
        Stream<Employee> stream3 = Arrays.stream(empArr);
    }

    /**
     * 3.通过Stream的of()方法创建
     */
    @Test
    public void test3(){
        Employee emp = new Employee(1002, "马腾云", 32, 6010.38);
        Stream<Object> objectStream = Stream.of(1, 112.23, "3", true, "333", emp);
    }

    /**
     * 4.创建无限流对象：类似于造数据
     */
    @Test
    public void test4(){
        //迭代 public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)
        // seed 表示初始值
        // f 是一个函数式接口类型数据
        // Stream.iterate(0, i -> i + 2) 表示可以不断的创造数据2, 4, 6, 8, 10...
        // forEach()表示要消费数据
        // 如果没有limit()会一直执行下去，limit表示只需要前10条
        Stream.iterate(0, i -> i + 2).limit(10).forEach(System.out::println);
        //生成 public static<T> Stream<T> generate(Supplier<T> s)
        Stream.generate(Math::random).limit(10).forEach(System.out::println);
    }
}

中间操作

java 复制代码 
public class StreamOption_ {
    /**
     * 中间操作: 筛选与切片
     */
    @Test
    public void test1() {
        List<Employee> employees = EmployeeData.getEmployees();
        //Stream<T> filter(Predicate<? super T> predicate) ---> 筛选操作
        Stream<Employee> stream = employees.stream();
        stream.filter(emp->emp.getSalary() > 7000).forEach(System.out::println);
        System.out.println("********************************************************");
        //limit(n)--->载断流，使其元素不超过给定数量。顺序流是前3个，如果是并行流就不一定了。
        employees.stream().limit(3).forEach(System.out::println);
        System.out.println("********************************************************");
        //skip(n)---->跳过元素，返回一个扔掉了前n个元素的流。若流中元素不足 n 个，则返回-个空的流
        employees.stream().skip(3).forEach(System.out::println);
        //distinct()---->筛选，通过流所生成元素的hashCode()和 equals()去除重复元素
        Stream.of("true", true, 1, 32, "hello", 1, "hello", true).distinct().forEach(System.out::println);
    }
    /**
     * 中间操作: 映射
     */
    @Test
    public void test2(){
        List<Employee> employees = EmployeeData.getEmployees();
        //map(Function f)--->接收一个函数作为参数，将元素转换成其他形式或提取信息, 该函数会被应用到每个元素上，并将其映射成一个新的元素。
        Stream<Employee> stream = employees.stream();
        //给所有员工涨工资
        //注意：如果 addSalary 直接修改了 Employee 的薪水属性且返回 void，这里的 map 是编译不过的。
        // 如果它返回的是增加后的薪水比如 double，那 Stream 就会从 Stream<Employee> 变成 Stream<Double>。
        // 如果是想修改原对象：
        //   1.让addSalary返回Employee对象
        //   2.map(emp -> { emp.setSalary(emp.getSalary() + 1000); return emp; })
        //   3.直接用 peek()。
        stream.map(emp->emp.addSalary(1000d)).forEach(System.out::println);
        System.out.println("********************************************************");
        Stream<Employee> stream1 = employees.stream();
        stream1.map(emp -> {emp.setSalary(emp.getSalary() + 1000); return emp;}).forEach(System.out::println);
        System.out.println("********************************************************");
        Stream<Hero> stream2 = employees.stream();
        stream2.peek(emp -> emp.setSalary(emp.getSalary() + 1000)).forEach(System.out::println);
        System.out.println("********************************************************");
        //获取员工姓名长度大于3的员工的姓名。
        Stream<String> nameStream = employees.stream().map(Employee::getName);
        nameStream.filter(emp->emp.length() > 3).forEach(System.out::println);
        //flatMap(Function f)---接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。
        // List<String> list = Arrays.asList(new String[]{"aa", "bb", "cc"});
        List<String> list = Arrays.asList("aa", "bb", "cc");
        Stream<Stream<Character>> streamStream = list.stream().map(StreamOption_::fromStringToStream);
        streamStream.forEach(s->{ //传统获取更深层的值比较麻烦
            s.forEach(System.out::println);
        });
        //flatMap主要可以将[Stream<T>,Stream<Stream<T>>]转换成[Stream<T>,Stream<T>,Stream<T>]
        Stream<Character> characterStream = list.stream().flatMap(StreamOption_::fromStringToStream);
        characterStream.forEach(System.out::println);
    }
    
	//将字符串的每个字符放到集合里
    public static Stream<Character> fromStringToStream(String str){
        ArrayList<Character> list = new ArrayList<>();
        for (Character c : str.toCharArray()) {
            list.add(c);
        }
        return list.stream();
    }

    /**
     * 中间操作: 排序
     */
    @Test
    public void test3(){
        //sorted 自然排序
        List<Integer> list = Arrays.asList(12, 43, 65, 34, 87, 0, -98, 7);
        list.stream().sorted().forEach(System.out::println);
        //sorted(Comparator com) ----定制排序
        List<Employee> employees = EmployeeData.getEmployees();
        employees.stream().sorted((e1,e2)->{
            int value = Integer.compare(e1.getAge(), e2.getAge());
            if (value != 0){
                return value;
            }
            return Double.compare(e1.getSalary(), e2.getSalary());
        }).forEach(System.out::println);
    }
}

终止操作

java 复制代码 
public class StreamOption_ {	
	/**
     * 终止操作：匹配与查找
     */
    @Test
    public void test4(){
        List<Employee> employees = EmployeeData.getEmployees();
        //allMatch(Predicate p) 检查是否匹配所有元素。
        boolean b1 = employees.stream().allMatch(e -> e.getAge() > 20);
        System.out.println(b1);
        //anyMatch(Predicate p) 检查是否至少匹配一个元素。
        boolean b2 = employees.stream().anyMatch(e -> e.getSalary() > 10000);
        System.out.println(b2);
        //noneMatch(Predicate p) 检查是否没有匹配的元素。
        boolean b3 = employees.stream().noneMatch(e -> e.getName().startsWith("雷"));
        System.out.println(b3);
        //findFirst 返回第一个元素
        Optional<Employee> first = employees.stream().findFirst();
        System.out.println(first);
        //findAny 返回当前流中的任意元素
        //findAny 几乎总是返回第一个；但如果用了 parallelStream()（并行流），它才会真正随机返回
        Optional<Employee> any = employees.stream().findAny();
        System.out.println(any);
        //count 返回流中元素的总个数
        long count = employees.stream().count();
        System.out.println(count);
        //max(Comparator c) 返回流中最大值
        Optional<Employee> max = employees.stream().max((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
        System.out.println(max);
        //min(Comparator c) 返回流中最小值
        Optional<Employee> min = employees.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
        System.out.println(min);
        //forEach(Consumer c) 内部迭代  使用Collection接口需要用户去做迭代，称为外部迭代
    }

    /**
     * 终止操作：规约
     */
    @Test
    public void test5(){
        //reduce(T iden, BinaryOperator b) 可以将流中元素反复结合起来，得到一个值。返回T
        //map 可以将stream中每一个元素映射为新的元素。reduce可以将映射的元素进行总体操作，最后返回一个值。
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        Integer all = list.stream().reduce(0, Integer::sum);
        System.out.println(all);
        //reduce(Binaryperator b) 可以将流中元素反复结合起来，得到一个值。返回Optional<T>
        List<Employee> employees = EmployeeData.getEmployees();
        Optional<Double> allSalary = employees.stream().map(Employee::getSalary).reduce(Double::sum);
        System.out.println(allSalary);
    }

    /**
     * 终止操作：收集
     */
    @Test
    public void test6(){
        //collect(Collector c) 接口中方法的实现决定了如何对流执行收集的操作(如收集到List、Set、Map)。
        //Collectors 是工具类，Collector 才是接口。
        //另外，Collectors实用类提供了很多静态方法，可以方便地创建常见收集器实例。
        List<Employee> employees = EmployeeData.getEmployees();
        List<Employee> c1 = employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toList());
        // employees.stream().filter(e -> e.getSalary() > 6000).toList()
        c1.forEach(System.out::println);
        System.out.println("**************************************************************");
        Set<Employee> s1 = employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toSet());
        s1.forEach(System.out::println);
    }
}

Collectors实用类提供了很多静态方法，可以方便地创建常见收集器实例。如下表：

方法 返回类型 作用 示例代码
toList List<T> 把流中元素收集到List List<Employee> emps = list.stream().collect(Collectors.toList());
toSet Set<T> 把流中元素收集到Set Set<Employee> emps = list.stream().collect(Collectors.toSet());
toCollection Collection<T> 把流中元素收集到创建的集合 Collection<Employee> emps = list.stream().collect(Collectors.toCollection(ArrayList::new));
counting Long 计算流中元素的个数 long count = list.stream().collect(Collectors.counting());
summingInt Integer 对流中元素的整数属性求和 int total = list.stream().collect(Collectors.summingInt(Employee::getSalary));
averagingInt Double 计算流中元素Integer属性的平均值 double avg = list.stream().collect(Collectors.averagingInt(Employee::getSalary));
summarizingInt IntSummaryStatistics 收集流中Integer属性的统计值。如：平均值 IntSummaryStatistics iss = list.stream().collect(Collectors.summarizingInt(Employee::getSalary));

Optional类

到目前为止，臭名昭著的空指针异常是导致Java应用程序失败的最常见原因。以前，为了解决空指针异常，Google公司著名的Guava项目引入了Optional类，Guava通过使用检查空值的方式来防止代码污染，它鼓励程序员写更干净的代码。受到Google Guava的启发，Optional类已经成为Java 8类库的一部分。

Optional<T>类(java.util.Optional)是一个容器类，它可以保存类型T的值，代表这个值存在。或者仅仅保存null，表示这个值不存在。原来用null表示一个值不存在，现在 Optional可以更好的表达这个概念。并且可以避免空指针异常。

api

Optional提供很多有用的方法，这样我们就不用显式进行空值检测。

创建Optional类对象的方法:

Optional.of(T t):创建一个 Optional实例，t 必须非空;

Optional.empty():创建一个空的Optional 实例

Optional.ofNullable(T t): t 可以为null

判断Optional容器中是否包含对象:

boolean isPresent():判断是否包含对象

void ifPresent(Consumer<? super T> consumer): 如果有值，就执行Consumer接口的实现代码，并且该值会作为参数传给它。

获取Optional容器的对象:

T get():如果调用对象包含值，返回该值，否则抛异常

T orElse(T other):如果有值则将其返回，否则返回指定的other对象。

T orElseGet(Supplier<? extends T>other):如果有值则将其返回，否则返回由Supplier接口实现提供的对象。

T orElseThrow(Supplier<? extends X> exceptionSupplier):如果有值则将其返回，否则抛出由Supplier接口实现提供的异常。

示例：

java 复制代码 
public class OptionalTest {
    /**
     * 创建Optional对象
     */
    @Test
    public void test1() {
        Girl girl = new Girl("小花");
        //Optional.of(T t):创建一个 Optional实例，t 必须非空;
        Optional<Girl> g1 = Optional.of(girl); //这里如果girl为null就会抛异常
        System.out.println(g1);
        //Optional.empty():创建一个空的Optional实例
        //Optional.ofNullable(T t):  t 可以为null
        girl = null; //girl可以为null
        Optional<Girl> g2 = Optional.ofNullable(girl);
        System.out.println(g2);
    }

    /**
     * Optional应用
     */
    @Test
    public void test2(){
        Boy boy = new Boy();
        //下面代码就会抛空指针异常
        String girlName1 = getgirlName1(boy);
        System.out.println(girlName1);
    }

    //空指针异常
    public String getgirlName1(Boy boy){
        // 对于boy.getGirl().getName()代码有可能boy是null，也有可能 boy.getGirl()是null
        // 所以调用可能会包空指针异常
        return boy.getGirl().getName();
    }

    @Test
    public void test3(){
        Boy boy = new Boy();
        String girlName1 = getgirlName2(boy);
        System.out.println(girlName1);
    }

    public String getgirlName2(Boy boy){
        //我们一般的判断
        if (boy != null && boy.getGirl() != null){
            return boy.getGirl().getName();
        }
        return null;
    }


    @Test
    public void test4(){
        Boy boy = new Boy(new Girl("苍老师"));
        boy = null;
        String girlName1 = getgirlName3(boy);
        System.out.println(girlName1);
    }
    /**
     * 使用Optional api
     */
    public String getgirlName3(Boy boy){
        Optional<Boy> boyOptional = Optional.ofNullable(boy);
        Boy b = boyOptional.orElse(new Boy(new Girl("迪丽热巴")));
        Girl girl = b.getGirl();
        Optional<Girl> girlOptional = Optional.ofNullable(girl);
        Girl g = girlOptional.orElse(new Girl("古力娜扎"));
        return g.getName();
    }
}

class Boy {
    private Girl girl;
    public Boy() {}
    public Boy(Girl girl) {
        this.girl = girl;
    }

    public Girl getGirl() {
        return girl;
    }

    public void setGirl(Girl girl) {
        this.girl = girl;
    }

    @Override
    public String toString() {
        return "Boy{" +
                "girl=" + girl +
                '}';
    }
}

class Girl {
    private String name;

    public Girl(){}

    public Girl(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "girl{" +
                "name='" + name + '\'' +
                '}';
    }
}
相关推荐
SL_staff39 分钟前
私有化低代码：面向强监管行业的可控数字化实践
java·低代码
三翼鸟数字化技术团队1 小时前
高性能存储引擎RocksDB：原理与Java生态实践
java
SL_staff2 小时前
JVS-APS有限产能建模的七个刚性支点：面向产线真实约束的技术实现解析
java·开源·全栈
特立独行的猫A2 小时前
少 3 个环节、少 1 次 ABI、少 3500 行代码：cj-tauri 与 Ionic/Capacitor 的鸿蒙桥接机制对比
java·后端·python
学长毕设2 小时前
基于SpringBoot的高校后勤报修管理系统-附源码
java·spring boot·后端
特立独行的猫A2 小时前
cj-tauri vs Rust/Tauri 同款播放器实测：编译 21 秒 vs 11 分钟，磁盘 12 MB vs 1.2 GB
java·后端·python
杨凯凡3 小时前
Spring AI RAG 实战：向量检索、租户过滤、引用溯源与防幻觉边界
java·人工智能·spring
小科先生3 小时前
Java springboot调用数据库的基本流程
java·数据库·spring boot
秋饼4 小时前
GPT-Live 全双工语音 API Java 服务端落地实战：事件协议、会话恢复与生产踩坑
java·ai·技术分享·后端开发
SL_staff4 小时前
为什么企业级自动化不能只靠AI编排？——逻辑引擎在确定性业务场景中的不可替代性
java·开源·产品
热门推荐
01国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）02如何新建文件夹？ 电脑新建文件夹的4种方法03历年考研数学一、数学二、数学三真题试卷及答案PDF04几个好用的ip纯净度检测网站05微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新06昇腾910B系列芯片完全指南：四款型号对比、服务器选型与大模型部署实战07GitHub 镜像站点08蜘蛛磁力 搜索引擎大全，如何使用蜘蛛磁力查找磁力链接09苹果iPA游戏软件资源下载网站10Dify：一站式AI应用开发平台全解析与Windows部署指南