3.1_27 JavaSE-JDK8新特性 P3 【Optional容器类】处理null值

已于 2022-04-28 17:32:25 修改
阅读量767 收藏
点赞数
文章标签： 容器 jdk1.8
于 2022-01-14 12:17:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43529621/article/details/122329198
版权

相关链接

目录

数据准备

通过案例，使用Optional对模拟数据进行一系列处理，熟悉Optional各常用方法

1. pom.xml 配置文件  参考笔记 -> 六、lombok插件

    <dependencies>
       <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>4.1.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
        </dependency>
    </dependencies>

2. Employee 实体类

package com.groupies.jdk8.day03.po;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @author GroupiesM
 * @date 2022/01/12
 * @introduction 员工类
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Employee {
    private Integer id;
    private String name;
    private Integer age;
    private Double salary;
}

3. OptionalService 服务类，提供初始化数据方法

package com.groupies.jdk8.day03.service;

import com.groupies.jdk8.day03.po.Employee;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

@Service
public class OptionalService {
    /**
     * @return 初始化数据
     */
    public static List<Optional<Employee>> getEmployee() {
        //员工列表
        Employee employee3 = new Employee(null, "张三", 20, 6666.66D);
        Employee employee4 = new Employee(4, "赵四", 26, 3000D);
        Employee employee5 = new Employee(5, "王五", 55, 6000D);

        ArrayList<Optional<Employee>> list = new ArrayList<>();
        list.add(Optional.of(employee3));
        list.add(Optional.of(employee4));
        list.add(Optional.of(employee5));
        return list;
    }
}

1 概述

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

  常用方法：

|id| 方法名 | 方法作用 | 请求参数 |返回值类型 |
|:–|:–|:–|:–|:–|:–|
| 1 | Optional.of | 创建 Optional 类
静态方法，创建一个 Optional 实例 | T value |Optional<T>
| 2 | Optional.empty | 创建 Optional 类
静态方法，创建一个 Optional 空实例 | - |Optional<T>
| 3 | Optional.ofNullable | 创建 Optional 类
静态方法
1. 入参 T 为null， 创建 Optional 空实例
2. 入参 T 不为null，创建 Optional 实例 | T| Optional<T>
| 4 | get | 获取对象
对于 Optional<T> 对象，通过get方法可以得到 T
其中 T 不能为空，否则会抛出异常 java.util.NoSuchElementException | - | T
| 5 | isPresent | 是否为空
1. 调用对象为null， 返回 false
2. 调用对象不为null，返回 true | - | boolean
| 6 | ifPresent | 安全消费值
1. 调用对象为null， 什么都不做
2. 调用对象不为null，通过Consumer接口（消费型接口）对其进行消费 | Consumer<? extends T> | void
| 7 | orElse | 获取对象/指定值
1. 调用对象为null， 返回 T
2. 调用对象不为null，返回 调用对象

注意： 无论optional是否有值，orElse都会被执行| T| T 或
Object
| 8 | orElseGet | 获取对象/指定值
1. 调用对象为null， 返回 Supplier提供的返回值
2. 调用对象不为null，返回 调用对象

注意： 只有optional为空时，orElseGet才会被执行| Supplier<? extends T> | T 或
Supplier提供的返回值
| 9 | orElseThrow | 获取对象/指定值
1. 调用对象为null， 抛出 X 异常
2. 调用对象不为null，返回 调用对象

注意： 只有optional为空时，orElseThrow才会被执行| Supplier<? extends X> throws X|<X extends Throwable> T
| 10 | filter | 过滤
1. Predicate结果为true， 返回调用对象
2. Predicate结果为false，返回Optional.empty()| Predicate<? super T>|Optional<T> 或
Optional.empty();
| 11 | map | 转换
1. 调用对象为null， 返回 Optional.empty()
2. 调用对象不为null，通过Function接口（函数型接口）对其进行处理，返回 Optional<任意值> | Function<? super T, ? extends U> |Optional<U> 或
Optional.empty();
| 12 | flatMap | 转换
1. 调用对象为null， 返回 Optional.empty()
2. 调用对象不为null，通过Function接口（函数型接口）对其进行处理，返回 Optional<任意值> | Function<? super T, Optional<U>> |Optional<U>
map与flatMap的区别：
 1. 请求参数：
  map：  Function接口返回 任意类型 参数。
  flatMap：Function接口返回 Optional类型 参数。
 2. 返回值：
  map：  Function接口返回的参数，再 额外包装一层Optional。
  flatMap：Function接口返回参数。
 3. 结论： 简单理解，返回值类型为Optional<T>时使用flatMap，返回值为其他类型时使用map。

