lambda表达式4种方法引用

引用地址：【Java-API】lambda表达式4种方法引用_lambad方法引用-CSDN博客

lambda表达式就是对匿名内部类的简写和优化（要求接口必须是函数式接口@Functional Interface（即接口中有且只有一个抽象方法（注意：与Object公共类相同的不计入抽象方法））但是可以有多个非抽象方法），方法引用就是对lambda表达式的优化和简写。

首先lambda表达式4种方法引用可以归纳为下列4种：

1，静态方法引用

2，实例方法引用

3，构造方法引用

4，特殊方法引用

那么就直接进行举例说明：
第一种：静态方法引用

静态方法/类方法（static修饰的方法）引用
        语法:类名::方法名

注意事项:
        被引用的方法参数列表和函数式接口中抽象方法的参数一致!!
        接口的抽象方法没有返回值，引用的方法可以有返回值也可以
        没有接口的抽象方法有返回值，引用的方法必须有相同类型的返回值!!
        由于满足抽象参数列表与引用参数列表相同，所以可以写成静态方法引用的格式

案例：（将字符串转换成Integer类型）

函数式接口

    /**
     * 通过以下接口实现匿名内部类，lambda表达式，静态方法引用
     * public interface MyInterface{
        Integer strToInt(String str);
        }
     * 底层适用：Integer.parseint()实现
     *创建一个接口
     *抽象方法为Integer strToInt(String str);
     */
    public interface MyInterface {
        //抽象方法
        Integer strToInt(String str); //将字符串转换成Integer类型
    }

测试类

    /**
     * 接口测试类 1.通过以下接口实现匿名内部类，
     * lambda表达式，静态方法引用 public interface MyInterface{
     *  Integer strToInt(String str); }
     * 底层适用：Integer.parseint()实现
     * 静态方法引用
            语法:类名::方法名
            注意事项:
            被引用的方法参数列表和函数式接口中抽象方法的参数一致!!
            接口的抽象方法没有返回值，引用的方法可以有返回值也可以
            没有接口的抽象方法有返回值，引用的方法必须有相同类型的返回值!!
            由于满足抽象参数列表与引用参数列表相同，所以可以写成静态方法引用的格式
     */
    public class MyInterfaceTest {
        public static void main(String[] args) {
            // 利用匿名内部类的方式
            MyInterface my = new MyInterface() {
                // 底层适用：Integer.parseint()实现
                @Override
                public Integer strToInt(String str) {
                    // 参数为String类型，返回值类型为int类型（会自动进行装箱）
                    return Integer.parseInt(str);  //方法是static修饰的 为静态方法
                }
            };
     
            // 采用lambda表达式进行优化
            MyInterface my1 = str -> Integer.parseInt(str);
            
            // 采用静态方法引用
            MyInterface my2 =  Integer::parseInt;
     
            // 调用方法 非static修饰 对象名.方法名（）
            System.out.println(my.strToInt("1261542"));
            System.out.println(my1.strToInt("134343"));
            System.out.println(my2.strToInt("134343"));
     
        }
     
    }

第二种：实例方法引用

实例方法（非static修饰的方法）引用
        语法:对象名:∶非静态方法名

注意事项:
被引用的方法参数列表和函数式接口中抽象方法的参数一致!!

接口的抽象方法没有返回值，引用的方法可以有返回值也可以没有

接口的抽象方法有返回值，引用的方法必须有相同类型的返回值! !

案例：给你一个字符串【数字】  判断是否是以.png结尾的

函数式接口

    // 给你一个字符串  判断是否是以.png结尾的
    public interface MyInterface {
        //抽象方法
        Boolean judgeSuffix(String str);// 参数是字符串，返回值是Boolean类型
    }

