函数式编程思想概述
函数式思想则尽量忽略面向对象的复杂语法:“强调做什么,而不是以什么形式去做”
而Lambda表达式就是函数式思想的体现
lambda 表达式(闭包)
基本概念
Lambda 允许把函数作为一个方法的参数(函数作为参数传递进方法中)。
使用 Lambda 表达式可以使代码变的更加简洁紧凑。
(形式参数) -> {代码块}
-
-
形式参数:如果有多个参数,参数之间用逗号隔开;如果没有参数,留空即可
-
->:由英文中画线和大于符号组成,固定写法。代表指向动作
-
代码块:是我们具体要做的事情,也就是以前我们写的方法体内容
-
省略模式
-
-
如果参数有且仅有一个,那么小括号可以省略
-
组成Lambda表达式的三要素
Lambda 表达式练习
无参无返回值抽象方法
-
-
定义一个测试类(EatableDemo),在测试类中提供两个方法
-
一个方法是:useEatable(Eatable e)
-
-
//接口
public interface Eatable {
void eat();
}
//实现类
public class EatableIml implements Eatable{
@Override
public void eat() {
System.out.println("666666");
}
}
//测试类
public class EatableDemo {
public static void main(String[] args) {
//主方法调用
Eatable e=new EatableIml();
useEatable(e);
//匿名内部类
useEatable(new Eatable() {
@Override
public void eat() {
System.out.println("666666");
}
});
//Lambda表达式
useEatable(()->{
System.out.println("666666");
});
}
private static void useEatable(Eatable e){
e.eat();
}
}
有参无返回值抽象方法
-
-
定义一个测试类(FlyableDemo),在测试类中提供两个方法
-
一个方法是:useFlyable(Flyable f)
-
-
public interface Flyable {
void fly(String s);
}
public class FlyableDemo {
public static void main(String[] args) {
//在主方法中调用useFlyable方法
//匿名内部类
useFlyable(new Flyable() {
@Override
public void fly(String s) {
System.out.println(s);
System.out.println("飞机自驾游");
}
});
System.out.println("--------");
//Lambda
useFlyable((String s) -> {
System.out.println(s);
System.out.println("飞机自驾游");
});
}
private static void useFlyable(Flyable f) {
f.fly("风和日丽,晴空万里");
}
}
有参有返回值抽象方法
-
-
定义一个测试类(AddableDemo),在测试类中提供两个方法
-
一个方法是:useAddable(Addable a)
-
-
public interface Addable {
int add(int x,int y);
}
public class AddableDemo {
public static void main(String[] args) {
//在主方法中调用useAddable方法
useAddable((int x,int y) -> {
return x + y;
});
}
private static void useAddable(Addable a) {
int sum = a.add(10, 20);
System.out.println(sum);
}
}
-
-
必须有上下文环境,才能推导出Lambda对应的接口
-
根据局部变量的赋值得知Lambda对应的接口
Runnable r = () -> System.out.println("Lambda表达式");
-
根据调用方法的参数得知Lambda对应的接口
-
-
-
匿名内部类:可以是接口,也可以是抽象类,还可以是具体类
-
Lambda表达式:只能是接口
-
-
使用限制不同
-
如果接口中有且仅有一个抽象方法,可以使用Lambda表达式,也可以使用匿名内部类
-
如果接口中多于一个抽象方法,只能使用匿名内部类,而不能使用Lambda表达式
-
-
实现原理不同
-
匿名内部类:编译之后,产生一个单独的.class字节码文件
-
-
补充:
Lambda表达式是延迟执行的,有些场景的代码执行后,结果不一定会被使用,从而造成性能浪费,可作为解决方案,提升性能。
方法引用
出现原因
在使用Lambda表达式的时候,我们实际上传递进去的代码就是一种解决方案:拿什么参数做什么操作。那么考虑一种情况:如果我们在Lambda中所指定的操作方案,已经有地方存在相同方案,那是否还有必要再写重复逻辑?
:: 该符号为引用运算符,而它所在的表达式被称为方法引用
推导与省略
-
-
如果使用Lambda,那么根据“可推导就是可省略”的原则,无需指定参数类型,也无需指定的重载形式,它们都将被自动推导
-
如果使用方法引用,也是同样可以根据上下文进行推导
-
-
public interface Converter {
int conver(String s);
}public class ConverterDemo {
public static void main(String[] args) {
// lambda表达式 引用类方法 类名.方法名,
// 传递的参数类型可省略,return也可以,中括号也可省略
// 因为我们使用该方法的目的是将参数的类型进行转化
// 再Integer对象有个方法是可以将字符串传化为int
// 而且我们使用该方法的参数类型就是int
// 我们只需要返回一个int对象就可以了,
// 就可以直接使用调用Integer类.parseInt方法,return一个int类型的变量
useConverter((s)-> Integer.parseInt(s));
// 方法引用,道理也是相同,我们不用管参数类型
// 因为当使用方法引用时,
// lambda表达式中的参数会直接给到引用的静态方法作为参数
// Lambda表达式被类方法替代的时候,它的形式参数全部传递给静态方法作为参数
useConverter(Integer::parseInt);
}
private static void useConverter(Converter c) {
int num = c.conver("8888");
System.out.println(num);
}
}
public interface Printer {
void printUpperCase(String s);
}
public class PrintString {
public void printUpper(String s){
String result = s.toUpperCase();
System.out.println(result);
}
}
public class PrinterDemo {
public static void main(String[] args) {
// lambda表达式,获取参数。调用String类下toUpperCase方法
// toUpperCase方法将此String所有字符转换为大写
usePrinter((s)->{
System.out.println(s.toUpperCase());
});
// 方法引用,调用类中成员方法
// 创建类对象,使用该类下的成员方法printUpper
// Lambda表达式被对象的实例方法替代的时候,
// 它的形式参数全部传递给该方法作为参数
PrintString printString = new PrintString();
usePrinter(printString::printUpper);
}
private static void usePrinter(Printer p) {
p.printUpperCase("dgwgwgehegwee");
}
}
public interface MyString {
String myString(String s,int x,int y);
}
public class MyStringDemo {
public static void main(String[] args) {
// lambda表达式,返回一个字符串对象,对字符串操作截取,substring方法
useMyString((s,x,y)->s.substring(5,7));
useMyString((s,x,y)->s.substring(5,8));
// 方法引用,Lambda表达式被类的实例方法,替代时,第一个参数作为调用者,剩余参数作为该方法的参数
// 方法引用就是对lambda表达式方案的重复调
// 用已经存在的方案
useMyString(String::substring);
}
private static void useMyString(MyString my){
String s =my.myString("ghhdhdhvdsvsvs",5,7);
System.out.println(s);
}
}
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;
}
}
public interface StudentBuilder {
Student build(String name,int age);
}
public class StudentDemo {
public static void main(String[] args) {
//Lambda简化写法
useStudentBuilder((name,age) -> new Student(name,age));
//引用构造器
useStudentBuilder(Student::new);
}
private static void useStudentBuilder(StudentBuilder sb) {
Student s = sb.build("林青霞", 30);
System.out.println(s.getName() + "," + s.getAge());
}
}