第九章 Lambda&方法引用

怼烎@ 2023-02-28 15:18 13阅读 0赞

### 目录 ###

*   *  9.1、Lambda表达式
     *   *  9.1.1、标准格式
         *  9.1.2、使用前提
         *  9.1.3、常见应用
         *   *  9.1.3.1、无参无返回值抽象方法练习
             *  9.1.3.2、有参无返回值抽象方法练习
             *  9.1.3.3、有参有返回值抽象方法练习
         *  9.1.4、省略模式
         *  9.1.5、注意事项
         *  9.1.6、Lambda表达式和匿名内部类的区别
     *  9.2、方法引用
     *   *  9.2.1、概述
         *  9.2.2、方法引用符
         *  9.2.3、省略模式
         *  9.2.4、常见应用
         *   *  9.2.4.1、引用类方法
             *  9.2.4.2、引用类的实例方法
             *  9.2.4.3、引用对象的实例方法
             *  9.2.4.4、引用构造器方法

--------------------

## 9.1、Lambda表达式 ##

### 9.1.1、标准格式 ###

(形式参数) -> { 代码块}

### 9.1.2、使用前提 ###

有一个接口并且接口中有且仅有一个抽象方法

### 9.1.3、常见应用 ###

#### 9.1.3.1、无参无返回值抽象方法练习 ####

interface MyInter { 
    	void show();
    }
    
    public class Main { 
    	public static void main(String[] args) { 
    		myInterShow(() -> System.out.println("Hello,World"));
    	}
    
    	public static void myInterShow(MyInter mi) { 
    		mi.show();
    	}
    }

#### 9.1.3.2、有参无返回值抽象方法练习 ####

interface MyInter { 
    	void show(String s);
    }
    
    public class Main { 
    	public static void main(String[] args) { 
    		myInterShow((s) -> System.out.println(s));
    	}
    
    	public static void myInterShow(MyInter mi) { 
    		mi.show("Hello,World");
    	}
    }

#### 9.1.3.3、有参有返回值抽象方法练习 ####

interface MyInter { 
    	int show(int x, int y);
    }
    
    public class Main { 
    	public static void main(String[] args) { 
    		myInterShow((x, y) -> x + y);
    	}
    
    	public static void myInterShow(MyInter mi) { 
    		int show = mi.show(10, 20);
    		System.out.println(show);
    	}
    }

### 9.1.4、省略模式 ###

1.  参数类型可以省略。但是有多个参数的情况下，不能只省略一个
2.  如果参数有且仅有一个，那么小括号可以省略
3.  如果代码块的语句只有一条，可以省略大括号和分号和return关键字

### 9.1.5、注意事项 ###

1.  使用Lambda必须要有接口并且要求接口中有且仅有一个抽象方法
2.  必须有上下文环境，才能推导出Lambda对应的接口
    
     *  根据局部变量的赋值得知Lambda对应的接口
    
        Runnable r = () -> System.out.println("Hello,World");
    
     *  根据调用方法的参数得知Lambda对应的接口
    
        new Thread(() -> System.out.println("Hello,World")).start();

### 9.1.6、Lambda表达式和匿名内部类的区别 ###

1.  所需类型不同
    
     *  匿名内部类：可以是接口，也可以是抽象类，还可以是具体类
     *  Lambda表达式：只能是接口
2.  使用限制不同
    
     *  如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类
     *  如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用Lambda表达式
3.  实现原理不同
    
     *  匿名内部类：编译之后，产生一个单独的.class字节码文件
     *  Lambda表达式：编译之后，没有一个单独的.class字节码文件，对应的字节码会在运行的时候动态生成

## 9.2、方法引用 ##

### 9.2.1、概述 ###

在使用Lambda表达式的时候，我们实际上传递进去的代码就是一种解决方案，拿参数做操作，如果我们在Lambda中所指定的操作方案，已经有地方存在相同方案，那是否还有必要再写重复逻辑呢？肯定是没必要，那我们又是如何使用已经存在的方案的呢？我们是通过方法引用来使用已经存在的方案

### 9.2.2、方法引用符 ###

::  该符号为引用运算符，而它所在的表达式被称为方法引用

### 9.2.3、省略模式 ###

方法引用可以根据上下文进行推导，方法引用是Lambda的孪生兄弟

### 9.2.4、常见应用 ###

#### 9.2.4.1、引用类方法 ####

使用说明：Lambda表达式被类方法替代的时候，它的形式参数全部传递给静态方法作为参数

interface Converter { 
    	int convert(String s);
    }
    
    public class Main { 
    	public static void main(String[] args) { 
    		// Lambda写法
    		useConverter(s -> Integer.parseInt(s));
    		// 引用的方法
    		useConverter(Integer::parseInt);
    	}
    
    	private static void useConverter(Converter c) { 
    		int number = c.convert("666");
    		System.out.println(number);
    	}
    }

#### 9.2.4.2、引用类的实例方法 ####

使用说明：Lambda表达式被类的实例方法替代的时候，第一个参数作为调用者，后面的参数全部传递给该方法作为参数

interface MyString { 
    	String mySubString(String s, int x, int y);
    }
    
    public class Main { 
    	public static void main(String[] args) { 
    		// Lambda写法
    		useMyString((s, x, y) -> s.substring(x, y));
    		// 引用的方法
    		useMyString(String::substring);
    	}
    
    	private static void useMyString(MyString my) { 
    		String s = my.mySubString("HelloWorld", 2, 5);
    		System.out.println(s);
    	}
    }

#### 9.2.4.3、引用对象的实例方法 ####

使用说明：Lambda表达式被对象的实例方法替代的时候，它的形式参数全部传递给该方法作为参数

class PrintString { 
    	public void printUpper(String s) { 
    		String result = s.toUpperCase();
    		System.out.println(result);
    	}
    }
    
    interface Printer { 
    	void printUpperCase(String s);
    }
    
    public class Main { 
    	public static void main(String[] args) { 
    		// Lambda写法
    		usePrinter(s -> System.out.println(s.toUpperCase()));
    		// 引用的方法
    		PrintString ps = new PrintString();
    		usePrinter(ps::printUpper);
    	}
    
    	private static void usePrinter(Printer p) { 
    		p.printUpperCase("HelloWorld");
    	}
    }

#### 9.2.4.4、引用构造器方法 ####

使用说明：Lambda表达式被构造器替代的时候，它的形式参数全部传递给构造器作为参数

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;
    	}
    }
    
    interface StudentBuilder { 
    	Student build(String name, int age);
    }
    
    public class Main { 
    	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());
    	}
    }