1. 基于Function函数式使用Lambda表达式
Function<T,R>：接收一个参数并返回结果的函数；R apply(T t)：将此参数应用到函数中
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.function.Function;
/**
* 获取集合最大值
*/
public class LambdaFace {
private static List<Integer> list = Arrays.asList(1, 2, 13, 14, 18, 101);
//接收一个参数并返回结果的函数,即接收一个List集合，返回一个Integer数据
public static void getMax(Function<List<Integer>, Integer> function){
//将此list参数应用到Function函数式接口中，并输出其返回的结果
System.out.println(function.apply(list));
}
public static void main(String[] args) {
//调用方法,使用lambda表达式,n为传入的参数，利用Collections.max()方法获取集合最大值，并返回
getMax(n -> {
Integer max = Collections.max(n);
return max;
});
}
}
2. 基于BiFunction函数式使用Lambda表达式
BiFunction<T,U,R>：接受两个参数并返回结果的函数；R apply(T t, U u)：将参数应用于函数执行
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.BiFunction;
/**
* 获取两个List集合中的重复元素
*/
public class Lambda_BiFunction {
private static List<Integer> list1 = Arrays.asList(1,3,5,7,9);
private static List<Integer> list2 = Arrays.asList(1,2,4,6,9);
public static void getSame(BiFunction<List<Integer>,List<Integer>,List<Integer>>biFunction){
for(Integer num : biFunction.apply(list1,list2)){
System.out.println(num);
}
}
public static void main(String[] args) {
getSame((n,m) -> {
//存放重复数据
List<Integer> result = new ArrayList<Integer>();
for (Integer num : n) {//遍历n
if (m.contains(num)) {//如果存在这个数
result.add(num);//放进一个list里面，这个list就是交集
}
}
return result;
});
}
}
3. 基于Predicate函数式使用Lambda表达式
Predicate
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
/**
* 查找集合中包含字符“a”的元素
*/
public class Lambda_Predicate {
private static List<String> list = Arrays.asList("java","PHP","China","World");
public static void getContains(List<String> list, Predicate<String> predicate){
for(String str : list){
if(predicate.test(str)){
System.out.println(str);
}
}
}
public static void main(String[] args) {
getContains(list,n->n.contains("a"));
}
}
4. 基于BiPredicate函数式接口使用Lambda表达式
BiPredicate<T,U>：对给定的两个输入参数执行操作，返回一个boolean类型的结果（布尔值函数）；boolean test(T t, U u)：根据给定的两个输入参数进行判断
import java.util.Arrays;
import java.util.List;
import java.util.function.BiPredicate;
/**
* 判断集合中是否存在某个元素
*/
public class Lambda_BiPredicate {
private static List<String> list = Arrays.asList("java","world");
private static String name = "java";
public static void IfContains(List<String> list , String name , BiPredicate<List<String>,String> biFunction){
if(biFunction.test(list,name)){
System.out.println("集合中存在该元素！");
}else{
System.out.println("集合中不存在该元素！");
}
}
public static void main(String[] args) {
IfContains(list,name,(n,m) ->n.contains(m));
}
}
5. 基于Consumer函数式接口使用Lambda表达式
Consumer
import java.util.function.Consumer;
public class Lambda_Consumer {
public static void main(String[] args) {
/**
* void accept(T t)
* 对给定的参数执行操作
*/
Consumer<Integer> consumer1 = (t) -> {
System.out.println(t*3);
};
consumer1.accept(8);
/**
* default Consumer<T> andThen(Consumer<? super T> after)
* 返回一个组合函数，after将会在该函数执行之后应用
*/
Consumer<Integer> consumer2 = (t) -> {
System.out.println(t*3);
};
Consumer<Integer> consumerAfter = (s) -> {
System.out.println("之后执行："+s);
};
consumer2.andThen(consumerAfter).accept(5);
}
}
6. 基于BiConsumer函数式接口使用Lambda表达式
BiConsumer<T,U>：提供两个自定义类型的输入参数，不返回执行结果；void accept(T t, U u)：对给定的参数执行操作；default BiConsumer<T,U> andThen(BiConsumer<? super T,? super U> after)：返回一个组合函数，after将会在该函数执行之后应用
import java.util.function.BiConsumer;
public class Lambda_BiConsumer {
public static void main(String[] args) {
/**
* void accept(T t, U u)：对给定的参数执行操作；
*/
BiConsumer<String, String> biConsumer = (a, b) -> {
System.out.println(a.concat(b));
};
biConsumer.accept("Hello ", "World!");
/**
* default BiConsumer<T,U> andThen(BiConsumer<? super T,? super U> after)：返回一个组合函数，after将会在该函数执行之后应用
*/
BiConsumer<String, String> biConsumer1 = (a, b) -> {
System.out.println(a.concat(b));
};
biConsumer.andThen(biConsumer1).accept("Hello", " Java!");
}
}
7. 基于Supplier函数式接口使用Lambda表达式
Supplier
import java.util.function.Supplier;
public class Lambda_Supplier {
public static void main(String[] args) {
Supplier<String> supplier = () -> "Hello World!";
System.out.println(supplier.get());
}
}
