文章目录
一、回顾匿名内部类
1.1 使用实现类
要启动一个线程，需要创建一个Thread类的对象并调用start方法。而为了指定线程执行的内容，需要调用 Thread 类的构造方法：
public Thread(Runnable target)
为了获取 Runnable 接口的实现对象，可以为该接口定义一个实现类 RunnableImpl ：
public class RunnableImpl implements Runnable {
@Override
public void run() {
System.out.println("多线程任务执行！");
}
}
然后创建该实现类的对象作为 Thread 类的构造参数：
public class Demo03ThreadInitParam {
public static void main(String[] args) {
Runnable task = new RunnableImpl();
new Thread(task).start();
}
}
1.2 使用匿名内部类
这个 RunnableImpl 类只是为了实现 Runnable 接口而存在的，而且仅被使用了唯一一次，所以使用匿名内部类的语法即可省去该类的单独定义，即匿名内部类：
public class Demo04ThreadNameless {
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("多线程任务执行！");
}
}).start();
}
}
1.3 匿名内部类的好处与弊端
一方面，匿名内部类可以帮我们省去实现类的定义；
另一方面，匿名内部类的语法——确实太复杂了！。
二、编程思想转换
我们真的希望创建一个匿名内部类对象吗？不。我们只是为了做这件事情而不得不创建一个对象。我们真正希望做的事情是：将 run 方法体内的代码传递给 Thread 类知晓。
传递一段代码——这才是我们真正的目的。而创建对象只是受限于面向对象语法而不得不采取的一种手段方式。那，有没有更加简单的办法？如果我们将关注点从“怎么做”回归到“做什么”的本质上，就会发现只要能够更好地达到目的，过程与形式其实并不重要。
故我们需要把面向对象的思想转换成函数式编程思想。
面向对象的思想 :
做一件事情，找一个能解决这个事情的对象，调用对象的方法，完成事情。
函数式编程思想 :
只要能获取到结果，谁去做的，怎么做的都不重要，重视的是结果，不重视过程
而JDK1.8中就新增了Lambda表达式来实现这种思想解决传递一段代码的目的。
三、Lambda表达式
-
Lambda 是一个匿名函数，我们可以把 Lambda 表达式理解为是一段可以传递的代码 (将代码像数据一样进行传递) 。
-
Lambda 表达式是 JDK1.8 的一个新特性，又称特殊的匿名内部类，可以取代大部分的匿名内部类，语法更简洁，可以写出更优雅的 Java 代码，可以极大地优化代码结构。
注意：Lambda 表达式不会生成单独的内部类文件，但匿名内部类会。
四、Lambda表达式特性
- Lambda 表达式没有显示的方法名。
- Lambda 表达式很像一个函数，具有参数列表、函数体、返回类型、异常，但没有函数名。
- Lambda 表达式可以作为方法的参数，也可以作为变量存储。
- Lambda 表达式的代码更加简洁和精确。
五、Lambda表达式的定义
-
基本语法：
<函数式接口> <变量名> = (参数类型 参数名称,参数类型 参数名称...) -> { //方法体 }; -
省略语法
<函数式接口> <变量名> = (参数名称, 参数名称...) -> 表达式;在Lambda基本语法的基础上，使用省略写法的规则为：
-
小括号内参数的类型可以省略；
-
如果小括号内有且仅有一个参，则小括号可以省略；
-
如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。
注意：要省略{ } ，return，分号必须一起省略
-
-
格式说明：
- 小括号内的语法与传统方法参数列表一致：无参数则留空；多个参数则用逗号分隔。
->是新引入的语法格式，代表指向动作，把参数传递给方法体{ }或者表达式。- 大括号内的语法与传统方法体要求基本一致，即重写接口的抽象方法的方法体。
-
注意事项：
- Lambda 表达式由三部分构成：参数列表、箭头（->）、Lambda 体。
- Lambda 体，可以是一个表达式，也可以是一个语句块。
- Lambda 体，表达式中不能加入 return 语句，因为在表达式中已经隐含了 return 语句；但是，语句块中没有隐含，需要使用 return 语句。
- Lambda 表达式并不是对所有接口都可以实现，接口需要满足一个条件才能被Lambda 表达式实现：Lambda 规定接口中只能有一个需要被实现的方法。注意，并不是规定接口中只能有一个方法。
特别提醒：
jdk1.8 中的另一个新特性：default，被 default 修饰的方法会有默认实现，不是必须被实现的方法。在实现Lambda 表达式的时候需注意。
六、Lambda 表达式的使用
6.1 无参，无返回值
Runnable r1 = () ->{System.out.println("Hello zsw");};
实例 : Runnable接口
//语法格式一：无参，无返回值
public class LambdaTest1 {
public static void main(String[] args) {
Runnable r1 = new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("Hello zsw");
}
};
r1.run();
System.out.println("********Lambda的写法*********");
Runnable r2 = () -> System.out.println("Hello zsw");
r2.run();
}
}
6.2 单参，无返回值
Consumer<String> con = (String str) -> {System.out.println(str);};
实例 : Consumer接口
//语法格式二:Lambda需要一个参数，但是没有返回值
public class LambdaTest2 {
public static void main(String[] args) {
Consumer<String> con = new Consumer<String>(){
@Override
public void accept(String s) {
System.out.println(s);
}
};
con.accept("谎言和誓言的区别是什么呢?");
System.out.println("********Lambda的写法*********");
Consumer<String> con1 = (String s) -> {
System.out.println(s);
};
con1.accept("一个是听的人当真了，一个是说的人当真了");
}
}
6.3 省略数据类型
因为可由编译器推断得出，称为类型推断
Consumer<String> con = (str) -> {System.out.println(str)}
代码示例 :
//语法格式三：数据类型可以省略，因为可由编译器推断得出，称为“类型推断”
public class LambdaTest3 {
public static void main(String[] args) {
//未使用Lambda表达式
Consumer<String> con = new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
};
con.accept("你好啊Lambda！");
System.out.println("====================");
//使用Lambda表达式
Consumer<String> con1 = (s) -> {
System.out.println(s);
};
con1.accept("我是Lambda");
}
}
6.4 单参，小括号可省略
Consumer<String> con = str -> {System.out.println(str)}
代码示例 :
//语法格式四：Lambda 若只需要一个参数时，参数的小括号可以省略
public class LambdaTest4 {
public static void main(String[] args) {
//未使用Lambda表达式
Consumer<String> con = new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
};
con.accept("你好啊Lambda！");
System.out.println("====================");
//使用Lambda表达式
Consumer<String> con1 = s -> {
System.out.println(s);
};
con1.accept("我是Lambda");
}
}
6.5 多参，多语句，且可有返回值
//语法格式五：Lambda 需要两个或以上的参数，多条执行语句，并且可以有返回值
public class LambdaTest5 {
public static void main(String[] args) {
//未使用Lambda表达式
Comparator<Integer> com1 = new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
System.out.println(o1);
System.out.println(o2);
return Integer.compare(o1, o2);
}
};
System.out.println(com1.compare(23, 45));
System.out.println("====================");
//使用Lambda表达式
Comparator<Integer> com2 = (o1, o2) -> {
System.out.println(o1);
System.out.println(o2);
return o1.compareTo(o2);
};
System.out.println(com2.compare(23, 12));
}
}
6.6 单语句，省略大括号
return和大括号若有，都可以省略
Comparator<Integer>com = (o1,o1) -> Integer.compare(o1,o2);
代码示例 :
//当Lamdba体只有一条语句时，return和大括号若有，都可以省略
public class LambdaTest6 {
public static void main(String[] args) {
//多参
Comparator<Integer> com1 = (o1, o2) ->{
return o1.compareTo(o2);
};
System.out.println(com1.compare(13, 12));
System.out.println("********Lambda表达式***********");
Comparator<Integer> com2 = (o1,o2) -> o1.compareTo(o2);
System.out.println(com2.compare(12, 21));
System.out.println("=============================");
//单参
Consumer<String> con2 = s ->
System.out.println(s);
con2.accept("一个是听得人当真了，一个是说的人当真了");
}
}
6.7 表达式使用技巧总结
- 形参列表的数据类型会自动判断。
- 如果形参列表为空，只需保留（）。
- 如果形参只有一个，（）可以省略，只需要参数的名称即可。
- 如果执行语句只有一句，且无返回值，则{ }可省略；如果有返回值，若想省略{ }，则必须同时省略return，且执行语句也必须保证只有一句。
6.8 Lambda表达式总结
- Lambda表达式的本质：作为函数式接口的实例
- 当你需要使用函数式接口写一个匿名实现类的对象的时候你可以用Lambda表达式
- 如果一个接口中, 只声明了一个抽象方法,则此接口就称为函数式接口（后面有一章专门会讲到）。我们可以在一个接口上可以在一个接口上用
@FunctionalInterface注解, 这样做可以检查它是否是一个函数式接口。 - 所以以前用匿名实现类表达的现在都可以用Lambda表达式
八、函数式接口（先了解）
若想详细了解，请点击 函数式接口
8.1 函数式接口概述
- 只包含一个抽象方法的接口,称为函数式接口。
- 你可以通过Lambda表达式来创建该接口的对象。（若Lambda表达式抛出一个受检异常（即：非运行时异常），那么该异常需要在目标接口的抽象方法上进行声明）。
- 可以在一个接口上使用
@FunctionalInterface注解，这样做可以检查它是否是一个函数式接口。同时javadoc也会包含一条声明，说明这个接口是一个函数式接口。 - 在
java.util.function包下定义了Java 8的丰富的函数式接口
8.2 四大核心函数式接口
- T - 函数输入的类型
- R - 函数的结果类型
| 函数式接口 | 参数类型 | 返回类型 | 用途 |
|---|---|---|---|
| Consumer<T> 消费类型接口 | T | void | 对类型为T的对象应用操作,包含方法：void accept(T t) |
| Supplier 供给型接口 | 无 | T | 返回类型为 T 的对象,包含方法 : T get() |
| Function<T,R>函数型接口 | T | R | 对象类型为 T 的对象应用操作，并返回结果。结果是 R 类型的对象。包含方法：R apply(T t) |
| Predicate<T>断定型接口 | T | boolean | 确定类型为 T 的对象是否满足某约束,并返回 boolean 值。包含方法: boolean test(T t) |
九、Lambda 表达式应用
9.1 方法引用
因本文只是粗略的提到方法引用，故详细请点 方法引用
方法引用可以看做是Lambda表达式深层次的表达。
换句话说，方法引用就是Lambda表达式，也就是函数式接口的一个实例，通过方法的名字来指向一个方法。
-
使用情景：
当要传递给Lambda体的操作，已经实现的方法了，可以使用方法引用！
-
引用语法：
类(或对象) :: 方法名 -
常见形式 ：
- 情况1 对象 :: 非静态方法
- 情况2 类 :: 静态方法
- 情况3 类 :: 非静态方法
-
引用要求：
- 要求接口中的抽象方法的形参列表和返回值类型与方法引用的方法的形参列表和返回值类型相同！（针对于情况1和情况2）
- 当函数式接口方法的第一个参数是需要引用方法的调用者，并且第二个参数是需要引用方法的参数(或无参数)时：
ClassName::methodName（针对于情况3）
-
使用建议:
如果给函数式接口提供实例，恰好满足方法引用的使用情境，就可以考虑使用方法引用给函数式接口提供实例。
如果不熟悉方法引用，那么还可以使用lambda表达式。
代码示例：
public class MethodReferences {
public static void main(String[] args) {
test7();
}
// 情况一：对象 :: 实例方法
//Consumer中的void accept(T t)
//PrintStream中的void println(T t)
public static void test1() {
//使用Lambda表达
Consumer<String> con1 = str -> System.out.println(str);
con1.accept("中国");
System.out.println("====================");
//使用方法引用
PrintStream ps = System.out;
Consumer con2 = ps::println;
con2.accept("China");
}
//Supplier中的T get()
//Employee中的String getName()
public static void test2() {
//使用Lambda表达
Employee emp = new Employee(1001, "Bruce", 34, 600);
Supplier<String> sup1 = () -> emp.getName();
System.out.println(sup1.get());
System.out.println("====================");
//使用方法引用
Supplier sup2 = emp::getName;
System.out.println(sup2.get());
}
// 情况二：类 :: 静态方法
//Comparator中的int compare(T t1,T t2)
//Integer中的int compare(T t1,T t2)
public static void test3() {
//使用Lambda表达
Comparator<Integer> com1 = (t1, t2) -> Integer.compare(t1, t2);
System.out.println(com1.compare(32, 45));
System.out.println("====================");
//使用方法引用
Comparator<Integer> com2 = Integer::compareTo;
System.out.println(com2.compare(43, 34));
}
//Function中的R apply(T t)
//Math中的Long round(Double d)
public static void test4() {
//使用匿名内部类
Function<Double, Long> func = new Function<Double, Long>() {
@Override
public Long apply(Double aDouble) {
return Math.round(aDouble);
}
};
System.out.println(func.apply(10.5));
System.out.println("====================");
//使用Lambda表达式
Function<Double, Long> func1 = d -> Math.round(d);
System.out.println(func1.apply(12.3));
System.out.println("====================");
//使用方法引用
Function<Double, Long> func2 = Math::round;
System.out.println(func2.apply(12.6));
}
// 情况三：类 :: 实例方法
// Comparator中的int comapre(T t1,T t2)
// String中的int t1.compareTo(t2)
public static void test5() {
//使用Lambda表达式
Comparator<String> com1 = (s1, s2) -> s1.compareTo(s2);
System.out.println(com1.compare("abd", "aba"));
System.out.println("====================");
//使用方法引用
Comparator<String> com2 = String::compareTo;
System.out.println(com2.compare("abd", "abc"));
}
//BiPredicate中的boolean test(T t1, T t2);
//String中的boolean t1.equals(t2)
public static void test6() {
//使用Lambda表达式
BiPredicate<String, String> pre1 = (s1, s2) -> s1.equals(s2);
System.out.println(pre1.test("abc", "abc"));
System.out.println("====================");
//使用方法引用
BiPredicate<String, String> pre2 = String::equals;
System.out.println(pre2.test("abc", "abd"));
}
// Function中的R apply(T t)
// Employee中的String getName();
public static void test7() {
//使用Lambda表达式
Employee employee = new Employee(1001, "Tom", 45, 10000);
Function<Employee, String> func1 =e->e.getName();
System.out.println(func1.apply(employee));
System.out.println("====================");
//使用方法引用
Function<Employee,String>func2 = Employee::getName;
System.out.println(func2.apply(employee));
}
}
9.2 构造器和数组的引用
-
使用格式:
方法引用 : 类名 :: new
数组引用 ：数组类型 [] :: new
-
使用要求:
-
构造器引用
和方法引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致。抽象方法的返回值类型即为构造器所属的类的类型
-
数组引用
可以把数组看做是一个特殊的类，则写法与构造器引用一致。
-
-
使用举例
-
构造器的引用
public class ConstructorReferences { public static void main(String[] args) { test3(); } //构造器引用 //Supplier中的T get() public static void test1() { //使用匿名内部类 Supplier<Employee> sup = new Supplier<Employee>() { @Override public Employee get() { return new Employee(); } }; System.out.println(sup.get()); //使用Lambda表达式 System.out.println("===================="); Supplier<Employee> sup1 = () -> new Employee(1001, "Tom", 43, 13333); System.out.println(sup1.get()); //使用方法引用 Supplier<Employee> sup2 = Employee::new; System.out.println(sup2.get()); } //Function中的R apply(T t) public static void test2() { //使用Lambda表达式 Function<Integer, Employee> func1 = id -> new Employee(id); Employee employee = func1.apply(1001); System.out.println(employee); System.out.println("===================="); //使用方法引用 Function<Integer, Employee> func2 = Employee::new; Employee employee1 = func2.apply(1002); System.out.println(employee1); } //BiFunction中的R apply(T t,U u) public static void test3() { //使用Lambda表达式 BiFunction<Integer, String, Employee> func1 = (id, name) -> new Employee(id, name); System.out.println(func1.apply(1001, "Tom")); System.out.println("===================="); //使用方法引用 BiFunction<Integer, String, Employee> func2 = Employee::new; System.out.println(func2.apply(1002, "Jarry")); } } -
数组引用
//数组引用 //Function中的R apply(T t) public static void test4() { Function<Integer, String[]> func1 = length -> new String[length]; String[] arr1 = func1.apply(5); System.out.println(Arrays.toString(arr1)); System.out.println("===================="); //使用方法引用 Function<Integer,String[]>func2=String[]::new; String[] arr2 = func2.apply(10); System.out.println(Arrays.toString(arr2)); }
-
9.3 创建线程
public class TestLambda {
public static void main(String[] args) {
// 匿名内部类
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println("子程序执行。。。");
}
};
// Lambda表达式
Runnable runnable2 = ()->System.out.println("子程序执行2。。。");
new Thread(runnable2).start();
new Thread(()->System.out.println("子程序执行3。。。")).start();
}
}
9.4 集合操作
可以调用集合的 public void forEach(Consumer<? super E> action) 方法，通过 Lambda 表达式的方式遍历集合中的元素。Consumer 接口是 jdk 为我们提供的一个函数式接口(后面会讲，现在了解即可)。
public class test {
// 集合遍历
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
Collections.addAll(list, 4, 3, 9, 0, 5);
// 方法引用
list.forEach(System.out::println);
// Lambda表达式 element上下文推断为list里的集合元素
list.forEach(element -> {
if (element % 2 == 0) {
System.out.println(element);
}
});
}
}
public class test {
// 集合排序
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
Collections.addAll(list, 4, 3, 9, 0, 5);
// 匿名内部类
list.sort(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1 - o2;
}
});
// lambda表达式
list.sort((o1,o2)->o1-o2);
list.forEach(System.out::println);
}
}
3178
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
