【jdk1.8特性】之Optional

最新推荐文章于 2024-08-12 09:04:32 发布
最新推荐文章于 2024-08-12 09:04:32 发布
阅读量759 收藏 1
点赞数
分类专栏： jdk1.8特性 文章标签： Optional Optional用法 Optional示例 Optional使用示例 jdk1.8特性
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/justry_deng/article/details/96123617
版权

简介：Optional类是jdk1.8开始为我们提供的一个处理null的类。

代码实例说明：

声明：下面只示例介绍jdk1.8里Optional的用法，对于更高版本jdk里对Optional的进一步优化(如果有的话)，
            这里不作介绍。

  • public T get()：如果 Optional中存在值，则返回值，否则抛出 NoSuchElementException。

/**
 * .get()方法 : 如果 Optional中存在值，则返回值，否则抛出 NoSuchElementException
 *
 * @author JustryDeng
 * @date 2019/7/15 20:49
 */
@Test(expected = NoSuchElementException.class)
public void testFour() {
    Optional<?> optional = Optional.empty();
    optional.get();
}

  • public static <T> Optional<T> of(T value)：获得持有value的Optional实例。

/**
 * .of(instance)方法 : 获得持有instance的Optional实例
 *
 * 注:instance不能为null
 *
 * @author JustryDeng
 * @date 2019/7/15 20:49
 */
@Test
public void testOne() {
    Staff staff = Staff.builder().name("员工9527").age(123).staffNo("NO.1").build();
    Optional<Staff> optional = Optional.of(staff);
    Assert.assertEquals(optional.get(), staff);
}

  • public static <T> Optional<T> ofNullable(T value)：获得持有value的Optional实例。

/**
 * .ofNullable(instance)方法 : 获得持有instance的Optional实例
 *
 * 注:instance可以为null,为null时，获得的就是Optional.empty()
 *
 * @author JustryDeng
 * @date 2019/7/15 20:49
 */
@Test(expected = NoSuchElementException.class)
public void testTwo() {
    Optional<Staff> optional = Optional.ofNullable(null);
    // 当optional不持有值的时候，调用 optional.get()方法会抛出NoSuchElementException
    // 注:Optional.empty()方法获得的Optional实例，就是不持有值的Optional实例
    optional.get();
}

  • public boolean isPresent()：判断optional持有的值是否为null(即：判断Optional是否持有值)。

/**
 * .isPresent()方法 : 判断optional持有的值是否为null(即:判断Optional是否持有值)。
 * 官方的话是 : 如果存在值，则返回 true ，否则为 false 。
 *
 * @author JustryDeng
 * @date 2019/7/15 20:49
 */
@Test
public void testThree() {
    Staff staff = Staff.builder().name("员工9527").age(123).staffNo("NO.1").build();
    // 持有值时(即:Optional<T>中，T不为null时)
    Optional<Staff> optionalOne = Optional.ofNullable(staff);
    Assert.assertTrue(optionalOne.isPresent());
    // 不持有值时
    Optional<Staff> optionalTwo = Optional.ofNullable(null);
    Assert.assertFalse(optionalTwo.isPresent());
}

  • public void ifPresent(Consumer<? super T> consumer)：如果存在值，则使用该值调用指定的消费者，否则不执行任何操作。

class  MyConsumer implements Consumer<Staff>{
    @Override
    public void accept(Staff staff) {
        System.out.println("重新了accept(T t)方法 -> " + staff);
    }
}

/**
 * .ifPresent()方法 : 如果存在值，则使用该值调用指定的消费者，否则不执行任何操作。
 *
 * @author JustryDeng
 * @date 2019/7/15 21:06
 */
@Test
public void testFive() {
    Staff staff = Staff.builder().name("员工9527").age(123).staffNo("NO.1").build();
    Optional<Staff> optional = Optional.ofNullable(staff);
    optional.ifPresent(new MyConsumer());
    // 此处我们可以不需要显示的实现Consumer接口，而是直接使用lombda表达式来进行优化，如:
    // optional.ifPresent(s -> System.out.println("重新了accept(T t)方法 -> " + s));
    Optional<Staff> emptyOptional = Optional.empty();
    emptyOptional.ifPresent(k -> System.out.println("如果emptyOptional不持有值，那么是不会输出这句话的。"));
}

  • public Optional<T> filter(Predicate<? super T> predicate) : 如果一个值存在，并且该值给定的谓词相匹配时(即：filter(Predicate<? super T> predicate)里的，predicate判定结果为true时)，返回一个 Optional描述的值，否则返回一个空的 Optional。

