文章目录
一、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("重写接口中的方法"));
}
}
@FunctionalInterface
interface MyFunctionalInterface{
public void method();
}
作为方法的返回值类型:可以直接返回一个Lambda表达式
package Lambda;
import java.util.Arrays;
import java.util.Comparator;
public class TestLambda1 {
public static Comparator<String> 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<String> 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<Integer> 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<String> 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<String> con1
Consumer<String> con2
String 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<String> con1 , Consumer<String> 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<String> con1 , Consumer<String> 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<String> con1 , Consumer<String> 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<String> 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 {
/*
定义一个方法,方法的参数,传递一个字符串,两个Predicate接口
一个用于判断字符串长度是否大于5
一个用于判断字符串中是否包含a
两个条件必须同时满足
*/
public static boolean checkString(String s , Predicate<String> pre1 , Predicate<String> 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 {
/*
定义一个方法,方法的参数,传递一个字符串,两个Predicate接口
一个用于判断字符串长度是否大于5
一个用于判断字符串中是否包含a
满足一个条件即可
*/
public static boolean checkString(String s , Predicate<String> pre1 , Predicate<String> 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 {
/*
定义一个方法,方法的参数,传递一个字符串,一个Predicate接口
如果字符串长度大于5,则返回false
如果字符串长度不大于5,则返回true
*/
public static boolean checkString(String s , Predicate<String> 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 {
/*
定义一个方法
方法的参数传递一个字符串类型的证书
方法的参数传递一个Function接口,泛型使用<String,Integer>
使用Function接口中的方法apply,把字符串类型的整数转换为Integer类型
*/
public static void change(String s , Function<String,Integer> 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 {
/*
需求:把String类型的“123”转换为Integer类型,把转换后的结果加10
把增加之后的Integer类型的数据转换为String类型
分析:转换了两次
第一次是Function<String,Integer> fun1:
Integer i = fun1.apply("123")+10
第二次是Function<Integer,String> fun2:
String s = fun2.apply(i)
我们可以使用andThen方法将两次转换组合在一起使用
String s = fun1.andThen(fun2).apply("123")
*/
public static void change(String s , Function<String,Integer> fun1 , Function<Integer,String> 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+"");
}
}