2 常用方法

案例1 Optional.of 创建实例

|id| 方法名 | 方法作用 | 请求参数 |返回值类型 |
|:–|:–|:–|:–|:–|:–|
| 1 | Optional.of | 创建 Optional 类
静态方法，创建一个 Optional 实例 | T value |Optional<T>

案例代码一  Optional.of 创建实例

package com.groupies.jdk8.day03.practice;
import com.groupies.jdk8.day03.po.Employee;
import java.util.Optional;

/**
 * @author GroupiesM
 * @date 2022/01/12
 * @introduction Optional.of
 */
public class Demo1OptionalOf {
    public static void main(String[] args) {
        Optional<Employee> opt = Optional.of(new Employee());
    }
}

案例2 Optional.empty 创建空实例

|id| 方法名 | 方法作用 | 请求参数 |返回值类型 |
|:–|:–|:–|:–|:–|:–|
| 2 | Optional.empty | 创建 Optional 类
静态方法，创建一个 Optional 空实例 | - |Optional<T>

案例代码二  Optional.empty 创建空实例

package com.groupies.jdk8.day03.practice;
import java.util.Optional;

/**
 * @author GroupiesM
 * @date 2022/01/12
 * @introduction Optional.empty
 */
public class Demo2OptionalEmpty {
    public static void main(String[] args) {
        Optional<Object> opt = Optional.empty();
    }
}

案例3 Optional.ofNullable 有则创建/无则empty()

|id| 方法名 | 方法作用 | 请求参数 |返回值类型 |
|:–|:–|:–|:–|:–|:–|
| 3 | Optional.ofNullable | 创建 Optional 类
静态方法
1. 入参 T 为null， 创建 Optional 空实例
2. 入参 T 不为null，创建 Optional 实例 | T| Optional<T>
案例代码三  Optional.ofNullable 有则创建/无则empty()

package com.groupies.jdk8.day03.practice;
import com.groupies.jdk8.day03.po.Employee;
import java.util.Optional;

/**
 * @author GroupiesM
 * @date 2022/01/12
 * @introduction Optional.ofNullable
 */
public class Demo3OptionalOfNullable {
    public static void main(String[] args) {
        //1. 入参 T 为null， 创建 Optional 空实例
        Employee emp1 = null;
        Optional<Object> opt1 = Optional.ofNullable(emp1);
        System.out.println(opt1);//Optional.empty

        //2. 入参 T 不为null，创建 Optional 实例
        Employee emp2 = new Employee();
        Optional<Object> opt2 = Optional.ofNullable(emp2);
        System.out.println(opt2);//Optional[Employee(id=null, name=null, age=null, salary=null)]
    }
}

案例4 get 获取对象

|id| 方法名 | 方法作用 | 请求参数 |返回值类型 |
|:–|:–|:–|:–|:–|:–|
| 4 | get | 获取对象
对于 Optional<T> 对象，通过get方法可以得到 T
其中 T 不能为空，否则会抛出异常 java.util.NoSuchElementException | - | T

案例代码四  Optional.get 获取对象

package com.groupies.jdk8.day03.practice;
import com.groupies.jdk8.day03.po.Employee;
import java.util.Optional;

/**
 * @author GroupiesM
 * @date 2022/01/12
 * @introduction Optional.get
 */
public class Demo4OptionalGet {
    public static void main(String[] args) {
		//对于 Optional<T> 对象，通过get方法可以得到 T
        Employee emp1 = new Employee();
        Optional<Object> opt1 = Optional.ofNullable(emp1);
        System.out.println(opt1.get());//Employee(id=null, name=null, age=null, salary=null)

		//其中 T 不能为空，否则会抛出异常 java.util.NoSuchElementException
        Employee emp2 = null;
        Optional<Object> opt2 = Optional.ofNullable(emp2);
        System.out.println(opt2.get());//Exception in thread "main" java.util.NoSuchElementException: No value present
    }
}

