Lambda表达式
一、Lambda表达式简介
什么是Lambda？
Lambda是JAVA 8添加的新特性，说白了，Lambda是一个匿名函数
为什么使用Lambda
使用Lambda表达式可以对一个接口的方法进行非常简洁的实现
Lambda对接口的要求
虽然可以使用Lambda表达式对某些接口进行简单的实现，但是并不是所有的接口都可以用Lambda表达式来实现，要求接口中定义的 必须要实现的抽象方法只能是一个 在JAVA8中 ，对接口加了一个新特性：default 可以使用default对接口方法进行修饰，被修饰的方法在接口中可以默认实现
@FunctionalInterface
修饰函数式接口的，接口中的抽象方法只有一个
二、Lambda的基础语法
1.语法 // 1.Lambda表达式的基础语法 // Lambda是一个匿名函数 一般关注的是以下两个重点 // 参数列表 方法体 /** * （）：用来描述参数列表 * {}：用来描述方法体 有时可以省略 * ->: Lambda运算符 读作goes to * 例 Test t=()->{System.out.println("hello word")}; 大括号可省略 */
2.创建多个接口 /** * 无参数无返回值接口 * @author Alan * @version 1.0 * @date 2020-05-27 10:24 */ @FunctionalInterface public interface LambdaNoneReturnNoneParmeter { void test(); } /** * 无返回值有单个参数 * @author Alan * @version 1.0 * @date 2020-05-27 10:26 */ @FunctionalInterface public interface LambdaNoneReturnSingleParmeter { void test(int n); } /** * 无返回值 多个参数的接口 * @author Alan * @version 1.0 * @date 2020-05-27 10:27 */ @FunctionalInterface public interface LambdaNoneReturnMutipleParmeter { void test(int a,int b); } /** * 有返回值 无参数接口 * @author Alan * @version 1.0 * @date 2020-05-27 10:28 */ @FunctionalInterface public interface LambdaSingleReturnNoneParmeter { int test(); } /** * 有返回值 有单个参数的接口 * @author Alan * @version 1.0 * @date 2020-05-27 10:29 */ @FunctionalInterface public interface LambdaSingleReturnSingleParmeter { int test(int n); } /** * 有返回值 有多个参数的接口 * @author Alan * @version 1.0 * @date 2020-05-27 10:30 */ @FunctionalInterface public interface LambdaSingleReturnMutipleParmeter { int test(int a,int b); }
3.创建测试类 package com.alan.learn.syntax; import com.alan.learn.interfaces.*; /** * @author Alan * @version 1.0 * @date 2020-05-27 10:33 */ public class Syntax1 { public static void main(String[] args) { // 1.Lambda表达式的基础语法 // Lambda是一个匿名函数 一般关注的是以下两个重点 // 参数列表 方法体 /** * （）：用来描述参数列表 * {}：用来描述方法体 * ->: Lambda运算符 读作goes to */ // 无参无返回 LambdaNoneReturnNoneParmeter lambda1=()->{ System.out.println("hello word"); }; lambda1.test(); // 无返回值 单个参数 LambdaNoneReturnSingleParmeter lambda2=(int n)->{ System.out.println("参数是："+n); }; lambda2.test(10); // 无返回值 多个参数 LambdaNoneReturnMutipleParmeter lambda3=(int a,int b)->{ System.out.println("参数和是："+(a+b)); }; lambda3.test(10,12); // 有返回值 无参数 LambdaSingleReturnNoneParmeter lambda4=()->{ System.out.println("lambda4："); return 100; }; int ret=lambda4.test(); System.out.println("返回值是："+ret); // 有返回值 单个参数 LambdaSingleReturnSingleParmeter lambda5=(int a)->{ return a*2; }; int ret2= lambda5.test(3); System.out.println("单个参数，lambda5返回值是:"+ret2); //有返回值 多个参数 LambdaSingleReturnMutipleParmeter lambda6=(int a,int b)->{ return a+b; }; int ret3=lambda6.test(12,14); System.out.println("多个参数，lambda6返回值是："+ret3); } } 输出结果： hello word 参数是：10 参数和是：22 lambda4： 返回值是：100 单个参数，lambda5返回值是:6 多个参数，lambda6返回值是：26
三、语法精简
针对上述基础语法的精简
1.参数类型精简 /** * 语法精简 * 1.参数类型 * 由于在接口的抽象方法中，已经定义了参数的数量类型 所以在Lambda表达式中参数的类型可以省略 * 备注：如果需要省略类型，则每一个参数的类型都要省略，千万不要一个省略一个不省略 */ LambdaNoneReturnMutipleParmeter lambda1=(int a,int b)-> { System.out.println("hello world"); }; 可以精简为: LambdaNoneReturnMutipleParmeter lambda1=(a,b)-> { System.out.println("hello world"); };
2.参数小括号精简 /** * 2.参数小括号 * 如果参数列表中，参数的数量只有一个 此时小括号可以省略 */ LambdaNoneReturnSingleParmeter lambda2=(a)->{ System.out.println("hello world"); }; 可以精简为: LambdaNoneReturnSingleParmeter lambda2= a->{ System.out.println("hello world"); };
3.方法大括号精简 /** * 3.方法大括号 * 如果方法体中只有一条语句，此时大括号可以省略 */ LambdaNoneReturnSingleParmeter lambda3=a->{ System.out.println("hello world"); }; 可以精简为: LambdaNoneReturnSingleParmeter lambda3=a->System.out.println("hello world");
4.大括号精简补充 /** * 4.如果方法体中唯一的一条语句是一个返回语句 * 贼省略大括号的同时 也必须省略return */ LambdaSingleReturnNoneParmeter lambda4=()->{ return 10; }; 可以精简为: LambdaSingleReturnNoneParmeter lambda4=()->10;
5.多参数，有返回值 精简 LambdaSingleReturnNoneParmeter lambda4=(a,b)->{ return a+b; }; 可以精简为: LambdaSingleReturnMutipleParmeter lambda5=(a,b)->a+b;
四、Lambda语法进阶
1.方法引用(普通方法与静态方法)
在实际应用过程中，一个接口在很多地方都会调用同一个实现，例如： LambdaSingleReturnMutipleParmeter lambda1=(a,b)->a+b; LambdaSingleReturnMutipleParmeter lambda2=(a,b)->a+b;
这样一来每次都要写上具体的实现方法 a+b，如果需求变更，则每一处实现都需要更改，基于这种情况，可以将后续的是实现更改为已定义的 方法，需要时直接调用就行
语法： /** *方法引用： * 可以快速的将一个Lambda表达式的实现指向一个已经实现的方法 * 方法的隶属者 如果是静态方法 隶属的就是一个类 其他的话就是隶属对象 * 语法：方法的隶属者::方法名 * 注意： * 1.引用的方法中，参数数量和类型一定要和接口中定义的方法一致 * 2.返回值的类型也一定要和接口中的方法一致 */
例： package com.alan.learn.syntax; import com.alan.learn.interfaces.LambdaSingleReturnSingleParmeter; /** * @author Alan * @version 1.0 * @date 2020-05-27 11:48 */ public class Syntax3 { public static void main(String[] args) { LambdaSingleReturnSingleParmeter lambda1=a->a*2; LambdaSingleReturnSingleParmeter lambda2=a->a*2; LambdaSingleReturnSingleParmeter lambda3=a->a*2; //简化 LambdaSingleReturnSingleParmeter lambda4=a->change(a); //方法引用 LambdaSingleReturnSingleParmeter lambda5=Syntax3::change; } /** * 自定义的实现方法 */ private static int change(int a){ return a*2; } }
2.方法引用(构造方法)
目前有一个实体类 public class Person { public String name; public int age; public Person() { System.out.println("Person的无参构造方法执行"); } public Person(String name, int age) { this.name = name; this.age = age; System.out.println("Person的有参构造方法执行"); } }
需求
两个接口，各有一个方法，一个接口的方法需要引用Person的无参构造，一个接口的方法需要引用Person的有参构造 用于返回两个Person对象，例： interface PersonCreater{ //通过Person的无参构造实现 Person getPerson(); } interface PersonCreater2{ //通过Person的有参构造实现 Person getPerson(String name,int age); }
那么可以写作： public class Syntax4 { public static void main(String[] args) { PersonCreater creater=()->new Person(); //引用的是Person的无参构造 //PersonCreater接口的方法指向的是Person的方法 PersonCreater creater1=Person::new; //等价于上面的()->new Person() //实际调用的是Person的无参构造 相当于把接口里的getPerson()重写成new Person()。 Person a=creater1.getPerson(); //引用的是Person的有参构造 PersonCreater2 creater2=Person::new; Person b=creater2.getPerson("张三",18); } }
注意：是引用无参构造还是引用有参构造 在于接口定义的方法参数
五、综合练习
1.集合排序案例 package com.alan.exercise; import com.alan.learn.data.Person; import java.util.ArrayList; /** * 集合排序案例 * @author Alan * @version 1.0 * @date 2020-05-27 15:08 */ public class Exercise1 { public static void main(String[] args) { //需求：已知在一个ArrayList中有若干各Person对象，将这些Person对象按照年龄进行降序排列 ArrayList<Person> list=new ArrayList<>(); list.add(new Person("张三",10)); list.add(new Person("李四",12)); list.add(new Person("王五",13)); list.add(new Person("赵六",14)); list.add(new Person("李雷",11)); list.add(new Person("韩梅梅",8)); list.add(new Person("jack",10)); System.out.println("排序前："+list); //将排列的依据传入 具体的方法指向的是 内部元素的age相减 sort会依据结果的正负进行降序排列 //sort 使用提供的 Comparator对此列表进行排序以比较元素。 list.sort((o1, o2) -> o2.age-o1.age); System.out.println("排序后："+list); } }
2.Treeset排序案例 package com.alan.exercise; import com.alan.learn.data.Person; import java.util.TreeSet; /** * @author Alan * @version 1.0 * @date 2020-05-27 15:37 */ public class Exercise2 { public static void main(String[] args) { /**Treeset 自带排序 * 但是现在不知道Person谁大谁小无法排序 * 解决方法： * 使用Lambda表达式实现Comparator接口，并实例化一个TreeSet对象 * 注意：在TreeSet中如果Comparator返回值是 0 会判断这是两个元素是相同的 会进行去重 * TreeSet<Person> set=new TreeSet<>((o1, o2) -> o2.age-o1.age); * 这个获取的对象打印会少一个Person * 此时我们将方法修改 */ TreeSet<Person> set=new TreeSet<>((o1, o2) ->{ if(o1.age>=o2.age){ return -1; }else { return 1; } }); set.add(new Person("张三",10)); set.add(new Person("李四",12)); set.add(new Person("王五",13)); set.add(new Person("赵六",14)); set.add(new Person("李雷",11)); set.add(new Person("韩梅梅",8)); set.add(new Person("jack",10)); System.out.println(set); } }
3.集合的遍历 package com.alan.exercise; import java.util.ArrayList; import java.util.Collections; /** * 集合的遍历 * @author Alan * @version 1.0 * @date 2020-05-27 15:52 */ public class Exercise3 { public static void main(String[] args) { ArrayList<Integer> list=new ArrayList<>(); Collections.addAll(list,1,2,3,4,5,6,7,8,9); /** * list.forEach(Consumer<? super E> action) * api文档解释： 对 集合中的每个元素执行给定的操作，直到所有元素都被处理或动作引发异常。 * 将集合中的每一个元素都带入到接口Consumer的方法accept中 然后方法accept指向我们的引用 * 输出集合中的所有元素 * list.forEach(System.out::println); */ //输出集合中所有的偶数 list.forEach(ele->{ if(ele%2==0){ System.out.println(ele); } }); } }
4.删除集合中满足条件的元素 package com.alan.exercise; import com.alan.learn.data.Person; import java.util.ArrayList; /** * 删除集合中满足条件的元素 * @author Alan * @version 1.0 * @date 2020-05-27 16:05 */ public class Exercise4 { public static void main(String[] args) { ArrayList<Person> list=new ArrayList<>(); list.add(new Person("张三",10)); list.add(new Person("李四",12)); list.add(new Person("王五",13)); list.add(new Person("赵六",14)); list.add(new Person("李雷",11)); list.add(new Person("韩梅梅",8)); list.add(new Person("jack",10)); //删除集合中年龄大于12的元素 /** * 之前迭代器的做法 * ListIterator<Person> it = list.listIterator(); * while (it.hasNext()){ * Person ele=it.next(); * if(ele.age>12){ * it.remove(); * } * } */ /** * lambda实现 * 逻辑 * 将集合中的每一个元素都带入到接口Predicate的test方法中， * 如果返回值是true，则删除这个元素 */ list.removeIf(ele->ele.age>10); System.out.println(list); } }
5.开辟一条线程 做一个数字的输出 package com.alan.exercise; /** * 需求： * 开辟一条线程 做一个数字的输出 * @author Alan * @version 1.0 * @date 2020-05-27 16:17 */ public class Exercise5 { public static void main(String[] args) { /** * 通过Runnable 来实例化线程 */ Thread t=new Thread(()->{ for(int i=0;i<100;i++){ System.out.println(i); } }); t.start(); } }
六、系统内置的函数式接口 package com.alan.functional; import java.util.function.*; /** * 系统内置的一些函数式接口 * @author Alan * @version 1.0 * @date 2020-05-27 16:23 */ public class FunctionalInterface { public static void main(String[] args) { // Predicate<T> ： 参数是T 返回值boolean // 在后续如果一个接口需要指定类型的参数，返回boolean时可以指向 Predicate // IntPredicate int -> boolean // LongPredicate long -> boolean // DoublePredicate double -> boolean // Consumer<T> : 参数是T 无返回值(void) // IntConsumer int ->void // LongConsumer long ->void // DoubleConsumer double ->void // Function<T,R> : 参数类型T 返回值R // IntFunction<R> int -> R // LongFunction<R> long -> R // DoubleFunction<R> double -> R // IntToLongFunction int -> long // IntToDoubleFunction int -> double // LongToIntFunction long -> int // LongToDoubleFunction long -> double // DoubleToLongFunction double -> long // DoubleToIntFunction double -> int // Supplier<T> : 参数 无 返回值T // UnaryOperator<T> :参数T 返回值 T // BiFunction<T,U,R> : 参数 T、U 返回值 R // BinaryOperator<T> ：参数 T、T 返回值 T // BiPredicate<T,U> : 参数T、U 返回值 boolean // BiConsumer<T,U> : 参数T、U 无返回值 /** * 常用的 函数式接口 * Predicate<T>、Consumer<T>、Function<T,R>、Supplier<T> */ } }
七、Lambda闭包 package com.alan.closure; import java.util.function.Supplier; /** * @author Alan * @version 1.0 * @date 2020-05-27 16:59 */ public class ClosureDemo { public static void main(String[] args) { /** * lambda的闭包会提升包围变量的生命周期 * 所以局部变量 num在getNumber()方法内被 get()引用 不会在getNumber()方法执行后销毁 * 这种方法可以在外部获取到某一个方法的局部变量 */ int n=getNumber().get(); System.out.println(n); } private static Supplier<Integer> getNumber(){ int num=10; /** * Supplier supplier=()->num; * return supplier; */ return ()->{ return num; }; } } ************************************************************************* package com.alan.closure; import java.util.function.Consumer; /** * @author Alan * @version 1.0 * @date 2020-05-27 17:20 */ public class ClosureDemo2 { public static void main(String[] args) { int a=10; Consumer<Integer> c=ele->{ System.out.println(a+1); //System.out.println(ele); //System.out.println(a++); 会报错 //在lambda中引用局部变量 这个变量必须是一个常量 }; //a++; 这样也会导致内部报错 //如果在内部已经引用局部变量 参数传递后 打印的还是 10 c.accept(1); } }