1.1 Supplier接口

Supplier< T >:包含一个无参的方法

T get() ：获得结果。
该方法不需要参数，它会按照某种实现逻辑（由Lambda表达式实现）返回一个数据
Supplier< T >接口也被成为生产型接口，如果我们指定了接口的泛型是什么类型，那么接口中的get方法就会生产什么类型的数据供我们使用

package Java35.Demo1;

import java.util.function.Supplier;

public class demo1 {
    public static void main(String[] args) {
        String s = getString(() -> {
            return "lyy";
        });
        System.out.println(s);

        Integer i = getInteger(()->30);
        System.out.println(i);
    }
    //定义一个方法返回一个字符串数据
    private static Integer getInteger(Supplier<Integer> sup){
        return sup.get();
    }
    //定义一个方法返回一个字符串数据
    private static String getString(Supplier<String> sup){
        return sup.get();
    }
}

获取数组中最大值：

package Java35.Demo1;

import java.util.function.Supplier;

public class Demo2 {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {31,23,32,42,53,13};
        int maxvalue = getMax(() -> {
            int max = arr[0];
            for (int i = 1; i < arr.length; i++) {
                if (arr[i] > max) {
                    max = arr[i];
                }
            }
            return max;
        });
        System.out.println(maxvalue);
    }
    private static int getMax(Supplier<Integer> sup){
        return sup.get();
    }
}

1.2 Consumer接口

两个方法：

void accept(T t) ：对给定的参数执行此操作。
default Consumer< T > andThen(Consumer<? super T> after) ：返回一个组合的 Consumer ，按顺序执行该操作，然后执行 after操作。
该接口也称为消费型接口，数据类型由泛型指定

package Java35.Demo1;

import java.util.function.Consumer;

public class demo3 {
    public static void main(String[] args) {
//        operatorSting("lyy",(String s)->{
//            System.out.println(s);
//        });
        operatorSting("lyy",s-> System.out.println(s));
//        operatorSting("lyy",System.out::println);

        operatorSting("lyy",s->{
            System.out.println(new StringBuilder(s).reverse().toString());
        });

        operatorSting("lyy",s-> System.out.println(s),s->System.out.println(new StringBuilder(s).reverse().toString()));
    }
    //定义一个方法，用不同的方式消费同一个字符串数据两次
    private static void operatorSting(String name, Consumer<String> con1,Consumer<String> con2){
//        con1.accept(name);
//        con2.accept(name);
        con1.andThen(con2).accept(name);
    }

    //定义一个方法，消费一个字符串数据
    private static void operatorSting(String name, Consumer<String> con){
        con.accept(name);
    }
}

package Java35.Demo1;

import java.util.function.Consumer;

public class demo4 {
    public static void main(String[] args) {
        String[] strArray = {"lyy,24","lyq,24","sss,32"};

        printInfo(strArray,(String str)->{
            String name = str.split(",")[0];
            System.out.print("姓名："+name);
        },(String str)->{
            int age = Integer.parseInt(str.split(",")[1]);
            System.out.println(",年龄："+age);
        });

    }
    private static void printInfo(String[] strArray, Consumer<String> con1,Consumer<String> con2){
        for(String str:strArray){
            con1.andThen(con2).accept(str);
        }
    }
}

1.3 Predicate接口

常用的四个方法：

default Predicate and(Predicate<? super T> other) ：返回一个组合的谓词，表示该谓词与另一个谓词的短路逻辑AND。

default Predicate negate() ：返回表示此谓词的逻辑否定的谓词。

default Predicate or(Predicate<? super T> other) ：返回一个组合的谓词，表示该谓词与另一个谓词的短路逻辑或。

boolean test(T t) ：在给定的参数上评估这个谓词。

该接口通常用于判断参数是否满足指定条件

package Java35.Demo1;

import java.util.function.Predicate;

public class demo5 {
    public static void main(String[] args) {
//        boolean b1 = checkString("hello", (String s) -> {
//            return s.length() > 8;
//        });
//        System.out.println(b1);
        boolean b1 = checkString("hello",s -> s.length()>8);
        System.out.println(b1);

        boolean b2 = checkString("helloworld",s->s.length()>8);
        System.out.println(b2);
    }
    //判断给定的字符串是否满足要求
    private static boolean checkString(String s, Predicate<String> pre){
//        return pre.test(s);
//        return !pre.test(s);
        return pre.negate().test(s);
    }

}

package Java35.Demo1;

import java.util.function.Predicate;

public class demo7 {
    public static void main(String[] args) {
        boolean b1 = checkString("hello",s->s.length()>8);
        System.out.println(b1);

        boolean b2 = checkString("hello",s->s.length()>8,s -> s.length()<15);
        System.out.println(b2);

        boolean b3 = checkString("helloworld",s->s.length()>8,s -> s.length()<15);
        System.out.println(b3);
    }
    //判断给定的字符串是否满足要求
    private static boolean checkString(String s, Predicate<String> pre) {
        return pre.test(s);
    }
    //同一个字符串给出两个不同的判断条件，最后把这两个判断的结果做逻辑与运算的结果作为最终结果
    private static boolean checkString(String s, Predicate<String> pre1,Predicate<String> pre2){
//        boolean b1 = pre1.test(s);
//        boolean b2 = pre2.test(s);
//        boolean b = b1&&b2;
//        return b;
//        return pre1.and(pre2).test(s);
        return pre1.or(pre2).test(s);
    }
}

package Java35.Demo1;

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

public class demo8 {
    public static void main(String[] args) {
        String[] strArray = {"lyyda,24","de,41","dia,34"};

        ArrayList<String> array = detection(strArray, s -> s.split(",")[0].length() > 2,
                s -> Integer.parseInt(s.split(",")[1]) > 33);
        System.out.println(array);
    }
    private static ArrayList<String> detection(String[] strArray, Predicate<String> pre1, Predicate<String> pre2){
        //定义一个集合
        ArrayList<String> array = new ArrayList<String>();
        //遍历数组
        for (String str:strArray){
            if(pre1.and(pre2).test(str)){
                array.add(str);
            }
        }

        return array;

    }
}