案例5 isPresent 是否为空

|id| 方法名 | 方法作用 | 请求参数 |返回值类型 |
|:–|:–|:–|:–|:–|:–|
| 5 | isPresent | 是否为空
1. 调用对象为null， 返回 false
2. 调用对象不为null，返回 true | - | boolean

案例代码五  Optional.isPresent 是否为空

package com.groupies.jdk8.day03.practice;
import com.groupies.jdk8.day03.po.Employee;
import java.util.Optional;

/**
 * @author GroupiesM
 * @date 2022/01/12
 * @introduction Optional.isPresent
 */
public class Demo5OptionalIsPresent {
    public static void main(String[] args) {
        //1. 调用对象为null，返回 false
        Optional<Object> opt1 = Optional.empty();
        System.out.println(opt1.isPresent());//false

        //2. 调用对象不为null，返回 true
        Optional<Object> opt2 = Optional.ofNullable(new Employee());
        System.out.println(opt2.isPresent());//true
    }
}

案例6 ifPresent 有则Consumer/无则跳过

|id| 方法名 | 方法作用 | 请求参数 |返回值类型 |
|:–|:–|:–|:–|:–|:–|
| 6 | ifPresent | 安全消费值
1. 调用对象为null， 什么都不做
2. 调用对象不为null，通过Consumer接口（消费型接口）对其进行消费 | Consumer<? extends T> | void
案例代码六  Optional.ifPresent 有则Consumer/无则跳过

package com.groupies.jdk8.day03.practice;
import com.groupies.jdk8.day03.po.Employee;
import java.util.Optional;

/**
 * @author GroupiesM
 * @date 2022/01/12
 * @introduction Optional.ifPresent
 */
public class Demo6OptionalIfPresent {
    public static void main(String[] args) {
        //1. 调用对象为null，什么都不做
        Optional<Object> opt1 = Optional.empty();
        opt1.ifPresent(o -> System.out.println(o + " 来消费了"));//

        //2. 调用对象不为null，通过Consumer接口（消费型接口）对其进行消费
        Optional<Object> opt2 = Optional.ofNullable(new Employee());
            //Employee(id=null, name=null, age=null, salary=null) 来消费了
        opt2.ifPresent(o -> System.out.println(o + " 来消费了"));
    }
}

案例7 orElse 有则获取/无则Object

|id| 方法名 | 方法作用 | 请求参数 |返回值类型 |
|:–|:–|:–|:–|:–|:–|
| 7 | orElse | 获取对象/指定值
1. 调用对象为null， 返回 T
2. 调用对象不为null，返回 调用对象

注意： 无论optional是否有值，orElse都会被执行| T| T 或
Object
案例代码七  Optional.orElse 有则获取/无则Object

package com.groupies.jdk8.day03.practice;
import com.groupies.jdk8.day03.po.Employee;
import java.util.Optional;

/**
 * @author GroupiesM
 * @date 2022/01/12
 * @introduction Optional.orElse
 */
public class Demo7OptionalOrElse {
    public static void main(String[] args) {
        //1. 调用对象为null，返回 T
        Optional<Object> opt1 = Optional.empty();
        Object o1 = opt1.orElse(function());
        System.out.println(o1);//function方法执行了：0

        //2. 调用对象不为null，返回 调用对象
        Optional<Object> opt2 = Optional.of(new Employee());
        Object o2 = opt2.orElse(function());
        System.out.println(o2);//function方法执行了：Employee(id=null, name=null, age=null, salary=null)
    
        //3. orElse也可以直接传入Object类型参数
        Object o = opt2.orElse(0);
    }
	
	//注意： 无论optional是否有值，orElse都会被执行
    public static Object function() {
        System.out.print("function方法执行了：");
        return 0;
    }
}

案例8 orElseGet 有则获取/无则Supplier