测试类

    package cn.meituan.lambdainstancequote11111;
     
    /**
     * 给你一个字符串 判断是否是以.png结尾的
     * 实例方法（非static修饰的方法）引用
            语法:对象名:∶非静态方法名
        注意事项:
        被引用的方法参数列表和函数式接口中抽象方法的参数一致!!    
        接口的抽象方法没有返回值，引用的方法可以有返回值也可以没有    
        接口的抽象方法有返回值，引用的方法必须有相同类型的返回值! !
     */
    public class MyInterfaceTest {
        public static void main(String[] args) {
            String s = "默默无闻的你.png";
            // 采用匿名内部类方法
            MyInterface my = new MyInterface() {
     
                @Override
                public Boolean judgeSuffix(String str) {// 参数为字符串类型(输入的是结尾)
                                                        // 返回值为Boolean类型
                    // 字符串【数字】 判断是否是以.png结尾的
                    return s.endsWith(str);// 调用s.endsWith（没有static修饰）的实例方法
                }
            };
     
            // 采用lambda表达式进行优化简化代码
            MyInterface my1 =  str ->  s.endsWith(str);
            
            // 采用实例方法引用进行简写
            MyInterface my2 =  s::endsWith;
     
            // 调用方法输出结果
            System.out.println(my.judgeSuffix(".png"));
            System.out.println(my1.judgeSuffix(".png"));
            System.out.println(my2.judgeSuffix(".png"));
        }
    }

第三种：构造方法引用

构造方法引用
        语法:类名::new

注意事项:
        被引用的类必须存在一个构造方法与函数式接口的抽象方法参数列表一致

案例：利用构造方法将String字符串转换成Integer类型

函数式接口

    public interface MyInterface {
        //抽象方法
        Integer strToInt(String str);
    }

测试类

    /**
     * 接口测试类 构造方法引用
     * 利用构造方法将String字符串转换成Integer类型
     *
     * 构造方法引用
            语法:类名::new
        注意事项:
            被引用的类必须存在一个构造方法与函数式接口的抽象方法参数列表一致
     */
    public class MyInterfaceTest {
        public static void main(String[] args) {
            // 采用匿名内部类的方式
            MyInterface my = new MyInterface() {
     
                @Override
                public Integer strToInt(String str) {
                    // Integer integer = new
                    // Integer(str);//创建一个构造方法将String类型转换成Integer类型（自动装箱）
                    return new Integer(str); // 方法是一个构造方法
                }
            };
     
            // 采用lambda表达式对匿名内部类进行优化
            MyInterface my1 =  str ->  new Integer(str);
            
            // 采用构造方法引用进行简化代码
            MyInterface my2 =  Integer::new;
     
            // 调用方法输出结果
            System.out.println(my.strToInt("232434"));
            System.out.println(my1.strToInt("232434"));
            System.out.println(my2.strToInt("232434"));
        }
    }

第四种：特殊方法引用

特殊方法引用

        语法:类名::实例方法名

注意事项:
        在抽象方法中，参数作为实例方法调用者，就可以简化

需求:判断参数t是否为空字符串

函数式接口

    public interface MyInterface {
        //抽象方法
        Boolean empty(String str);
     
    }

测试类

    package cn.meituan.lambdaspecialinstancequote11111;
     
    /**
     * 需求：给你一个字符串， 判断是否为空
     * 特殊方法引用
          语法:类名::实例方法名
     *
     */
    public class MyInterfaceTest {
        public static void main(String[] args) {
            // 采用匿名内部类方法
            MyInterface my = new MyInterface() {
     
                @Override
                public Boolean empty(String str) {// 参数为字符串类型（输入的字符串）
                                                    // 返回值为Boolean类型
                    // 字符串【数字】 判断是否为空
     
                    return str.isEmpty();// 特殊实例方法引用
                }
            };
     
            // 采用lambda表达式进行优化简化代码
            MyInterface my1 =  str -> str.isEmpty();
     
     
            // 采用实例方法引用进行简写    格式： 类名（数据类型的类）::实例方法名
     
            MyInterface my2 =  String::isEmpty;
            
            // 调用方法输出结果
            System.out.println(my.empty("sdsdsd"));// false
            System.out.println(my1.empty(""));// true
            System.out.println(my2.empty(""));// true
        }
     
    }