四大函数型接口

Supplier 供给型接口

该接口只有一个抽象方法get

• get

  T get()
  

  获得结果。

  • 结果

    结果

用Supplier接口求最大值

import java.util.function.Supplier;
//求数组元素的最大值
public class Demo01Lambda {
    public static void main(String[] args) {
        int[] arr={5,6,8,1,2,45,65,78,23};
        int s = getstring(() ->{
            int max=arr[0];
            for (int i : arr) {
                if (i>max){
                    max=i;
                }
            }
            return max;
        } );
        System.out.println(s);
    }

    private static int getstring(Supplier<Integer> sup) {
        return sup.get();
    }
}

Consumer消费型接口

消费方法 与Supplier相反

public class ConsumerDemo02 {
    public static void main(String[] args) {
        int i=5;
        String m="mmM";
        method(i,(Integer n)->{
            int s=sum(i);
            System.out.println(s);
			//全部变为大写输出
            System.out.println(m.toUpperCase());
        },(Integer n)->{
            int s=chen(i);
            System.out.println(s);
            //变为小写输出
            System.out.println(m.toLowerCase());

        });
    }
    public static void method(int n, Consumer<Integer> con1, Consumer<Integer> con2){
        //谁在前谁先消费  andThen 同时运行
        con1.andThen(con2).accept(n);
    }
    //定义递归求和方法
    public static int sum(int i){
        if (i==1){
            return 1;
        }
        return i+sum(i-1);
    }
    //定义递归阶乘方法
    public static int chen(int i){
        if (i==1){
            return 1;
        }
        return i*chen(i-1);
    }
}

Predicate断定型 接口

断定型接口：有一个输入参数，返回值只能是 布尔值！

import java.util.function.Predicate;

public class PredicateDemo {
    public static void main(String[] args) {
        String s="jklsad";
        boolean method = method(s, (String s1) -> s1.length() > 5,(String s1) -> s1.length() < 6);
        System.out.println(method);
    }
    public static boolean method(String name, Predicate<String> pre, Predicate<String> pre1){
//        return pre.test(name);//test 进行判断
//        return pre.and(pre1).test(name); //and 默认方法  相当于逻辑与
//        return pre.or(pre1).test(name); //and 默认方法  相当于逻辑或
        return pre1.negate().test(name); //and 默认方法  取反 等效于 !pre.test(name)
    }
}

案例：

给出一个数组 String[] arr={"赵丽颖,女","李一桐,女","马儿扎哈,男","迪丽热巴,女"}; 将名字长度大于4 并且为女性的

元素添加到ArrayList集合中;

import java.util.ArrayList;
import java.util.function.Predicate;

public class preDicateDemo02 {
    public static void main(String[] args) {
        String[] arr={"赵丽颖,女","李一桐,女","马儿扎哈,男","迪丽热巴,女"};
        ArrayList<String> list = method(arr, (String s) -> {
            String name = s.split(",")[0];
//             String sex=s.split(".")[1];
            return name.length() == 4;
        }, (String s) -> {
            String sex = s.split(",")[1];
//                String sex=s.split(".")[1];
            return sex.equals("女");
        });
        for (String s : list) {
            System.out.println(s);

        }

    }
    public static ArrayList<String> method(String[] arr, Predicate<String> pre, Predicate<String> pre1){
        ArrayList<String> list=new ArrayList<>();
        for(String s:arr){
            boolean b = pre.and(pre1).test(s);
            if (b){
                list.add(s);
            }
        }
        return list;
    }
}

Function函数式接口

将一个字符串为整数 然后+10 在转换为字符串

可以用于类型转换

import java.util.function.Function;

public class FunctionDemo {
    public static void main(String[] args) {
        method("123",(String s)->Integer.parseInt(s)+10,(Integer i)->i.toString());
    }
    public static void method(String s, Function<String,Integer> fun,Function<Integer,String> fun1){
//        Integer apply = fun.apply(s);//把字符串类型的整数转换为String类型
//        String apply1 = fun1.apply(apply);
        String apply2 = fun.andThen(fun1).apply(s);
        System.out.println(apply2);
    }
}