|id| 方法名 | 方法作用 | 请求参数 |返回值类型 |
|:–|:–|:–|:–|:–|:–|
| 8 | orElseGet | 获取对象/指定值
1. 调用对象为null， 返回 Supplier提供的返回值
2. 调用对象不为null，返回 调用对象

注意： 只有optional为空时，orElseGet才会被执行| Supplier<? extends T> | T 或
Supplier提供的返回值

案例代码八  Optional.orElseGet 有则获取/无则Supplier

package com.groupies.jdk8.day03.practice;
import com.groupies.jdk8.day03.po.Employee;
import java.util.Optional;

/**
 * @author GroupiesM
 * @date 2022/01/12
 * @introduction Optional.orElseGet
 */
public class Demo8OptionalOrElseGet {
    final private static Employee admin = new Employee(0, "Administrator", 0, 0d);

    public static void main(String[] args) {
        //1. 调用对象为null，返回 T
        Optional<Object> opt1 = Optional.empty();
        System.out.println(opt1.orElseGet(() -> {
            System.out.print("Optional对象为空===");
            return admin;
        }));//Optional对象为空===Employee(id=0, name=Administrator, age=0, salary=0.0)

        //2. 调用对象不为null，返回 调用对象
        Optional<Object> opt2 = Optional.of(new Employee());
        System.out.println(opt2.orElseGet(() -> {
            System.out.println("Optional对象为空");
            return admin;
        }));//Employee(id=null, name=null, age=null, salary=null)
    }
}

案例9 orElseThrow 有则获取/无则异常

|id| 方法名 | 方法作用 | 请求参数 |返回值类型 |
|:–|:–|:–|:–|:–|:–|
| 9 | orElseThrow | 获取对象/指定值
1. 调用对象为null， 抛出 X 异常
2. 调用对象不为null，返回 调用对象

注意： 只有optional为空时，orElseThrow才会被执行| Supplier<? extends X> throws X|<X extends Throwable> T
案例代码九  Optional.orElseThrow 有则获取/无则异常

package com.groupies.jdk8.day03.practice;
import com.groupies.jdk8.day03.po.Employee;
import java.util.Optional;
import java.util.function.Supplier;

/**
 * @author GroupiesM
 * @date 2022/01/12
 * @introduction Optional.orElseThrow
 */
public class Demo9OptionalOrElseThrow {
    public static void main(String[] args) throws Throwable {
        //2. 调用对象不为null，返回 调用对象
        Optional<Object> opt2 = Optional.of(new Employee());
        System.out.println(opt2.orElseThrow((Supplier<Throwable>) () -> {
            System.out.print("orElseThrow方法执行了：");
            return new RuntimeException("Optional对象不能为空");
        }));//Employee(id=null, name=null, age=null, salary=null)

        //1. 调用对象为null，返回 T
        Optional<Object> opt1 = Optional.empty();
        System.out.println(opt1.orElseThrow((Supplier<Throwable>) () -> {
            System.out.print("orElseThrow方法执行了：");
            return new RuntimeException("Optional对象不能为空");
        }));//orElseThrow方法执行了：Exception in thread "main" java.lang.RuntimeException: Optional对象不能为空
    }
}

案例10 filter 过滤

|id| 方法名 | 方法作用 | 请求参数 |返回值类型 |
|:–|:–|:–|:–|:–|:–|
| 10 | filter | 过滤
1. Predicate结果为true， 返回调用对象
2. Predicate结果为false，返回Optional.empty()| Predicate<? super T>|Optional<T> 或
Optional.empty();
需求： 过滤 id不为null 的员工，并打印

处理前：

Optional[Employee(id=null, name=张三, age=20, salary=6666.66)]
Optional[Employee(id=4, name=赵四, age=26, salary=3000.0)]
Optional[Employee(id=5, name=王五, age=55, salary=6000.0)]

处理后：

Optional.empty
Optional[Employee(id=4, name=赵四, age=26, salary=3000.0)]
Optional[Employee(id=5, name=王五, age=55, salary=6000.0)]

案例代码十  filter 过滤

package com.groupies.jdk8.day03.practice;

import com.groupies.jdk8.day03.po.Employee;
import com.groupies.jdk8.day03.service.OptionalService;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

