java-lambda

lambda表达式

匿名内部类：可以是接口，可以是抽象类，可以是具体类。
lambda表达式：只能是接口

匿名内部类：接口中可以有多个抽象方法
lambda表达式：接口中只能有一个抽象方法

new Thread(new Runnable(){
    public void run(){
		sout("匿名内部类创建类接受参数为接口")；
}
}).start();

new Thread(() -> {
	sout("类接受参数为接口的lambda表达式")
}).start();

method(new interface(){
	public void run(){
		sout("匿名内部类形式调用形参为接口的方法")
	}
});

method(() -> {
	sout("lambda表达式形式调用形参为接口的方法");
});

//参数的类型可以省略
//多个参数时，不能只省略一个
method((int x) -> {
	return x;
});
method((x) -> {
	return x;
});

//如果参数只有一个，小括号可以省略
method(x->{
	return x;
});
//如果代码块语句只有一条，可以省略大括号和分号省略
//如果代码块包括return,return也要省略
method(x->sout(x));
method(x->x);

引用类方法

格式：类名::静态方法
范例：Integer::parseInt。将string转换为int类型数据
lambda表达式被类方法替代的时候，他的形式参数全部传递给静态方法

public class world {
    public static void main(String[] args) {
//        useConverter((String s)->{
//            return Integer.parseInt(s);
//        });
//        useConverter(s -> Integer.parseInt(s));
        useConverter(Integer::parseInt);
    }
    private static void useConverter(Converter converter){
        System.out.println(converter.resu("100"));
    }
}

引用对象的实例方法

格式：对象::成员方法
范例：“helloworld”::toUpperCase。将所有字符转大写
lambda表达式被对象的实例方法替代的时候，他的形式参数全部传递。

public class PrinterDemo {
    public static void main(String[] args) {
//        usePrinter(s -> System.out.println(s.toUpperCase()));
        PrintString printString = new PrintString();
        usePrinter(printString::printUpper);
        
    }
    private static void usePrinter(Printer p){
        p.printUpperCase("helloworld");
    }
}

引用类的实例方法

引用类中的成员方法
格式：类名::成员方法
范例：String::substring。截取字符串的长度
lambda表达式被类的实例方法代替的时候，第一个参数作为调用者，后面的参数传递给该方法作为参数

public class subDemo {
    public static void main(String[] args) {
//        usemySub((String s,int x,int y)->{
//            return s.substring(x,y);
//        });
//        usemySub((s, x, y) -> s.substring(x, y));
        usemySub(String::substring);
    }

    public static void usemySub(mySub mysub) {
        System.out.println(mysub.sub1("helloworld", 1, 4));
    }
}

引用构造器

格式：类名::new
范例：Student::new
lambda表达式被构造器替代的时候，他的形式参数全部传递。

public class StudentDemo {
    public static void main(String[] args) {
        useStudent(((name, age) -> new Student(name,age)));
//        useStudent(Student::new);
    }
    private static void useStudent(StudentBuilder s){
        Student student = s.build("java",10);
        System.out.println(student.getName()+student.getAge());
    }
}