方法引用
在使用Lambda表达式的时候,我们实际上传递进去的代码就是一种解决方案:那参数做操作
弱国我们在Lambda中苏哦指定的操作方案,已经有地方存在相同方案,那是否还有必要再写重复逻辑呢,答案肯定时没有必要。
我们通过方法引用使用已经存在的方案
public interface PrintTxt {
void PringString(String s);
}
public class Demo {
public static void main(String[] args) {
usePring( s -> System.out.println(s));
//方法引用符: "::"
usePring(System.out::print);
//可推到的就是可以省略的
}
static void usePring(PrintTxt pt){
pt.PringString("爱生活");
}
}
方法引用符
-
:: 该符号为引用运算符,而它所在的表达式被称为方法引用
-
Lambda表达式: usePring( s -> System.out.println(s));
- 分析:拿到参数s之后通过Lambda表达式,传递给 System.out.println方法处理
-
方法引用:usePring(System.out::print);
*分析:直接使用System.out中的println方法取代Lambda,代码更加简洁
推导与省略
- 如果使用Lambda,那么根据"可推到就是可省略"的原则,无需指定参数类型,也无需指定的重载形式,他们都将被自动推导
- 如果使用方法引用,也是同样可以根据上下文进行推导
- 方法引用时Lambda的孪生兄的
Lambda表达式支持的方法引用
常见引用方式:
- 引用类方法
- 引用对象的实例方法
- 引用类的实例方法
- 引用构造器
引用类方法
其实就是引用静态的方法
- 格式:类名::静态方法
- 例:Integer::parseInt
- Integer类的方法:public static int parseInt(String s)将此String传唤为int类型数据
public interface Converter {
int convert(String s);
}
public class Demo {
public static void main(String[] args) {
//Lambda表达式
useConverter(s -> Integer.parseInt(s));
//引用类方法
useConverter(Integer::parseInt);
//Lambda表达式被类方法替代的时候,它的形式参数全部传递给静态方法作为参数
}
private static void useConverter(Converter c){
int convert = c.convert("1234");
System.out.println(convert);
}
}
引用对象的实例方法
就是引用类中的成员方法
- 格式:对象::成员方法
- 例:"HelloWorld"::toUpperCase
- String类中的方法:public String toUpperCase()将此String所有字符转换为大写
public interface Printer {
void printUpperCase(String s);
}
public class PrintString {
public void printUpper(String s){
String s1 = s.toUpperCase();
System.out.println(s1);
}
}
public class Demo {
public static void main(String[] args) {
//Lambda表达式
usePrinter(s -> System.out.println(s.toUpperCase()));
//引用对象的实例方法
PrintString ps = new PrintString();
usePrinter(ps::printUpper);
//Lambda表达式被对象的实例方法代替的时候,它的形式参数全部传递给该方法作为参数
}
private static void usePrinter(Printer p){
p.printUpperCase("HelloWorld");
}
}
引用类的实例方法
其实就是引用类中的成员方法
- 格式:类名::成员方法
- 例:String::substring
- String 类中的方法:public String usbstring(int beginIndex,int endIndex)
- 从beginIndex开始到endIndex结束,截取字符串。返回一个字串,字串的长度为endIndex-beginIndex
public interface MyString {
String mySubString(String s, int x, int y);
}
public class Demo {
public static void main(String[] args) {
//Lambda表达式
useMyString((s,x,y) -> s.substring(x,y));
//引用类的实例方法
useMyString(String::substring);
//Lambda表达式被类的实例方法替代的时候
//第一个参数作为调用者
//后面的参数全部传递给该方法作为参数
}
private static void useMyString(MyString m){
String s = m.mySubString("Helloworld", 2, 8);
System.out.println(s);
}
}
引用构造器
就是引用构造方法
- 格式:类名::new
- 例:Student::new
public interface StudentBuilder {
Student build(String name,int age);
}
public class Student {
String name;
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;
}
}
public class Demo {
public static void main(String[] args) {
//Lambda表达式
useStudentBuilder(((name, age) -> new Student(name,age)));
//引用构造器
useStudentBuilder(Student::new);
//Lambda表达式被构造器代替的时候,它的形式参数全部传递给构造器作为参数
}
private static void useStudentBuilder(StudentBuilder sb){
Student s = sb.build("张三", 20);
System.out.println(s.getName()+","+s.getAge());
}
}