class  MyPredicate implements Predicate<Staff> {
    @Override
    public boolean test(Staff staff) {
        boolean result = staff != null && staff.getAge() > 100;
        log.info(" MyPredicate.test result is -> {}", result);
        return result;
    }
}

/**
 * .filter()方法 : 如果一个值存在，并且该值给定的谓词相匹配时(即:filter(Predicate<? super T> predicate)里的，
 *                predicate判定结果为true时)，返回一个 Optional描述的值，否则返回一个空的 Optional 。
 *
 * @author JustryDeng
 * @date 2019/7/15 21:06
 */
@Test
public void testSix() {
    Staff staff = Staff.builder().name("员工9527").age(123).staffNo("NO.1").build();
    Optional<Staff> optionalOne = Optional.ofNullable(staff);
    // 匹配Predicate,那么会返回一个 Optional描述的值
    Optional<Staff> newOptionalOne = optionalOne.filter(new MyPredicate());
    // 此时newOptionalOne.isPresent()结果应该为true
    Assert.assertTrue(newOptionalOne.isPresent());

    Optional<Staff> optionalTwo = Optional.ofNullable(null);
    // 不匹配Predicate,那么会返回一个不持有值的Optional实例(即:optional持有的是null)
    Optional<Staff> newOptionalTwo = optionalTwo.filter((s) -> s != null && s.getAge() > 1000);
    // 此时newOptionalOne.isPresent()结果应该为false
    Assert.assertFalse(newOptionalTwo.isPresent());
}

  • public<U> Optional<U> map(Function<? super T, ? extends U> mapper)：Optional的泛型(即：持有值 数据类型)转换。

class  MyFunction implements Function<String, Staff> {

    /**
     * 将String转换为Staff
     */
    @Override
    public Staff apply(String s) {
        return Staff.builder().name(s).build();
    }
}

/**
 * .map()方法 : Optional的泛型(即:持有值 数据类型)转换
 *
 * 注:如Optional<A>.map(Function<? super A, ? extends B> function)后会得到Optional<B>,其
 *    中function的apply方法中定义有从A转换到B的规则
 *
 * 注:会应用function转换的前提是，Optional<A>持有值;
 *
 * 注:如果Optional<A>没持有值，或者Optional<A>持有值，但经过function转换后的Optional<B>不持有值的话，那么
 *    会返回一个一个空的(即:不持有值的)Optional
 *
 * @author JustryDeng
 * @date 2019/7/15 21:06
 */
@Test
public void testSeven() {
    Optional<String> optionalOne = Optional.of("蚂蚁牙黑");
    // 将字符串Optional<String>转换为Optional<Staff>，即:将【蚂蚁牙黑】转换为Staff
    Optional<Staff> newOptionalOne = optionalOne.map(new MyFunction());
    Assert.assertEquals("蚂蚁牙黑", newOptionalOne.orElse(Staff.builder().build()).getName());
}

注：如Optional<A>.map(Function<? super A, ? extends B> function)后会得到Optional<B>，
       其中function的apply方法中定义有从A转换到B的规则。

注：会应用function转换的前提是，Optional<A>持有值。

注：如果Optional<A>没持有值，或者Optional<A>持有值，但经过function转换后的Optional<B>
       不持有值的话，那么会返回一个一个空的(即:不持有值的)Optional。

  • public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper)：Optional泛型(即：持有值 数据类型)转换。

class  MyFunctionTwo implements Function<String, Optional<Staff>> {

    /**
     * 将String转换为Optional<Staff>
     */
    @Override
    public Optional<Staff> apply(String s) {
        return Optional.of(Staff.builder().name(s).build());
    }
}

