JAVA新特性（2）optional类与方法引用

最新推荐文章于 2025-03-30 09:38:06 发布
原创 最新推荐文章于 2025-03-30 09:38:06 发布 · 432 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了Java中的Optional类，包括of、empty、ofNullable等方法的使用，以及Optional类在处理非空值时的作用。此外，还探讨了方法引用的概念，将其分为四类，并解释了如何在Lambda表达式中使用方法引用。最后，文章提到了Java中接口默认方法的冲突解决策略。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

  1. optional类的理解与使用：
    1）public static <T> Optional<T> of(T value)： 返回value（非空）的实例
         public static<T> Optional<T> empty()：返回空实例
         public static <T> Optional<T> ofNullable(T value)：根据传入值 返回value或空的 实例
         Optional()与Optional(T)为私有构造方法
        @Test
    public void Test1(){//不推荐采用这种方式
        Optional<String> optionalS = Optional.of("Hello");
        if(optionalS.isPresent()) System.out.println(optionalS.get());
    }
    @Test
    public void Test2(){//推荐
        Optional<String> optionalS = Optional.of("Hello");
        Optional<String> op = Optional.empty();
        optionalS.ifPresent(item -> System.out.println(item));
        System.out.println(op.orElse("word"));//op为空则打印传入的参数，不为空则打印op本身
    }

    2）应用：List集合，返回集合或一个为空的集合

        @Test
    public void Test3(){
        Employee employee1 =new Employee();
        employee1.setName("Liu");
        Employee employee2 =new Employee();
        employee2.setName("Ze");

        Company company = new Company();
        company.setName("Hua Zhong");

        List<Employee> employeeList = Arrays.asList(employee1,employee2);
//构造Employee集合
        company.setList(employeeList);//在company中添加集合

        List<Employee> employees = company.getList();
        Optional<Company> optional = Optional.ofNullable(company);
        System.out.println(optional.map(mycom->mycom.getList()).orElse(Collections.emptyList()));
//传入的集合若不为空，则打印此集合；传入的集合为空，则打印空集合
//输出：1） [] （注释掉company.setList(employeeList);） 
//      2)  [com.learn.jdk8.Employee@39ed3c8d, com.learn.jdk8.Employee@71dac704] 
    }

//构造的company与Employee为一对多的关系
class Employee{
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
class Company{
    private String name;
    private List<Employee> employees;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public List<Employee> getList() {
        return employees;
    }
    public void setList(List<Employee> employees) {
        this.employees = employees;
    }
}

     

  2. 方法引用：method reference：实际上是Lambda表达式的一种语法糖。当Lambda表达式只有一行代码，且Lambda表达式的方法恰好是已经存在的，这可以改写成为方法引用的形式。
    方法引用共有四类：
    1）类名::静态方法名
    2）引用名（对象名）::实例方法名
    3）类名::实例方法名
    说明：实例方法一定是由对象来调用的，此对象就是原方法中接收的Lambda表达式的第一个参数；如果接收多个参数，则除了第一个参数，后面所有的参数都作为这个实例方法的参数。
    4）类名::new    说明：此种放式是构造方法的引用（知识补充：构造方法会返回所在类的实例） 
    public class MethodReferenceTest {
    @Test
    public void TestLambda(){
        Teacher teacher1 = new Teacher("liu", 12);
        Teacher teacher2 = new Teacher("ze", 55);
        Teacher teacher3 = new Teacher("tian", 29);
        Teacher teacher4 = new Teacher("men", 1);
        List<Teacher> teacherList = Arrays.asList(teacher1,teacher2,teacher3,teacher4);
//使用Lambda表达式形式实现
        teacherList.sort((t1,t2)->Teacher.SortByage(t1, t2));
        teacherList.forEach(t-> System.out.println(t.getAge()));
        System.out.println("-----------------------");
        teacherList.sort((t1,t2)->Teacher.SortByname(t1, t2));
        teacherList.forEach(t-> System.out.println(t.getName()));
    }
    @Test
    public void TestMethodReference(){
//        使用方法引用：第一类：
//        类名::静态方法名
        Teacher teacher1 = new Teacher("liu", 12);
        Teacher teacher2 = new Teacher("ze", 55);
        Teacher teacher3 = new Teacher("tian", 29);
        Teacher teacher4 = new Teacher("men", 1);
        List<Teacher> teacherList = Arrays.asList(teacher1,teacher2,teacher3,teacher4);

        teacherList.sort(Teacher::SortByage);
        teacherList.forEach(t-> System.out.println(t.getAge()));
        System.out.println("-----------------------");
        teacherList.sort(Teacher::SortByname);
        teacherList.forEach(t-> System.out.println(t.getName()));
    }

