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 + '\'' +
                '}';
    }
}
相关推荐
zzu123zsw1 小时前
把条件校验收敛到枚举接口：Spring Boot 统一断言模式与零污染异常切面工程化
java·spring boot·后端·架构设计
SL_staff1 小时前
计划系统落地难？从开发者视角重构执行入口体验
java·开源·全栈
鬼手点金1 小时前
单轮对话：最简单的 API 调用
java·服务器·前端·javascript·react.js·servlet·tomcat
牛牛牌蜡笔小新2 小时前
Java-常用类库
java·开发语言
Wang's Blog2 小时前
Java 项目实战: 交友项目 - MongoDB集群：概述
java·mongodb·交友
wangchunyu1142 小时前
JAVA ThreadLocal、伪共享与Disruptor
java
慧都小项2 小时前
图解 MyEclipse Deployment Assembly：资源如何进入部署产物？
java·ide·tomcat·maven·myeclipse·部署排查
Wang's Blog2 小时前
Java 项目实战: 交友项目 - MongoDB基础总结与自检清单
java·mongodb·交友
鬼手点金2 小时前
消息的四种角色
java·前端·人工智能·git·深度学习
热门推荐
01国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）02如何新建文件夹？ 电脑新建文件夹的4种方法03ai安全工具:CyberStrikeAI安装部署与使用04GitHub 镜像站点05历年考研数学一、数学二、数学三真题试卷及答案PDF06几个好用的ip纯净度检测网站07昇腾910B系列芯片完全指南：四款型号对比、服务器选型与大模型部署实战08苹果iPA游戏软件资源下载网站09Windows 10/11 如何退出微软账户并改用本地账户登录（含找不到选项的解决方法）10乙二醇水溶液物性参数