JAVA基础之函数式接口

目录

函数式接口：有且仅有一个抽象方法的接口

1.Interface Comparator：

1.概述：

2.代码演示：

2.Interface Supplier:

1.概述：

2.常用方法：

3.代码演示：

3.Interface Consumer:

1.概述：

2.常用方法：

3.代码演示：

4.Interface Predicate:

1.概述：

2.常用方法：

3.代码演示：

5.Interface Function:,r>

1.概述：

2.常用方法：

3.代码实现：

总结：

---

函数式接口：有且仅有一个抽象方法的接口

1.Interface Comparator<T>：

1.概述：

比较功能，对一些对象的集合施加了一个整体排序 。

2.代码演示：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class ComparatorDemo {
    public static void main(String[] args) {
        ArrayList<String> array = new ArrayList<String>();
        array.add("cccc");
        array.add("aa");
        array.add("ddd");
        array.add("b");
        System.out.println("排序前"+array);

//        Collections.sort(array);
        Collections.sort(array,getComparator());
        System.out.println("排序后"+array);

//        getCompartor((array) -> System.out.println(array));

    }
    private static Comparator<String> getComparator(){
        //匿名内部类
//        Comparator<String> comp = new Comparator<String>() {
//            @Override
//            public int compare(String o1, String o2) {
//                return o1.length() - o2.length();
//            }
//        };
//        return comp;
//
//        return new Comparator<String>() {
//            @Override
//            public int compare(String o1, String o2) {
//                return o1.length() - o2.length();
//            }
//        };

        //如果方法的返回值是函数式接口，我们可以用Lambda表达式作为结果返回
        return ((o1, o2) -> o1.length() - o2.length());
    }
}

2.Interface Supplier<T>:

1.概述：

没有要求每次调用供应商时都会返回新的或不同的结果。

2.常用方法：

T get() :获得结果。

3.代码演示：

//代表结果供应商。
//没有要求每次调用供应商时都会返回新的或不同的结果。
import java.util.function.Supplier;

public class SupplierDemo {
    public static void main(String[] args) {
        String s = getString(() -> "王崇阳");
        System.out.println(s);

        Integer i = getInt(() -> 666);
        System.out.println(i);
    }
    private static String getString(Supplier<String> sup){
        return sup.get();
    }

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


}

3.Interface Consumer<T>:

1.概述：

表示接受单个输入参数并且不返回结果的操作。

2.常用方法：

        void accept(T t) :对给定的参数执行此操作。
        default Consumer<T> andThen(Consumer<? super T> after) :返回一个组合的 Consumer ，按顺序执行该操作，然后执行 after操作。

3.代码演示：

import java.util.function.Consumer;

//表示接受单个输入参数并且不返回结果的操作。
//void accept(T t) :对给定的参数执行此操作。
//default Consumer<T> andThen(Consumer<? super T> after):返回一个组合的 Consumer ，按顺序执行该操作，然后执行 after操作。
public class ConsumerDemo {
    public static void main(String[] args) {
        operatorStirng("小王",(s) -> System.out.println(s));

        //方法引用
//        operatorStirng("小王",System.out :: println);

        operatorStirng("小王",(s) -> System.out.println(new StringBuilder(s).reverse().toString()));

        System.out.println("--------");
        operatorStirng(小王",s -> System.out.println(s),s -> System.out.println(new StringBuilder(s).reverse().toString()));

    }
    private static void operatorStirng(String name, Consumer<String> con){
        con.accept(name);
    }
    private  static void operatorStirng(String name, Consumer<String> con1,Consumer<String> con2){
//        con1.accept(name);
//        con2.accept(name);
        con1.andThen(con2).accept(name);

    }

}

4.Interface Predicate<T>:

1.概述：

表示一个参数的谓词（布尔值函数）。

2.常用方法：

        default Predicate<T> and(Predicate<? super T> other) :返回一个组合的谓词，表示该谓词与另一个谓词的短路逻辑AND。
        default Predicate<T> negate() :返回表示此谓词的逻辑否定的谓词。
        default Predicate<T> or(Predicate<? super T> other) :返回一个组合的谓词，表示该谓词与另一个谓词的短路逻辑或。
        boolean test(T t) :在给定的参数上评估这个谓词。

3.代码演示：

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

public class PredicateTest {
    public static void main(String[] args) {
        String[] strArray = {"小王,26", "小张,20", "小李子,20", "小赵,18"};
        ArrayList<String> list = usePredicate(strArray, s -> s.split(",")[0].length() > 2
                , s -> Integer.parseInt(s.split(",")[1]) >= 20);
        System.out.println(list);

    }

    private static ArrayList<String> usePredicate(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;

    }

}

5.Interface Function<T,R>:

1.概述：

表示接受一个参数并产生结果的函数。

2.常用方法：

        default <V> Function<T,V> andThen(Function<? super R,? extends V> after) :返回一个组合函数，首先将该函数应用于其输入，然后将 after函数应用于结果。
        R apply(T t) :将此函数应用于给定的参数。

3.代码实现：

//Function<T,R>
//表示接受一个参数并产生结果的函数。
//通常用于对参数进行处理，转换，然后返回一个新的值
//default <V> Function<T,V> andThen(Function<? super R,? extends V> after)
//返回一个组合函数，首先将该函数应用于其输入，然后将 after函数应用于结果。

//R apply(T t)
//将此函数应用于给定的参数。
import java.util.function.Function;

public class FunctionDemo {
    public static void main(String[] args) {
//        useFunction1("666",(s) -> Integer.parseInt(s));
//        //方法引用
//        useFunction1("666",Integer::parseInt);

//        useFunction2(666,(s) ->String.valueOf(s+777));

        useFunction3("666",s ->  Integer.parseInt(s)
                ,i -> String.valueOf(i+777) );
    }


    //定义一个方法，把一个字符串转换为int类型，在控制台输出
    private static void useFunction1(String s, Function<String,Integer> fun){
//        Integer i = fun.apply(s);
        int i = fun.apply(s);
        System.out.println(i);
    }

    //定义一个方法，把一个int类型的数据加上一个整数之后，转为字符串在控制台输出
    private static void useFunction2(int i,Function<Integer,String> fun){
        String s = fun.apply(i);
        System.out.println(s);
    }

    //定义一个方法，把一个字符串转换为int类型，把int类型的数据加上一个整数之后，转换为字符串在控制台输出
    private static void useFunction3(String s,Function<String,Integer> fun1,Function<Integer,String>fun2){
//        int i = fun1.apply(s);
//        String result = fun2.apply(i);
//        System.out.println(result);
        String s1 = fun1.andThen(fun2).apply(s);
        System.out.println(s1);
    }
}

总结：

以上内容属于自学，可能不是很全面，但为了方便日后的观看和复习，在此发文，如发现有错误请联系博主，欢迎指正。