四大内置核心函数式编程&&Lambda表达式

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:对给定的输入参数执行操作,返回一个boolean类型的结果(布尔值函数);boolean test(T t):根据给定的参数进行判断

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:提供一个T类型的输入参数,不返回执行结果;void accept(T t):对给定的参数执行操作;default Consumer andThen(Consumer<? super T> after):返回一个组合函数,after将会在该函数执行之后应用

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:不提供输入参数,但是返回结果的函数;T get() 获取结果值;

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());
    }
}

评论

暂无评论