1.方法引用
package lamdba;
public interface Printable {
void printString(String s);
}
package lamdba;
public class PrintableDemo {
public static void main(String[] args) {
/* userPrintable((String s) ->{
System.out.println(s);
});*/
//方法引用符 ::
userPrintable(System.out::println);
//可推导的就是可省略的
}
private static void userPrintable(Printable t){
t.printString("爱生活爱java");
}
}
输出结果:
爱生活爱java
package lamdba;
public interface Converter {
int convert(String s);
}
package lamdba;
public class ConverterDemo {
public static void main(String[] args) {
//内部类方式
/*userConverter(new Converter() {
@Override
public int convert(String s) {
return Integer.parseInt(s);
}
});*/
// lambda表达式方式
//userConverter( s -> Integer.parseInt(s));
//引用类方法
userConverter(Integer::parseInt);
//lambda表达式被类方法替代的时候,它的形式参数全部传递给静态方法作为参数
}
private static void userConverter(Converter c){
System.out.println(c.convert("123"));
}
}
输出结果
123
package lamdba;
public class PrintString {
public void printUpper(String s){
System.out.println(s.toUpperCase());
}
}
package lamdba;
public interface Printer {
void printUpperCase(String s);
}
package lamdba;
public class PrinterDemo {
public static void main(String[] args) {
// Lambda表达式
/* usePrinter((s) ->{
new PrintString().printUpper(s);
});*/
//方法引用
usePrinter(new PrintString()::printUpper);
//Lambda表达式被对象的实例方法替代的时候,它的形式参数全部传递给该方法作为参数
}
private static void usePrinter(Printer p){
p.printUpperCase("abc");
}
}
输出结果:
ABC
package lamdba;
public interface MyString {
String mySubString(String s,int x,int y);
}
package lamdba;
public class MyStringDemo {
public static void main(String[] args) {
//内部类
useMyString(new MyString() {
@Override
public String mySubString(String s, int x, int y) {
return s.substring(x,y);
}
});
//Lambda
useMyString((String s, int x, int y) ->{
return s.substring(x,y);
});
//引用方法
useMyString(String::substring);
//Lambda表达式被类的实例方法替代的时候,第一个参数作为调用者,后面的参数全部传递给该方法作为参数
}
private static void useMyString(MyString my){
String s =my.mySubString("hellojavaSE",2,5);
System.out.println(s);
}
}
package lamdba;
public class Student {
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public Student() {}
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;
}
}
package lamdba;
public interface StudentBuilder {
Student build(String name,int age);
}
package lamdba;
public class StudentDemo {
public static void main(String[] args) {
//内部类
useStudentBuilder(new StudentBuilder() {
@Override
public Student build(String name, int age) {
return new Student(name,age);
}
});
//Lambda
useStudentBuilder((String name,int age) ->{
return new Student(name,age);
});
// 方法引用
useStudentBuilder(Student::new);
//Lambda表达式被构造器替代的时候,它的形式参数全部传递给构造器作为参数
}
private static void useStudentBuilder(StudentBuilder sb){
Student ss = sb.build("alisa",29);
System.out.println(ss.getName()+","+ss.getAge());
}
}
输出结果:
alisa,29
alisa,29
alisa,29