/**
 * @author GroupiesM
 * @date 2022/01/12
 * @introduction
 */
public class Demo10OptionalFilter {
    @Autowired
    private static OptionalService optionalService;

    public static void main(String[] args) {
        List<Optional<Employee>> list = optionalService.getEmployee();
        System.out.println("=====处理前=====");
        list.forEach(System.out::println);

        List<Optional<Employee>> collect = list.stream()
                //如果Optional<Employee>中Employee的id为空,则返回Optional.empty
                .map(optional -> optional.filter(employee -> employee.getId() != null))
                .collect(Collectors.toList());

        System.out.println("=====处理后=====");
        collect.forEach(System.out::println);
    }
}

案例11 map 任意类型 转为 Optional

|id| 方法名 | 方法作用 | 请求参数 |返回值类型 |
|:–|:–|:–|:–|:–|:–|
| 11 | map | 转换
1. 调用对象为null， 返回 Optional.empty()
2. 调用对象不为null，通过Function接口（函数型接口）对其进行处理，返回 Optional<任意值> | Function<? super T, ? extends U> |Optional<U> 或
Optional.empty();
案例代码十一  Optional.map 任意类型 转为 Optional

package com.groupies.jdk8.day03.practice;
import java.util.Optional;

/**
 * @author GroupiesM
 * @date 2022/01/12
 * @introduction Optional.map
 */
public class Demo11OptionalMap {
    public static void main(String[] args) {
        Optional<Object> opt = Optional.of("abc");
        Optional<Integer> res1 = opt.map((o) -> 5);
        Optional<Optional<Integer>> res2 = opt.map((o) -> Optional.of(5));
        System.out.println(res1);//Optional[5]
        System.out.println(res2);//Optional[Optional[5]]
    }
}

案例12 flatMap Optional 转为 Optional

|id| 方法名 | 方法作用 | 请求参数 |返回值类型 |
|:–|:–|:–|:–|:–|:–|
| 12 | flatMap | 转换
1. 调用对象为null， 返回 Optional.empty()
2. 调用对象不为null，通过Function接口（函数型接口）对其进行处理，返回 Optional<任意值> | Function<? super T, Optional<U>> |Optional<U>
案例代码十二  Optional.flatMap Optional 转为 Optional

package com.groupies.jdk8.day03.practice;

import java.util.Optional;

/**
 * @author GroupiesM
 * @date 2022/01/12
 * @introduction Optional.filter
 */
public class Demo12OptionalFlatMap {
    public static void main(String[] args) {
        Optional<Object> opt = Optional.of("abc");
        Optional<Integer> res = opt.flatMap((o) -> Optional.of(5));
        System.out.println(res);//Optional[5]
    }
}

22/01/14

M

