Java基础知识——lamda表达式和函数式接口

文章目录

一、Lambda表达式二、函数式接口

2.1 函数式接口作用2.2 常用函数式接口——Supplier接口2.3 常用函数式接口——Consumer接口2.4 常用函数式接口——Predicate接口2.5 常用函数式接口——Function接口

---

一、Lambda表达式

函数式接口：任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。对于函数式接口，可以通过Lambda表达式节创建该接口的对象。

使用Lambda表达式：避免匿名内部类定义过多、可以让代码看起来更简洁、去掉了一对没有意义的代码只留下了核心的逻辑

原来：

package Lambda;public class TestLambda1 { public static void main(String[] args) { ILike like = new Like(); like.lambda(); }}//1、定义一个函数式接口interface ILike{ void lambda();}//2、实现类class Like implements ILike { public void lambda(){ System.out.println("I like lambda"); }}

通过匿名内部类简化：

package Lambda;public class TestLambda1 { public static void main(String[] args) { ILike like = new ILike(){ public void lambda(){ System.out.println("I like lambda"); } }; like.lambda(); }}//1、定义一个函数式接口interface ILike{ void lambda();}

通过Lambda表达式进一步简化：

package Lambda;public class TestLambda1 { public static void main(String[] args) { ILike like = ()->{ System.out.println("I like lambda"); }; like.lambda(); }}//1、定义一个函数式接口interface ILike{ void lambda();}

总结：对于只包含一个抽象方法的接口，就可以用Lambda表达式简化代码创建对象

进一步省略：

参数类型可以省略方法体只有一句代码的时候，可以省略大括号return和分号方法只有一个参数的时候可以省略小括号

ILike like = ()->System.out.println("I like lambda");

二、函数式接口

函数式接口指的是有且只有一个抽象方法的接口，但是也可以有其他的方法(默认、静态、私有)。

可以添加@FunctionalInterface注解，作用是检测一个接口是否是函数式接口

2.1 函数式接口作用

函数式接口一般可以作为方法的参数和返回值类型

作为方法的参数：

package Lambda;public class TestLambda1 { public static void show(MyFunctionalInterface myInter){ myInter.method(); } public static void main(String[] args) { show(()->System.out.println("重写接口中的方法")); }}@FunctionalInterfaceinterface MyFunctionalInterface{ public void method();}

作为方法的返回值类型：可以直接返回一个Lambda表达式