    @Test
    public void TestMethodReference2(){
//        使用方法引用：第二类：
//        引用名（对象名）::实例方法名
        Teacher teacher1 = new Teacher("liu", 12);
        Teacher teacher2 = new Teacher("ze", 55);
        Teacher teacher3 = new Teacher("tian", 29);
        Teacher teacher4 = new Teacher("men", 1);
        List<Teacher> teacherList = Arrays.asList(teacher1,teacher2,teacher3,teacher4);

        TeacherCompare teacherCompare = new TeacherCompare();
        teacherList.sort(teacherCompare::SortTeacherAge);
        teacherList.forEach(t-> System.out.println(t.getAge()));
        System.out.println("-----------------------");
        teacherList.sort(teacherCompare::SortTeacherName);
        teacherList.forEach(t-> System.out.println(t.getName()));
    }

    @Test
    public void TestMethodReference3(){
//        使用方法引用：第三类：
//        类名::实例方法名
//        实例方法一定是由对象来调用的，此对象就是sort方法中接收的Lambda表达式的第一个参数
//        如果接收多个参数，则除了第一个参数，后面所有的参数都作为实例方法的参数
//        sort方法中lambda表达式为实现Comparator函数接口的int compare(T o1, T o2); 方法
        Teacher teacher1 = new Teacher("liu", 12);
        Teacher teacher2 = new Teacher("ze", 55);
        Teacher teacher3 = new Teacher("tian", 29);
        Teacher teacher4 = new Teacher("men", 1);
        List<Teacher> teacherList = Arrays.asList(teacher1,teacher2,teacher3,teacher4);

        teacherList.sort(Teacher::Sortage);
        teacherList.forEach(t-> System.out.println(t.getAge()));
        System.out.println("-----------------------");
        teacherList.sort(Teacher::Sortname);
        teacherList.forEach(t-> System.out.println(t.getName()));
    }

    @Test
    public void TestMethodReference4(){
//        使用方法引用：第四类：构造方法引用
//        类名::new
        System.out.println(getString(()->"liu"));//liutest
        System.out.println(getString(String::new));//test
        System.out.println(getString2("ze",String::new));//ze 注(构造方法一定会返回当前类的实例)
    }

    public String getString(Supplier<String> supplier){
        return supplier.get() + "test";
    }
    public String getString2(String str, Function<String,String> function){
        return function.apply(str);
    }
}
class Teacher{
    private String name;
    private int age;

    public Teacher(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
//定义这两个静态方法是有意为之的，是为了这个示例设计的。
// 平时使用时这样写没有意义（与当前类完全无关）。
//静态方法（实现比较器）以传入 sort(Comparator<? super E> c)方法作为参数
    public static int SortByname(Teacher st1, Teacher st2){
        return st1.getName().compareTo(st2.getName());
    }
    public static int SortByage(Teacher st1 , Teacher st2){
        return st1.getAge() - st2.getAge();
    }
//以下两种才有意义
    public int Sortname(Teacher st){
        return this.getName().compareTo(st.getName());
    }
    public int Sortage(Teacher st){
        return this.getAge() - st.getAge();
    }

}
class TeacherCompare{
//实例方法（实现比较器）以传入 sort(Comparator<? super E> c)方法作为参数
    public int SortTeacherName(Teacher t1, Teacher t2){
        return t1.getName().compareTo(t2.getName());
    }
    public int SortTeacherAge(Teacher t1, Teacher t2){
        return t1.getAge()- t2.getAge();
    }
}

     

