java中4个常用的函数式接口

阅读数: 次 2020-05-31

1. Supplier< T >
1. Consumer< T >
1. Function<T,R>
1. Predicate< T >

函数式接口

只有一个抽象方法的接口叫做函数式接口。这时就可以提供一个lambda表达式。

下面将介绍4个常用的函数式接口

Supplier< T >
Consumer< T >
Function<T,R>
Predicate< T >

1. Supplier< T >

Supplier接口中只有一个方法，需要实现的方法是get，该方法返回一个类型为T的值。

T get();

下面的例子用该方法来返回数组中的最大值

import java.util.function.Supplier;

//supplier函数式接口用来返回数据
public class supplier {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6};
        int a = max(()->{
            int max = arr[0];
            for(int i = 1;i<arr.length;i++){
                if(max<arr[i]) max = arr[i];
            }
            return max;
        });
        System.out.println(a);
    }

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

2. Consumer< T >

需要实现的方法为accept，接收一个T类型的参数，没有返回值。可以用来处理数据

1	void accept(T var1);

下面的例子用来输出字符串

import java.util.function.Consumer;

public class consumer {
    public static void main(String[] args) {
        print("hello",System.out::println);
    }

    private static void print(String s,Consumer<String> c){
        c.accept(s);
    }
}

该接口还有另一个很实用的方法andThen，该方法提供了默认实现

default Consumer<T> andThen(Consumer<? super T> after) {
    Objects.requireNonNull(after);
    return (t) -> {
        this.accept(t);
        after.accept(t);
    };
}

调用这个方法会返回一个Consumer对象，它的accept实现为依次调用两个对象的accept方法

下面用这个方法来输出两个不同的字符串

public class consumer {
    public static void main(String[] args) {
        print("hello",System.out::println,s->{
            System.out.println(s+" world!");
        });
    }

    private static void print(String s, Consumer<String> c1,Consumer<String> c2){
        c1.andThen(c2).accept(s);
        //返回的对象的accept方法为先调用c1的accept,再调用c2的accept
    }
}
//hello
//hello world

3. Function<T,R>

需要实现的方法为apply，输入一个T类型的值，返回一个R类型的值，可以用来转换数据

1	R apply(T var1);

下面的例子为将字符串转换为数字

import java.util.function.Function;

//Function<T,R>的apply方法，输入T，返回R
public class function {
    public static void main(String[] args) {
        convert("123",Integer::parseInt);
    }

    //将字符串转换为数字
    private static void convert(String s, Function<String,Integer> f){
        Integer apply = f.apply(s);
        System.out.println(apply);
    }
}

它也有个andThen方法，不过和Consumer的不同

default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
    Objects.requireNonNull(after);
    return (t) -> {
        return after.apply(this.apply(t));
    };
}

下面用这个方法来实现字符串转换数字并加5，然后再转换为字符串并输出

import java.util.function.Function;

//Function<T,R>的apply方法，输入T，返回R
public class function {
    public static void main(String[] args) {
        convertShow("123",Integer::parseInt,s ->{return String.valueOf(s+5);});
    }
    
    //将字符串转换为数字并加5输出
    private static void convertShow(String s,Function<String,Integer> f1,Function<Integer,String>f2 ){
        String s1 = f1.andThen(f2).apply(s);
        System.out.println(s1);
    }
}
//128

4. Predicate< T >

需要实现的方法为test，该方法可以用来测试数据，返回一个boolean值

1	boolean test(T var1);

下面的例子用来检验字符串的长度

import java.util.function.Predicate;

/*predicate可以用来筛选信息*/
public class predicate {
    public static void main(String[] args) {
        String string = "hello";
        boolean b = test(string,s->s.length()>3);
        System.out.println(b);
    }

    public static boolean test(String str,Predicate<String> predicate){
        return predicate.test(str);
    }
}

Predicate还有几个非常有用的方法，分别代表逻辑运算中的与、非、或

default Predicate<T> and(Predicate<? super T> other) {
    Objects.requireNonNull(other);
    return (t) -> {
        return this.test(t) && other.test(t);
    };
}

default Predicate<T> negate() {
    return (t) -> {
        return !this.test(t);
    };
}

default Predicate<T> or(Predicate<? super T> other) {
    Objects.requireNonNull(other);
    return (t) -> {
        return this.test(t) || other.test(t);
    };
}

下面用与运算来判断字符串的长度是否属于某个范围

import java.util.function.Predicate;

/*predicate可以用来筛选信息*/
public class predicate {
    public static void main(String[] args) {
        String string = "hello";
        System.out.println(AND(string,s -> s.length()>4,s -> s.length()<14));
    }

    public static boolean AND(String s,Predicate<String> p1,Predicate<String> p2){
        return p1.and(p2).test(s);//逻辑与
    }
}

总结

以上接口只是函数式接口中常用的几个，还有其他如Runnable这样的接口也是很常见的。

这些接口大多数在处理流的时候出现，要熟练掌握lambda表达式，并对其进行运用。