/**
 * .flatMap()方法 : Optional泛型(即:持有值 数据类型)转换
 *
 * 注:如Optional<A>.map(Function<? super A, ? extends B> function)后会得到Optional<B>,其
 *    中function的apply方法中定义有从A转换到B的规则
 *
 * 注:会应用function转换的前提是，Optional<A>持有值;
 *
 * 注:如果Optional<A>没持有值，或者Optional<A>持有值，但经过function转换后的Optional<B>不持有值的话，那么
 *    会返回一个一个空的(即:不持有值的)Optional
 *
 * @author JustryDeng
 * @date 2019/7/15 21:06
 */
@Test
public void testEight() {
    Optional<String> optionalOne = Optional.of("蚂蚁牙黑");
    // 将String转换为Optional<Staff>，即:将【蚂蚁牙黑】转换为Staff
    Optional<Staff> newOptionalOne = optionalOne.flatMap(new MyFunctionTwo());
    Assert.assertEquals("蚂蚁牙黑", newOptionalOne.orElse(Staff.builder().build()).getName());
}

注：如Optional<A>.map(Function<? super A, ? extends B> function)后会得到Optional<B>，其
       中function的apply方法中定义有从A转换到B的规则。

注：会应用function转换的前提是，Optional<A>持有值。

注：如果Optional<A>没持有值，或者Optional<A>持有值，但经过function转换后的Optional<B>不
       持有值的话，那么会返回一个一个空的(即:不持有值的)Optional。

  • public T orElse(T other)：返回值如果存在，则返回该值；否则返回 other。

/**
 * public T orElse(T other) 返回值如果存在，则返回该值；否则返回 other。
 *
 * @author JustryDeng
 * @date 2019/7/16 9:44
 */
@Test
public void testNine() {
    Staff defaultStaff = Staff.builder().name("默认姓名").build();

    Staff staff = Staff.builder().name("邓二洋").build();
    Optional<Staff> optionalOne = Optional.of(staff);
    // 若optionalOne持有值，则返回值；若不持有值(相当于持有的值为null)，则返回defaultStaff
    Staff s1 = optionalOne.orElse(defaultStaff);
    Assert.assertEquals("邓二洋", s1.getName());

    Optional<Staff> optionalTwo = Optional.ofNullable(null);
    // 若optionalTwo持有值，则返回值；若不持有值(相当于持有的值为null)，则返回defaultStaff
    Staff s2 = optionalTwo.orElse(defaultStaff);
    Assert.assertEquals("默认姓名", s2.getName());
}

  • public T orElseGet(Supplier<? extends T> other)：若optional持有值，则返回值；若不持有值(相当于持有的值为null)，则调用other并返回该调用的结果。

class MySupplier implements Supplier<Staff> {

    @Override
    public Staff get() {
        return Staff.builder().name("李四").build();
    }
}
/**
 * public T orElseGet(Supplier<? extends T> other)
 * 若optional持有值，则返回值；若不持有值(相当于持有的值为null)，则调用other并返回该调用的结果。
 *
 * 提示:可使用lombda进行优化
 *
 * @author JustryDeng
 * @date 2019/7/16 9:44
 */
@Test
public void testTen() {
    Staff staff = Staff.builder().name("邓二洋").build();
    Optional<Staff> optionalOne = Optional.of(staff);
    // 若optionalOne持有值，则返回值；若不持有值(相当于持有的值为null)，则调用Supplier.get并返回该调用的结果
    Staff s1 = optionalOne.orElseGet(new MySupplier());
    Assert.assertEquals("邓二洋", s1.getName());

    Optional<Staff> optionalTwo = Optional.ofNullable(null);
    // 若optionalTwo持有值，则返回值；若不持有值(相当于持有的值为null)，则调用Supplier.get并返回该调用的结果
    Staff s2 = optionalTwo.orElseGet(new MySupplier());
    Assert.assertEquals("李四", s2.getName());
}

  • public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X：返回包含的值（如果存在），否则抛出由提供的供应商创建的异常。

class MySupplierTwo implements Supplier<RuntimeException> {

    @Override
    public RuntimeException get() {
        return null;
    }
}

/**
 * public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier)
 * throws X extends Throwable
 * 返回包含的值（如果存在），否则抛出由提供的供应商创建的异常。
 *
 * 提示:可使用lombda进行优化
 *
 * @author JustryDeng
 * @date 2019/7/16 9:59
 */
