常见的函数式接口

package SimpleTest;

import java.util.function.Supplier;

/**
 * @className: Test13
 * @description: 函数式接口之Supplier（生产商接口就是只有返回没有入参）
 * @author: CCQ
 * @date: 2021/9/11
 **/

    //此接口是一个生产商接口，传入类型的参数就会返回什么类型的参数
    //此接口有一个T get()方法、获得结果
public class Test13 {
    public static void main(String[] args) {
        //lambda表达式实现Supplier接口
        String gets = gets(() -> "棋棋");
        System.out.println(gets);

        Integer geti = geti(() -> 100);
        System.out.println(geti);

        int[] arr ={10,56,42,63,21};
        int max1 = max(() -> {
            int max = arr[0];
            for (int i = 1; i < arr.length; i++) {
                if (arr[i] > max) {
                    max = arr[i];
                }
            }
            return max;
        });
        System.out.println(max1);
    }

    //定义一个方法，返回一个整数型数据
    static Integer geti(Supplier<Integer> s){
        return s.get();
    }

    //定义一个方法，返回一个字符串数据
    static String gets(Supplier<String> s){
        return s.get();
    }

    static int max(Supplier<Integer> s){
        return s.get();
    }
}

---

package SimpleTest;


import java.util.function.Consumer;

/**
 * @className: Test14
 * @description: Consumer函数式接口，消费型接口（消费型接口就是只有入参没有返回）
 * @author: CCQ
 * @date: 2021/9/11
 **/

//Consumer接口包含两个方法：
//void accept(T t);
//default Consumer<T>  andthen(Consumer<? super T> after)返回一个组合的Consumer，依次执行此操作，然后执行after操作
public class Test14 {
    public static void main(String[] args) {
        opp("棋棋", System.out::println);
        opp("陈慧棋",s-> System.out.println(new StringBuilder(s).reverse().toString()));

        System.out.println("----------------");

        //不同方式消费数据，一个利用引用方法直接打印参数，一个则反转字符串后打印
        opp2("陈慧棋",System.out::println,s-> System.out.println(new StringBuilder(s).reverse().toString()));
    }

    //定义一个方法，消费一个数据
    static void opp(String name, Consumer<String> c){
        c.accept(name);
    }

    //定义一个方法，用不同方式对同一数据消费两次
    static void opp2(String name,Consumer<String> c1,Consumer<String> c2){
//        //第一种方法用不同方式对同一数据消费两次
//        c1.accept(name);
//        c2.accept(name);
        //第二种方法用不同方式对同一数据消费两次
        //这个方法的意思是，先让c1对象执行accept,然后再让c2执行accept。注意：两个对象的accept方法是不同的。
        c1.andThen(c2).accept(name);
    }
}


class consumertest{
    public static void main(String[] args) {
        String[] str ={"棋棋,21","千叶影儿,20","夏倾月,20"};
        //使用lambda表达式实现Consumer接口
        printinfo(str,s ->{
            String s1 = s.split(",")[0];
            System.out.print("姓名："+s1);
        },s -> {
            int s1 = Integer.parseInt(s.split(",")[1]);
            System.out.println(",年龄:"+s1);
        });

        //优化后的lambda表达式，效果跟上面的lambda表达式一样
        printinfo(str,s -> System.out.print("姓名："+s.split(",")[0]),s -> System.out.println(",年龄:"+s.split(",")[1]));
    }

    static void printinfo(String[] strarr,Consumer<String> c1 ,Consumer<String>c2){
        for (String s : strarr) {
            c1.andThen(c2).accept(s);
        }
    }
}

---

package SimpleTest;

import java.security.cert.CertPath;
import java.security.cert.CertPathBuilderResult;
import java.util.function.Predicate;

/**
 * @className: Test15
 * @description: Predicate函数式接口（此接口通常用来判断参数是否满足指定的条件）
 * @author: CCQ
 * @date: 2021/9/11
 **/

/*Predicate接口有四个方法
*   boolean test(T t);对给定的参数进行判断（判断逻辑自己实现），返回一个布尔值
*   default Predicate<T> negate()。返回一个逻辑的否定，对应逻辑非
*   default Predicate<T> and(Predicate<? super T> other)返回一个组合判断，对应短路与
*   default Predicate<T> or(Predicate<? super T> other)返回一个组合判断，对应短路或 
*
* */
public class Test15 {
    public static void main(String[] args) {
        System.out.println(checkString("棋棋", s ->s.length() > 3));
        System.out.println(checkString("helloword", s ->s.length() > 8));

        System.out.println("------------------");

        System.out.println(checkString("棋棋赚大钱！", s -> s.length() > 3, s -> s.length() < 8));
        System.out.println(checkString("赚钱！", s -> s.length() > 3, s -> s.length() < 8));


    }

