Lambda表达式格式
(参数，参数) 调用方法，传递参数，多个参数以“，”逗号隔开（形参）
-> 将小括号中参数传递到大括号（方法体）中，使用
{……} 实现代码的方法体
代码：
//这4种官方提供的函数式接口，默认的所有抽象方法都只有一个参数
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
public class Test2 {
public static void main(String[] args) {
//调用静态方法，内部相当于重写了接口的抽象方法，需要形参
demo1(()->"执行demo1");
/*-------------------------------------------------------------------------------------------*/
demo2_1(t-> {
Integer num = Integer.valueOf(t);
return num;
});
demo2_2(t->{
Integer num1 = Integer.valueOf(t);
return num1;
},
t->{
Integer num2 = t + 10;
String str = num2.toString();
return str;
});
/*-------------------------------------------------------------------------------------------*/
demo3_1(t->System.out.println("demo3_1正在执行……"+t));
demo3_2(t->System.out.println("demo3_2正在执行……"+t),
t->System.out.println("demo3_2正在执行……"+t));
/*-------------------------------------------------------------------------------------------*/
demo4_1(t->{
boolean result = t.startsWith("qq");
return result;
});
demo4_2(t->{
boolean result = t.startsWith("qq");
return result;
},t->{
int index = t.indexOf(":");
String str = t.substring(index+1);
boolean resulet = str.length() <= 11;
return resulet;
});
demo4_3(t->{
boolean result = t.startsWith("qq");
return result;
},t->{
int index = t.indexOf(":");
String str = t.substring(index+1);
boolean resulet = str.length() >=6;
return resulet;
});
demo4_4(t->{
boolean result = t.startsWith("qq");
return result;
});
}
//定义静态方法，将接口作为参数，多态使用，需要实参
//1.接口1： Supplier<T> 内部函数: T get() 返回一个结果即可.
public static void demo1( Supplier<String> sup){
String result = sup.get();
System.out.println("demo1结果为："+result);
}
/*-------------------------------------------------------------------------------------------*/
//2.接口2: Function<T,R> 2.1.内部函数: R apply(T t) 根据参数t,返回一个结果R.
public static void demo2_1(Function<String,Integer> fun){
Integer result = fun.apply("10");
System.out.println("demo2_1结果为："+result);
}
// 2.2.其他默认函数: Function andThen( Function f1 )
public static void demo2_2(Function<String,Integer> fun1,Function<Integer,String> fun2){
String result = fun1.andThen(fun2).apply("10");
System.out.println("demo2_2结果为:"+ result);
}
/*-------------------------------------------------------------------------------------------*/
//3.接口3: Consumer<T> 3.1.内部函数: accept(T t) 根据参数t,判断是否接受即可，无返回值
public static void demo3_1(Consumer<String> con){
con.accept("Hello World！！！");
}
// 3.2.其他默认函数: Consumer andThen(Consumer c1)，无返回值
public static void demo3_2(Consumer<String> con1,Consumer<String> con2){
con1.andThen(con2).accept("Hello World！！！");
}
/*-------------------------------------------------------------------------------------------*/
//4.接口4: Predicate<T> 4.1 内部函数: boolean test(T t) 根据参数,进行判断,返回布尔值结果.
public static void demo4_1(Predicate<String> pre){
boolean result = pre.test("qq:15144641");
System.out.println("判断开头是否为“qq”的结果为："+result);
}
// 4.2 其他默认函数: Predicate<T> and(Predicate p1)
public static void demo4_2(Predicate<String> pre1,Predicate<String> pre2){
boolean result = pre1.and(pre2).test("qq:15144641");
System.out.println("判断开头是否为“qq”且qq位数是否小于等于11位的结果为："+result);
}
// 4.3 Predicate<T> or(Predicate p1)
public static void demo4_3(Predicate<String> pre1,Predicate<String> pre2){
boolean result = pre1.or(pre2).test("qq:15144641");
System.out.println("判断开头是否为“qq”且qq位数是否大于等于6位的结果为："+result);
}
// 4.4 Predicate<T> negate( )
public static void demo4_4(Predicate<String> pre){
boolean result = pre.negate().test("qq:15144641");
System.out.println("判断开头是否为“qq”的非结果为："+result);
}
}
运行后效果图：