GroupiesM
关注
JDK8-Java8-JavaSE8新特性和增强功能-第一部
06-18
熟悉JDK8新特性和库对Android开发(基于Java语言)更加得心应手。 5. 熟悉JDK8新特性能方便进行Java底层开发,比如Spring MVC. 6. IDE目前基于轻便的VSCode开发说明, 也可以自行通过IDEAJ建立项目运行。
JavaSE--jdk-8u25-linux-x64.rar
11-18
6. **Optional类**：一个容器对象，可能包含或者不包含非null值。设计目的是为了防止NullPointerException，鼓励更清晰的代码编写。 7. **新的类型接口**：例如java.util.function包中的函数式接口，如Predicate、...
Optional用法与争议点
fm18771120556的博客
11-06 412
要说Java中什么异常最容易出现，我想NullPointerException一定当仁不让，为了解决这种null值判断问题，Java8中提供了一个新的工具类Optional，用于提示程序员注意null值，并在特定场景中简化代码逻辑。
Java8新特性之consumer的用法
热门推荐
qq_36893229的博客
02-10 1万+
consumer是一个函数式接口（可以采用lambda写法），它的源码如下 @FunctionalInterface public interface Consumer<T> { void accept(T t); default Consumer<T> andThen(Consumer<? super T> after) { Objects.requireNonNull(after); return (T t) -&
java增效系列—jdk8新特性之Optional优雅处理null值情况
qq_45740561的博客
07-18 551
Optional 三种创建optional对象方式 public void test01(){ // 1.创建空optional Optional.empty(); // 2.使用非null值创建optional对象，使用null会报错 Optional.of("test"); // 3.可以使用任意值创建 Optional.ofNullable(null); } 正常引用和引用缺失情况下的使用 public void test01() { Op
使用Java 8 Optional避免空指针异常
weixin_34354173的博客
01-11 340
Optional可以让你的代码具有可读性，且会避免出现空指针异常。 都说没有遇到过空指针异常的程序员不是Java程序员，null确实引发过很多问题。Java 8中引入了一个叫做java.util.Optional的新类可以避免null引起的诸多问题。 我们看看一个null引用能导致哪些危害。首先创建一个类Computer，结构如下图所示: Computer类模型 当我们调用如下代码会怎样？ S...
3.1_24 JavaSE-JDK8新特性
GroupiesM的博客
02-11 225
目录
3.1_28_1 JDK8新特性【Date】之DayOfWeek 星期枚举
GroupiesM的博客
02-11 1095
5. 新API详解 id=2 DayOfWeek 星期枚举
3.1_28_4 JDK8新特性【Date】之ZoneId 时区信息
GroupiesM的博客
02-11 928
5. 新API详解 id=16 ZoneId 时区信息
3.1_28_5 JDK8新特性【Date】之ChronoField 时间结界
GroupiesM的博客
02-10 993
5. 新API详解 id=24 ChronoField 时间结界
3.1_28_3 JDK8新特性【Date】之ChronoUnit 时间单位枚举
GroupiesM的博客
02-11 604
5. 新API详解 id=14 ChronoUnit 时间单位枚举
JDK7-Java7-JavaSE7新特性和增强功能-第一部
06-18
熟悉JDK7新特性和库对Android开发(基于Java语言)更加得心应手。 5. 熟悉JDK7新特性能方便进行Java底层开发,比如Spring MVC. 6. IDE目前基于轻便的VSCode开发说明, 也可以自行通过IDEAJ建立项目运行。
jdk1.8 java官网正式版Windows 64位-jdk-8u202-windows-x64.exe
11-27
JDK 1.8引入了许多重要的新特性，提升了开发效率和程序性能。其中最显著的是Lambda表达式，这是一种函数式编程的概念，使得开发者能够更简洁地处理集合数据和并行操作。此外，新添加的Stream API简化了对集合对象的...
Jdk8下载(附：官网下载地址)
03-07
7. **Optional类**：为了解决null引用的问题，Java 8引入了`Optional`类，它是一个容器对象，可能包含或不包含非null值。如果值存在则`isPresent()`返回true，调用`get()`会返回该对象。 8. **类型推断的改进**：...
【赵渝强老师】K8s的DaemonSets控制器
赵渝强老师CSDN博客主页
09-21 856
DaemonSet控制器相当于在节点上启动了一个守护进程。通过使用DaemonSet可以确保一个Pod的副本运行在 Node节点上。如果有新的Node节点加入集群，DaemonSet也会自动给新加入的节点增加一个Pod的副本；反之，当有Node节点从集群中移除时，DaemonSet也可以保证将这些Pod自动回收。当删除 DaemonSet将会删除它创建的所有Pod。Kubernetes允许在节点上针对不同的类型的守护进程单独启动一个DaemonSet；
配置中心.zip
最新发布
09-24
配置中心
基于java的物流管理系统报告的开题报告.docx
09-24
基于java的物流管理系统报告的开题报告.docx
企业级SpringCould脚手架工程：Eureka、Ribbon、Hystrix、Zuul、Feign、分布式事务.zip
09-24
企业级SpringCould脚手架工程：Eureka、Ribbon、Hystrix、Zuul、Feign、分布式事务、分布式锁、
https://www.oracle.com/java/technologies/javase/javase-jdk8-downloads.html
03-16
这是Oracle官网上Java SE 8的下载页面，其中提供了Java SE 8开发工具包（JDK）和Java SE 8运行时环境（JRE）的下载链接。用户可以根据自己的需要选择不同的平台和版本进行下载安装。注意，Java SE 8已经不再接收免费...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值