package Lambda;import java.util.Arrays;import java.util.Comparator;public class TestLambda1 { public static Comparator getComparator(){ return (o1,o2) -> o2.length()-o1.length(); } public static void main(String[] args) { String[] arr = {"aaa","b","cccccc","dddddddddd"}; System.out.println(Arrays.toString(arr)); Arrays.sort(arr,getComparator());//按照长度排序 System.out.println(Arrays.toString(arr)); }}

2.2 常用函数式接口——Supplier接口

java.util.function.Supplier< T >接口仅包含一个无参的方法：T get()。用来获取一个泛型参数指定类型的对象数据。由于这是一个函数式接口，这也就意味着对应的Lambda表达式需要向外提供一个符合泛型类型的对象数据。这个接口被称为生产型接口，即指定接口的泛型是什么类型，那么接口中的get方法就会产生什么类型的数据。

样例：

package Lambda;import java.util.function.Supplier;public class DemoSupplier { public static String getString(Supplier sup){ return sup.get(); } public static void main(String[] args) { String s = getString(()->"胡歌"); System.out.println(s); }}

练习：使用Supplier接口作为方法参数类型，通过Lambda表达式求出int数组中的最大值。

package Lambda;import java.util.function.Supplier;public class DemoSupplier { public static int getMax(Supplier sup){ return sup.get(); } public static void main(String[] args) { int[] arr = {100,0,0-50,88,99,33,-30}; int maxValue = getMax(()->{ int max = arr[0]; for(int i :arr){ if(i > max) max = i; } return max; }); System.out.println(maxValue); }}

2.3 常用函数式接口——Consumer接口

java.util.function.consumer< T >接口正好与Supplier接口相反，它消费一个数据，其数据类型由泛型决定。它包含抽象方法void accept(T t)，意为消费一个指定泛型的数据。

accept()方法的使用：

package Lambda;import java.util.function.Consumer;public class DemoConsumer { public static void method(String name , Consumer con){ con.accept(name); } public static void main(String[] args) { method("赵丽颖",(String name)->{ //消费方式：把字符串进行翻转输出 String reName = new StringBuffer(name).reverse().toString(); System.out.println(reName); }); }}

Consumer接口中的默认方法andThen：如果一个方法的参数和返回值都是Consumer类型，那么就可以实现消费数据的时候，首先做一个操作，然后再做一个操作，实现组合。这个方法就是由andThen实现的。要向实现组合，需要两个或者多个Lambda表达式即可，而andThen语义正是一步接一步操作。例如：

Consumer con1Consumer con2String s = "hello";con1.accept(s);con2.accept(s);可以用andThen来进行连接，再进行消费，谁写前面谁先消费，所以下面是con1先进行消费：con1.andThen(con2).accept(s);

第一种方式：

第一种方式：package Lambda;import java.util.Locale;import java.util.function.Consumer;public class DemoConsumer { public static void method(String s , Consumer con1 , Consumer con2){ con1.accept(s); con2.accept(s); } public static void main(String[] args) { method("hello", (t)->{ System.out.println(t.toUpperCase()); }, (t)->{ System.out.println(t.toLowerCase()); }); }}

第二种方式：用andThen进行连接

package Lambda;import java.util.Locale;import java.util.function.Consumer;public class DemoConsumer { public static void method(String s , Consumer con1 , Consumer con2){ con1.andThen(con2).accept(s); } public static void main(String[] args) { method("hello", (t)->{ System.out.println(t.toUpperCase()); }, (t)->{ System.out.println(t.toLowerCase()); }); }}

练习：下面的字符串数组中存有多条信息，请按照格式“姓名：XX，性别：XX”的格式将信息打印出来，要求将打印姓名的动作作为第一个Consumer接口的Lambda实例，将打印性别的动作作为第二个Consumer接口的Lambda实例，将两个Consumer接口按照顺序拼接到一起：

package Lambda;import java.util.Locale;import java.util.function.Consumer;public class DemoConsumer { public static void printInfo(String[] arr , Consumer con1 , Consumer con2){ for(String message : arr){ con1.andThen(con2).accept(message); } } public static void main(String[] args) { String[] arr = {"迪丽热巴,女","古力娜扎,女","马尔扎哈,男"}; printInfo(arr,(message)->{ String name = message.split(",")[0]; System.out.print("姓名："+name+","); },(message)->{ String gender = message.split(",")[1]; System.out.println("性别："+gender); }); }}

2.4 常用函数式接口——Predicate接口

有时候我们需要对某种数据的类型进行判断，从而得到一个boolean值结果。这是可以用java.util.function.Predicate< T >接口。

抽象方法test()：

package Lambda;import java.util.function.Predicate;public class DemoPredicate { public static boolean checkString(String s , Predicate pre){ return pre.test(s); } public static void main(String[] args) { String s = "abcdef"; //对参数传递的字符串进行判断，判断字符串长度是否大于5 boolean b = checkString(s,str->str.length()>5); System.out.println(b); }}

既然是条件判断，那么就会存在与或非三种逻辑。

与逻辑：默认方法and()

package Lambda;import java.util.function.Predicate;public class DemoPredicate { public static boolean checkString(String s , Predicate pre1 , Predicate pre2){ return pre1.and(pre2).test(s); } public static void main(String[] args) { String s = "bcdeff"; boolean b = checkString(s,(String str)->{ return str.length()>5; },(String str)->{ return str.contains("a"); }); System.out.println(b); }}

或逻辑：默认方法or()

package Lambda;import java.util.function.Predicate;public class DemoPredicate { public static boolean checkString(String s , Predicate pre1 , Predicate pre2){ return pre1.or(pre2).test(s); } public static void main(String[] args) { String s = "bcdeff"; boolean b = checkString(s,(String str)->{ return str.length()>5; },(String str)->{ return str.contains("a"); }); System.out.println(b); }}

非逻辑：negate()

package Lambda;import java.util.function.Predicate;public class DemoPredicate { public static boolean checkString(String s , Predicate pre){ return pre.negate().test(s); } public static void main(String[] args) { String s = "bcdeff"; boolean b = checkString(s,str->str.length()>5); System.out.println(b); }}

2.5 常用函数式接口——Function接口

java.util.function.Function< T , R >接口用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件，后者称为后置条件。将T的数据类型转换为R的数据类型

抽象方法R apply(T t)，根据类型T的参数获取类型R的结果

package Lambda;import java.util.function.Function;public class DemoFunction { public static void change(String s , Function fun){ int in = fun.apply(s); System.out.println(in); } public static void main(String[] args) { String s = "1234"; change(s,str->Integer.parseInt(s)); }}

默认方法andThen：进行组合操作

package Lambda;import java.util.function.Function;public class DemoFunction { public static void change(String s , Function fun1 , Function fun2){ String ss = fun1.andThen(fun2).apply(s); System.out.println(ss); } public static void main(String[] args) { String s = "123"; change(s,str->Integer.parseInt(str)+10,i->i+""); }}