Lambda支持的方法引用

引用类中的静态方法替换lambda

引用类方法：引用类的静态方法；`类名::静态方法名

==============================================`

demo: 将String类型数据转换成为Integer类型

创建一个接口名字为convers

package com.itxs.demo04;

/**
 * @Classname : convers
 * @Description : TODO 转换接口
 * @Author : lin_refuel@qq.com
 */
public interface convers {
	//数据转换方法
    Integer conver(String str);
}

demo01:测试上面接口

package com.itxs.demo04;

/**
 * @Classname : demo01
 * @Description : TODO 转换接口测试类
 * @Author : lin_refuel@qq.com
 */
public class demo01 {
    public static void main(String[] args) {
        // 匿名内部类方式
        res(new convers() {
            @Override
            public Integer conver(String str) {
                // 字符串转成Int类型数据
                return Integer.parseInt(str);
            }
        });
        // 完整的lambda
        res((String str) ->{
         return  Integer.parseInt(str);
        });
        // 省略的lambda
        res(str -> Integer.parseInt(str));
        // 通过静态方法替换lambda
        // 此时lambda的实参会作为静态方法的实参拿过来直接用
        res(Integer::parseInt);

    }
    private static void res(convers c){
      Integer ret = c.conver("9527");
        System.out.println(ret+1);
    }
}

个人理解：lambda就是针对接口，接口中只能有一个抽象方法，使用lambda时，就相当于直接重写了接口中的抽象方法，传递一个实际参数，直接写出你要做的事情

运行结果：
在这里插入图片描述

引用对象实例化方法替换lambda

引用对象的实例方法：引用对象中的成员方法；对象::成员方法名

demo:小写的字符串转成大写

定义一个名字为printup的类

package com.itxs.demo05;

/**
 * @Classname : printup
 * @Description : TODO 输出大写字符串
 * @Author : lin_refuel@qq.com
 */
public class printup {
    public void printUp(String str){
        // toUpperCase是可以将小写转大写
        System.out.println("大写字母格式："+str.toUpperCase());
    }
}

定义一个名字为printupp的接口

package com.itxs.demo05;

/**
 * @Classname : printupp
 * @Description : TODO 打印大写字符串
 * @Author : lin_refuel@qq.com
 */
public interface printupp {
    void printtup(String str);
}

测试类

package com.itxs.demo05;

import java.util.Locale;

/**
 * @Classname : test
 * @Description : TODO 引用实例化对象的方法
 * @Author : lin_refuel@qq.com
 */
public class test {
    public static void main(String[] args) {
        // 小写字符串转大写字符串
        // 匿名内部类的方式实现
        print2(new printupp() {
            @Override
            public void printtup(String str) {
                System.out.println(str.toUpperCase());
            }
        });
        // 完整的lambda方式
        print2((String str)->{
            System.out.println(str.toUpperCase());
        });
        // lambda省略
        print2(str -> System.out.println(str.toUpperCase()));
        // 引用对象实例化方法 实例化对象 :: 方法名
        // 个人感觉：形参 p中的方法printtup按照实例化对象printup中的printUp方法的样子进行重写
        print2(new printup()::printUp);
    }
    private static void print2(printupp p){
        p.printtup("abcdefg");
    }
}

运行结果：
在这里插入图片描述

引用类中的实例方法替换lambda

引用类的实例方法：引用类中的成员方法；类名::方法名

demo:字符串截取

定义一个名字为intercept的接口

package com.itxs.demo06;

/**
 * @Classname : intercept
 * @Description : TODO
 * @Author : lin_refuel@qq.com
 */
public interface intercept {
    String cept(String str,int begin,int end);
}

test测试类,测试上面接口

package com.itxs.demo06;

/**
 * @Classname : test
 * @Description : TODO 字符串截取
 * @Author : lin_refuel@qq.com
 */
public class test {
    public static void main(String[] args) {
        //substring(),字符串截取方法
         //匿名内部类的方式
         res(new intercept() {
             @Override
             public String cept(String str, int begin, int end) {
                 return str.substring(begin,end);
             }
         });
         // lambda完整的写法
        res((String str,int begin,int end)->{
           return str.substring(begin,end);
        });
        // lambda省略
        res((str,begin,end)->str.substring(begin,end));
        // 引用类中实例方法进行替换，第一个参数作为对象，其他实参作为实例方法的形参进行传递
        res(String::substring);
    }
    private static void res(intercept i){
        String s = i.cept("abcdefg", 1, 5);//从下标1截取到下标4
        System.out.println(s);
    }
}

运行结果：
在这里插入图片描述

引用构造器替换lambda

引用构造方器：引用构造方法；类名::new

demo:通过接口获取学生类对象的几种方式

创建一个学生类

package com.itxs.demo07;

/**
 * @Classname : Student
 * @Description : TODO
 * @Author : lin_refuel@qq.com
 */
public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(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;
    }
}

定义一个接口，创建一个返回Student类型的抽象方法

package com.itxs.demo07;

/**
 * @Classname : student02
 * @Description : TODO
 * @Author : lin_refuel@qq.com
 */
public interface student02 {
    Student getstu(String name,Integer age);
}

test测试类

package com.itxs.demo07;

/**
 * @Classname : test
 * @Description : TODO 引用构造器替换lambda测试
 * @Author : lin_refuel@qq.com
 */
public class test {
    public static void main(String[] args) {
          // 匿名内部类获取一个学生类对象
         res(new student02() {
             @Override
             public Student getstu(String name, Integer age) {
                 return new Student(name,age);
             }
         });
         // lambda方式获取对象
        res((String name,Integer age)->{
            return new Student(name,age);
        });
        // 省略lambda
        res((name,age)->new Student(name,age));
        // 引用构造器
        res(Student::new);
    }
    private static void res(student02 sb){
        Student xs = sb.getstu("小肆", 18);
        System.out.println("姓名："+xs.getName()+" 年龄："+xs.getAge());
    }
}