  3. 在Java中实现类（继承父类）的优先级比接口（实现接口）的优先级高。
  4. 如果有两个接口都有方法类型和参数相同的默认方法(此方法在接口中已被实现，声明为default；新版本中引入默认方法能在接口中增加新的方法的同时避免对使用原有版本代码的破坏性影响)，一个类实现了这两个接口，则使用接口中的这默认方法时编译器会报错，可以重写这个方法，若要指定实现其中一个接口的默认方法，则可以在重写的这个方法体中用 接口名.super.方法名 的形式实现。
      
    public class DefaultMethodTest implements MyTest1 ,MyTest2{
    @Override
    public void MyMethod() {
        System.out.println("MyMethod");
        MyTest1.super.MyMethod();//MyTest1
    }
    public static void main(String[] args) {
        DefaultMethodTest dTest = new DefaultMethodTest();
        dTest.MyMethod();
    }
}
interface MyTest1{
     default void MyMethod(){
        System.out.println("MyTest1");
    }
}
interface MyTest2{
    default void MyMethod(){
        System.out.println("MyTest2");
    }
}



     

 

 

 

 





 

Java 的 Optional 类的使用方法示例
qq_29454203的博客
07-29 989
Java8 - Optional 类 防止 NPE ，是程序员的基本修养，注意 NPE 产生的场景，使用 JDK8 的 Optional 类来防止 NPE 问题。 Optional 类是Java8为了解决null值判断问题，借鉴google guava类库的Optional类而引入的一个同名Optional类，使用Optional类可以避免显式的null值判断（null的防御性检查），避免null导致的NPE（NullPointerException）。 Optional类的两个构造方法都是private
Java8中的Optional类
syx的专栏
07-19 6321
如果你开发过Java程序，可能会有过这样的经历：调用某种数据结构的一个方法得到了返回值却不能直接将返回值作为参数去调用别的方法。而是首先判断这个返回值是否为null，只有在非空的前提下才能将其作为其他方法的参数。Java8中新加了Optional这个类正是为了解决这个问题。Optional类的Javadoc描述如下： 这是一个可以为null的容器对象。如果值存在则isPresent()方法会返回t
java中Optional类下的方法使用
lihuihui01的博客
08-04 200
package optional; import java.util.Optional; import java.util.function.Consumer; /** * optional 主要是用来避免空指针带来的麻烦 * Optional实际上是个容器：它可以保存类型T的值，或者仅仅保存null。Optional提供很多有用的方法，这样我们就不用显式进行空值检测。 */ public class test { public static void main(String[] ar
Optional类方法
qq_43478625的博客
07-01 568
【代码】Optional类方法。
关于Optional类一些方法
potatotamato的博客
03-11 1265
java 8 引入了Optional类，主要是帮我们解决NPE问题（NullPointException）。话不多说，上源码。 一、ofNullable方法，当值为null时，调用empty()，非空调of(value) public static <T> Optional<T> ofNullable(T value) { return value == n...
Java-JDK8新特性总结-接口方法/Lambda/方法引用/Optional
07-12
本文将深入探讨其中的四大关键特性：接口中的方法（包括抽象方法、静态方法和默认方法）、Lambda表达式、方法引用以及Optional容器对象。 一、接口中的方法 1. 抽象方法：在Java 8之前，接口中的方法默认为public ...
Java8新特性之Lambda表达式和Optional类
09-02
Java 8 新特性之 Lambda 表达式和 Optional 类 Java 8 是 Java 语言的最新版本之一，它引入了许多新的特性，包括 Lambda 表达式和 Optional 类，这些特性极大地提高了 Java 语言的编程效率和可读性。下面我们将详细...
java8特性Optional应用demo
最新发布
04-26
在Java 8中引入的Optional类是一种容器对象，其目的是为了减少null检查的代码量，并避免在Java程序中频繁出现的空指针异常。Optional类的引入，主要是为了帮助开发者更清晰地表达“值可能不存在”的概念。在Java 8...
Java8新特性之Optional、Lambda表达式、Stream、新日期Api使用总结
忆往昔的博客
07-02 1135
Java8新特性之Optional、Lambda表达式、Stream、新日期Api使用总结
Java方法引用与Optional特性详解
方法引用是Java 8引入的一个新特性，它允许我们直接引用已存在的方法，而不是通过Lambda表达式来创建一个新的方法实现。方法引用主要有三种形式： 1. **静态方法引用**：通过类名::静态方法名，例如`Integer::...
Optional类的常用方法
olive
04-22 4714
方法 描述 empty 放回一个值为空的Optional实例 filter 如果值存在并且满足提供的谓词，就返回包含该Optional对象；否则返回一个空的Optional对象 flatMap 如果值存在，就对该值执行提供的mapping函数，将mapping函数返回值用Optional封装并返回，否则就返回一个空的Optional对象 get 如果值存在就返回该Opt...
Optional 类方法使用指南
技术交流，一起进步
03-30 1580
Optional 不是用来替代所有 null 检查的银弹，而是通过类型系统强制开发者处理空值情况的工具。当您需要：1、明确方法可能返回空值2、避免深层嵌套的 null 检查3、构建流畅的链式调用时，Optional 将成为您的得力助手。记住：不要为了使用 Optional 而使用它，正确的场景选择才能发挥其最大价值！思考题：如何处理多层嵌套对象（如 user.getAddress().getStreet()）的空值问题？欢迎在评论区分享你的解决方案！进阶技巧优先使用orElseGet。
Optional类方法使用详解
陌殇殇的博客
03-29 1080
Optional类方法使用详解
函数式编程之Optional接口，函数式接口和方法引用
风间琉璃の博客
07-07 533
使用来创建对象：无论参数值是否为空都不会抛出异常。 使用来创建对象：必须要保证当前参数的对象不能为空，否则同样会抛出空指针异常。 使用来创建对象：会返回一个空的对象。 1.1.2 安全消费值 使用方法来对其中的值进行消费操作（建议使用lambda表达式），不为空时才会运行其中的代码。 1.1.3 安全获取值 如果使用方法来获取，当内部的数据为空时会出现异常，即存在值就返回值，不存在就抛出异常。使用：设置一个默认值，数据为空就返回默认值，存在数据就返回数据值。 例如：获取当前的值，如果当前不存
Java 8 开始新增的 Optional 类 - Optional 中的方法
HONEY MOOSE
05-17 1105
fPresent() 的使用条件 ifPresent() 方法能够让我们在对对象进行下一步操作之前判断我们需要操作的对象是否为 Null，在没有 Optional 对象之前，我们通常使用下面的方法先进行判断： if(name != null) { System.out.println(name.length()); } 上面的程序逻辑是，首先判断 name 这个变量是不是为空，如果不为空的话，允许程序继续执行下一步。 这种判断方法不是很美观，代码也比较难看，更重要的是这种判断方法也是容易
Optional常用方法
K10I
09-02 1907
Optional.empty()方法是一个静态工厂 方法，它返回Optional类的特定单一实例。如果你尝试引用一个null，一定会触发NullPointerException，不过使用 Optional.empty()就完全没事儿，它是Optional类的一个有效对象，多种场景都能调用，非常有用。
Optional类详解及使用方法示例
Ascend1977的博客
05-29 5969
Optional类是java8中引入的一个非常有用的类，它可以用来解决空指针异常带来的不便。这个类可以将对象包装为一个Optional对象，如果该对象为空，则可以使用一些默认值或者执行一些默认操作。Optional 是 Java 实现函数式编程的强劲一步，并且帮助在范式中实现。Java8的Optional类提供了丰富的 API 方法，这里按照其功能分类介绍。
Java 8 新特性之Optional 类方法大全
qq_42981890的博客
12-24 438
Java应用中最常见的bug就是空值异常。在Java 8之前，Google Guava引入了Optionals类来解决NullPointerException，从而避免源码被各种null检查污染，以便开发者写出更加整洁的代码。Java 8也将Optional加入了官方库。
Optional 使用方法详解
热门推荐
怪咖@的博客
05-16 4万+
Optional的作用是什么？他都有哪些方法？阿里规范点名说尽量用Optional来避免空指针，那么什么场景用Optional？本篇文章围绕这三点来进行讲解。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值