@Test(expected = RuntimeException.class)
public void testEleven() {
    Staff staff = Staff.builder().name("邓二洋").build();
    Optional<Staff> optionalOne = Optional.of(staff);
    // 若optionalOne持有值，则返回值；若不持有值(相当于持有的值为null)，则抛出由提供的供应商创建的异常。
    Staff s1 = optionalOne.orElseThrow(new MySupplierTwo());
    Assert.assertEquals("邓二洋", s1.getName());

    Optional<Staff> optionalTwo = Optional.ofNullable(null);
    // 若optionalTwo持有值，则返回值；若不持有值(相当于持有的值为null)，则抛出由提供的供应商创建的异常。
    Staff s2 = optionalTwo.orElseThrow(new MySupplierTwo());
}

  • public boolean equals(Object obj)：Optional重写了equals方法，会比较Optional持有对象的值。

/**
 * Optional重写了equals方法，会比较Optional持有对象的值
 */
@Test
public void testTwelve() {
    Staff staffOne = Staff.builder().name("邓二洋").age(25).build();
    Staff staffTwo = Staff.builder().name("邓二洋").age(25).build();
    Staff staffThree = Staff.builder().name("JustryDeng").age(25).build();

    // 第一个Optional
    Optional<Staff> optionalOne = Optional.of(staffOne);
    // 第二个Optional
    Optional<Staff> optionalTwo = Optional.of(staffTwo);
    // 第三个Optional
    Optional<Staff> optionalThree = Optional.of(staffThree);
    // 第四个Optional
    Optional<Staff> optionalFour = Optional.ofNullable(null);
    // 第五个Optional
    Optional<Staff> optionalFive = Optional.ofNullable(null);

    // true
    boolean resultOne = optionalOne.equals(optionalTwo);
    Assert.assertTrue(resultOne);
    // false
    boolean resultTwo = optionalOne.equals(optionalThree);
    Assert.assertFalse(resultTwo);
    // true（若两个Optional都不持有对象，那么这两个Optional进行equals的结果为true）
    boolean resultThree = optionalFour.equals(optionalFive);
    Assert.assertTrue(resultThree);
    // false
    boolean resultFour = optionalOne.equals(optionalFour);
    Assert.assertFalse(resultFour);
}

  • public int hashCode()：返回当前值的哈希码值(如果有的话)，如果没有值，则返回0(零)。

/**
 * Optional.hashCode
 * 返回当前值的哈希码值（如果有的话），如果没有值，则返回0（零）。
 */
@Test
public void testThirteen() {
    Staff staffOne = Staff.builder().name("邓二洋").age(25).build();
    Staff staffTwo = Staff.builder().name("邓二洋").age(25).build();
    Staff staffThree = Staff.builder().name("JustryDeng").age(25).build();

    // 第一个Optional
    Optional<Staff> optionalOne = Optional.of(staffOne);
    // 第二个Optional
    Optional<Staff> optionalTwo = Optional.of(staffTwo);
    // 第三个Optional
    Optional<Staff> optionalThree = Optional.of(staffThree);
    // 第四个Optional
    Optional<Staff> optionalFour = Optional.ofNullable(null);
    int resultOne = optionalOne.hashCode();
    log.info(" resultOne is -> 【{}】！", resultOne);
    int resultTwo = optionalTwo.hashCode();
    log.info(" resultTwo is -> 【{}】！", resultTwo);
    // 求Optional对象的hashCode,实际上求的是Optional持有的对象的hashCode
    Assert.assertEquals(resultOne, resultTwo);

    int resultThree = optionalThree.hashCode();
    Assert.assertNotEquals(resultOne, resultThree);

    int resultFour = optionalFour.hashCode();
    // 若Optional不持有值，那么hashCode值为0
    Assert.assertEquals(0, resultFour);
}

  • public String toString()：返回此可选的非空字符串表示，适用于调试。

/**
 * Optional.toString
 * 返回此可选的非空字符串表示，适用于调试
 */
@Test
public void testFourteen() {

    Staff staffOne = Staff.builder().name("邓二洋").age(25).build();
    Optional<Staff> optionalOne = Optional.of(staffOne);

    Staff staffTwo = Staff.builder().name("JustryDeng").age(25).build();
    Optional<Staff> optionalTwo = Optional.of(staffTwo);

    Optional<Staff> optionalThree = Optional.ofNullable(null);
    // Optional[T.toString]
    log.info(" optionalOne is -> 【{}】！", optionalOne);
    // Optional[T.toString]
    log.info(" optionalTwo is -> 【{}】！", optionalTwo);
    // 若不持有值，那么tiString结果为 Optional.empty
    log.info(" optionalThree is -> 【{}】！", optionalThree);
}

 