    //判断给定的字符串是否满足要求
    static boolean checkString(String s,Predicate<String> p1){

//        return p1.test(s);

        //negate（）方法对test（）方法返回的结果取非
        return p1.negate().test(s);
    }

    //同一个字符串给出两个不同的判断条件，并将两个判断结果作逻辑与运算，然后返回最终的结果,or方法跟其一样，不再演示
    static boolean checkString(String s,Predicate<String> p1,Predicate<String> p2){
        //第一种方式
//        boolean test1 = p1.test(s);
//        boolean test2 = p2.test(s);
//        boolean b = test1 && test2;
//        return b;

        //第二种方式
        return p1.and(p2).test(s);

    }
}

---

package SimpleTest;

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

/**
 * @className: Test16
 * @description: 使用Predicate接口完成一个数据筛选的例子
 * @author: CCQ
 * @date: 2021/9/12
 **/

//将满足姓名长度大于2，年龄大于33的字符串放入集合中
public class Test16 {
    public static void main(String[] args) {
        String[] arr ={"林青霞,30","刘岩,34","张曼玉,35","貂蝉,31","王祖贤,33"};
        checkString(arr,s -> s.split(",")[0].length()>2,s -> Integer.parseInt(s.split(",")[1])>33);

    }

    static void checkString(String[] s, Predicate<String> p1,Predicate<String> p2){
        //创建集合存储信息
        ArrayList<String> arrayList =new ArrayList<>();

        //遍历字符串数组并且判断每一个字符串是否满足要求
        for (String a : s) {
            if (p1.and(p2).test(a)) {
                arrayList.add(a);
            }
        }

        //遍历集合
        Iterator<String> iterator = arrayList.iterator();
        while (iterator.hasNext())
            System.out.println(iterator.next());
    }
}

---

package SimpleTest;

import java.util.function.Function;

/**
 * @className: Test17
 * @description: Function<T,R>接口，一个函数式接口,T表示函数输入的类型，R表示函数结果的类型
 * @author: CCQ
 * @date: 2021/9/12
 **/

/*Function接口有四个方法，两个默认一个静态一个抽象
 下面介绍其中两个。
  R  apply(T t);将t传入进行操作，返回一个R类型的结果，具体逻辑自己实现
  default <V> Function<T,V> addthen(Function after);先执行调用函数的操作再执行after函数操作
 */
public class Test17 {
    public static void main(String[] args) {
        applytest("100",s -> Integer.parseInt(s));
        applytest("200",Integer::parseInt);
        System.out.println("-----------------------");

        applytest(100,i->String.valueOf(i+100));
        System.out.println("-----------------------");

        applytest("3000",s -> Integer.parseInt(s)+500,i->String.valueOf(i));
    }

    //把字符串转为int类型并输出
    static void applytest(String s,Function<String,Integer> f1){
        System.out.println(f1.apply(s));
    }

    //把int类型数据加上一个整数后转换为String类型输出
    static void applytest(int i,Function<Integer,String> f1){
        System.out.println(f1.apply(i));
    }

    //把一个字符串转成int类型，加上一个整数后转成字符串类型输出
    static void applytest(String s,Function<String,Integer> f1,Function<Integer,String> f2){
        //第一种方式
//        System.out.println(f2.apply(f1.apply(s)));

        //第二种方式：利用andthen方法，把f1执行完的结果当作f2的参数
        System.out.println(f1.andThen(f2).apply(s));

        //第三种方式：利用compose方法，这个方法跟andthen方法是相反的，在这里是先执行f1再执行f2,，把f1执行完的结果当作f2的参数
        System.out.println(f2.compose(f1).apply(s));
    }
}

---

package SimpleTest;

import java.util.function.Function;

/**
 * @className: Test18
 * @description: Function接口例子
 * @author: CCQ
 * @date: 2021/9/12
 **/

/*有一个字符串String s ="林青霞,30";
    将其截取得到数字年龄部分，
    将年龄字符串转成int类型数据，并且加70
*/
public class Test18 {
    public static void main(String[] args) {

        Functiontest("林青霞,30",s -> Integer.parseInt(s.split(",")[1])+70);
    }

    /*有一个字符串String s ="林青霞,30";
    将其截取得到数字年龄部分，
    将年龄字符串转成int类型数据，并且加70
    */
    static void Functiontest(String s, Function<String,Integer> f1){
        System.out.println(f1.apply(s));
    }
}