提示一：更多细节，可详见JDK API文档。

提示二：本文只是示例的jdk1.8的Optional新特性，jdk1.9仍然对Optional有进一步优化，但本文这里并未示例。

 

^_^ 如有不当之处，欢迎指正

^_^ 参考文档
              《jdk api 1.8_google.CHM》

^_^ 测试代码托管链接
               https://github.com/JustryDeng…Jdk8Feature

^_^ 本文已经被收录进《程序员成长笔记(五)》，笔者JustryDeng

justry_deng
关注
专栏目录
【Optional类】JDK1.8新特性之Optional类的使用
✅ Java 开发工程师，从事 Web 应用程序的研发，擅长 Spring、SpringBoot 等技术。 ✅ 热爱编程，业余时间学习新知识，通过 CSDN 记录学习心得和笔记内容。
09-19 803
在我们平常开发过程中，如果程序逻辑考虑不全，就有可能导致空指针异常NullPointerException，也就是我们常说的NPE。出现空指针异常的根本原因，就是我们在使用某个对象的时候，没有判断这个对象是否可以为null，如果这个对象为null，那么在调用其对应方法的时候，就会抛出空指针异常。// 判空校验throw new RuntimeException("obj对象不能为空");}}但是，从JDK1.8开始，就专门提供了一个处理NPE异常的类，即：【Optional】类。
JDK1.8 Optional
luohao_的博客
03-07 254
在我们的开发中，NullPointerException可谓是随时随处可见，为了避免空指针异常，我们常常需要进行一 些防御式的检查，所以在代码中常常可见if(obj != null) 这样的判断。幸好在JDK1.8中，java为我们提供了 一个Optional类，Optional类能让我们省掉繁琐的非空的判断。下面先说一下Optional中为我们提供的方法 下面我们写几个例子来具体看一下每...
Optional详解
最新发布
刘皇叔说Java的博客
08-12 944
java.util.Optional 是java8中引进的一个新的类，它可以对可能缺失的值进行建模，而不是直接将null赋值给量。它是用来规范我们开发的API，使其语义更加的明确，使用Optional修饰的对象，表示该对象可能为null。在一定程度上避免了空指针的问题。定义：Optional是一个可以为null的容器对象，它代表一个值存在或不存在。如果值存在，isPresent()方法会返回true，调用get()方法会返回该对象。目的：减少显式的空值检查，防止代码污染，使代码更加优雅、安全。
jdk1.8——Optional类
FlyLikeButterfly的博客
01-06 1249
Optional类
Jdk1.8新特性之Optional
技术成就人生
12-02 264
在我们的开发中，NullPointerException可谓是随时随处可见，为了避免空指针异常，我们常常需要进行一些防御式的检查，所以在代码中常常可见if(obj != null) 这样的判断。幸好在JDK1.8中，java为我们提供了一个Optional类，Optional类能让我们省掉繁琐的非空的判断。下面先说一下Optional中为我们提供的方法 // 将执行的值封装成Optional...
JDK1.8 Optional
技术刘的博客
12-06 294
Optional 是JDK1.8 不用判断是否为NUIL，1.8以前，没有判断是否为NULL，会报空指针异常(NullPointerException) Optional optional = shoppingCartRepository.findById(id); Optional.get() 方法可以拿到所有返回的值 官方的原话：这是一个可以包含或者不包含非 null 值的容器。如果值存在则...
JDK1.8中文文档 JDK1.8中文 jkd8中文文档 JDK中文版
07-15
首先，JDK1.8最重要的新特性之一就是Lambda表达式。Lambda表达式是函数式编程的核心概念，它允许将函数作为一个值传递，简化了代码并提高了可读性。通过这种方式，开发者可以更方便地处理集合数据和编写多线程程序。...
jdk1.8 api 中文文档
02-23
**标题解析：**"JDK1.8 API 中文文档" 这个标题指的是Java Development Kit (JDK) 1.8版本的API（Application Programming Interface）的中文解释文档。API是一系列预先定义的函数、类、接口和枚举，用于帮助程序员...
JDK 1.8中文API文档
07-27
JDK 1.8中文API文档详细列出了所有Java 1.8提供的类库、接口、枚举、注解等，包括它们的方法、属性和构造器，是学习和查阅Java 1.8特性的必备参考资料。通过查阅该文档，开发者可以快速找到所需的类和方法，理解其...
jdk1.8-windows解压双击安装
06-25
这个“jdk1.8-windows”文件很可能是JDK 1.8的Windows平台安装包，适用于在Windows操作系统上开发和运行Java程序。 在Windows系统中安装JDK 1.8的步骤如下： 1. **下载**：首先，你需要从Oracle官方网站或者可信的...
Java基础之140JDK8之Optional类的使用
C_time的博客
04-22 398
Optional容器类（JDK1.8） Optional容器类（JDK1.8） 这是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。 作用 为啥用它 ？ 好像是收到返回值不用判断是否为空了 直接使用就可以了 (以后理解了再完善) 创建Optional对象的两种方式 of： 为非null的值创建一个Optional。 ofN...
JDK1.8 Optional 源码剖析
少侠我姓朱
09-23 308
Optional 容器对象，可能包含也可能不包含非null值。如果存在值，{@ code isPresent（）}将返回{@code true}并且{@code get（）}将返回该值。 提供依赖于是否存在包含值的其他方法，例如{@link #orElse（java.lang.Object）orElse（）}（如果值不存在则返回默认值）和{@link #ifPresent （java.util....
JDK1.8中的Optional使用方式
weixin_42030357的博客
05-04 1955
文章目录1.方法：2.构造方法3.方法实列：3.1 of3.2 ofNullable3.3 empty3.4 get3.5 orElse3.6 orElseGet3.7 orElseThrow3.8 filter3.9 map3.10 flagMap3.11 ifPresent4.代码重构4.1 重构前4.2 重构之后 参考文章 参考文章2 1.方法： 方法 描述 of 把指定的...
JDK1.8新特性之Optional类
Esy_Hong
10-30 400
前言：最近做了一个需求，其中从其他微服务中获取了一个含有多个且多层实体的对象。而我则需要获取这个复杂对象里面的各个字段，如果不做校验很可能会出现空指针。所以代码中出现了很多if else来判断非null情况，而且还容易漏掉其中一个，造成空指针异常。Optional类刚好能解决优雅地这类问题。 Optional简介： A container object which may or may not...
Java JDK 1.8 新特性 Optional类
qq_43623492的博客
01-14 289
Optional.of Optional.ofNullable Optional.empty isPresent() get() orElse ifPresentOrElse ifPresent
jdk 1.8 optional的使用
LoveFly826的博客
12-23 507
本博客关于JDK1.8新特性介绍的目录在这里，欢迎点击 前言 在前面简单介绍了stream 流的使用，这篇博客主要介绍optional类的使用。 知道 Google 的 Guava 的同学，一定知道jdk的很多都是借鉴guava里面的思想来进行升级的，optional就是其中之一，早在java 6时，Guava 就提供了 Optional > 的实现。 言归正传，开始干 NullPoin...
JDK1.8新特性---Optional
Mr.Cui的Java学习之路
09-18 611
JDK1.8新特性---Optional
JDK1.8新特性值Optional（逻辑判断）
专注基础架构领域
03-29 6968
在我们的开发中，NullPointerException可谓是随时随处可见，为了避免空指针异常，我们常常需要进行一些防御式的检查，所以在代码中常常可见if(obj != null) 这样的判断。幸好在JDK1.8中，java为我们提供了一个Optional类，Optional类能让我们省掉繁琐的非空的判断。下面先说一下Optional中为我们提供的方法。 方法 描述 of 把指定...
JDK1.8新特性值Optional
山山来驰的博客
11-26 124
https://blog.csdn.net/zknxx/article/details/78586799
Java JDK1.8特性解析与应用优势
jdk1.8指的是Java Development Kit的第8个主要版本，它在Java社区中被广泛使用，为开发人员提供了许多增强功能和新特性。 1、性能提升： JDK 1.8的性能得到了显著提高，这主要归因于其底层结构的优化和JVM（Java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值