java8函数式接口——Precidate、Consumer、Function、Supplier

本文主要介绍java8的提供的几种函数式接口的使用

Precidate

先看下他的源码

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);

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

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

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

    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

可以看到Predicate中有5个方法,现在咱们来写5个demo看看每个方法的用法
1. test(T t)

    public class PredicateTest {
        public static void main(String[] args) {
            List<String> list = Arrays.asList("a", "bb", "ccc", "dddd", "eeeee", "ffffff");

    //        List<String> filter = filter(list, (String s) -> s.length() > 2);
            List<String> filter1 = filter(list, (s) -> s.length() > 2);
            for (String s : filter1) {
                System.out.println(s);
            }

            System.out.println("-----------------");
            List<String> filter2 = filter(list, (s) -> s.equals("ccc"));
            for (String s : filter2) {
                System.out.println(s);
            }
        }



        public static List<String> filter(List<String> list,Predicate<String> p){
            List<String> result = new ArrayList<>();
            for (String s : list) {
                if(p.test(s)){
                    result.add(s);
                }
            }
            return result;
        }
    }

test()方法接收一个参数,返回boolean值，我这里传入lambda表达式,使用lambda可以更灵活的完成一些功能

关于lambda表达式的使用请查看我的另外一篇博客:http://blog.csdn.net/KevinDai007/article/details/79299632

2. and(Predicate<? super T> other)

    public class PredicateTest02 {
        public static void main(String[] args) {
            List<String> list = Arrays.asList("a", "bb", "ccc", "dddd", "eeeee", "ffffff");

            Predicate<String> p1 = (s) -> s.length() > 2;
            Predicate<String> p2 = (s) -> s.equals("dddd");

            Predicate<String> and = p1.and(p2);
            List<String> filter = filter(list, and);
            for (String s : filter) {
                System.out.println(s);
            }
        }



        public static List<String> filter(List<String> list,Predicate<String> p){
            List<String> result = new ArrayList<>();
            for (String s : list) {
                if(p.test(s)){
                    result.add(s);
                }
            }
            return result;
        }
    }

and()方法接收Predicate类型且返回Predicate类型,可以进行链式判断,类似&&

3. and(Predicate<? super T> other)

    public class PredicateTest03 {
        public static void main(String[] args) {
            List<String> list = Arrays.asList("a", "bb", "ccc", "dddd", "eeeee", "ffffff");

            Predicate<String> p1 = (s) -> s.length() > 2;
            Predicate<String> p2 = (s) -> s.equals("a");

            Predicate<String> or = p1.or(p2);
            List<String> filter = filter(list, or);
            for (String s : filter) {
                System.out.println(s);
            }
        }



        public static List<String> filter(List<String> list,Predicate<String> p){
            List<String> result = new ArrayList<>();
            for (String s : list) {
                if(p.test(s)){
                    result.add(s);
                }
            }
            return result;
        }
    }

or()方法接收Predicate类型且返回Predicate类型,可以进行链式判断,类似||

4. Predicate negate()

    public class PredicateTest04 {
        public static void main(String[] args) {
            List<String> list = Arrays.asList("a", "bb", "ccc", "dddd", "eeeee", "ffffff");

            Predicate<String> p1 = (s) -> s.length() > 2;
            Predicate<String> negate = p1.negate();
            List<String> filter = filter(list, negate);
            for (String s : filter) {
                System.out.println(s);
            }
        }



        public static List<String> filter(List<String> list,Predicate<String> p){
            List<String> result = new ArrayList<>();
            for (String s : list) {
                if(p.test(s)){
                    result.add(s);
                }
            }
            return result;
        }
    }

negate()方法就是将test()方法的值取非

5. static Predicate isEqual(Object targetRef)

    public class PredicateTest04 {
        public static void main(String[] args) {
            List<String> list = Arrays.asList("a", "bb", "ccc", "dddd", "eeeee", "ffffff");

            Predicate<String> p1 = (s) -> s.length() > 2;
            Predicate<String> negate = p1.negate();
            List<String> filter = filter(list, negate);
            for (String s : filter) {
                System.out.println(s);
            }
        }



        public static List<String> filter(List<String> list,Predicate<String> p){
            List<String> result = new ArrayList<>();
            for (String s : list) {
                if(p.test(s)){
                    result.add(s);
                }
            }
            return result;
        }
    }

isEqual()方法接收一个object返回一个Predicate,用于查找与传入的对象相同的对象;如果传入的是null,则查找null

以上四种方法可灵活组合使用

从这些方法可以看出,Predicate接口主要作用是判断,例如在filter的方法中,Predicate通过接收判断的表达式或者方法,来判断对元素的操作.

---

Consumer

先看下他的源码

@FunctionalInterface
public interface Consumer<T> {

    void accept(T t);

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

1. void accept(T t)

    public class ConsumerTest01 {
        public static void main(String[] args) {
            List<String> list = Arrays.asList("a", "bb", "ccc", "dddd", "eeeee", "ffffff");

            Consumer<String> print = (s) -> System.out.println(s);
            Consumer<String> printLength = (s) -> System.out.println(s.length());

            filter(list,print);
            filter(list,printLength);


        }

        public static void filter(List<String> list,Consumer<String> consumer){
            for (String s : list) {
                consumer.accept(s);
            }
        }
    }

accept()方法接收一个Object但没有返回值
2. default Consumer andThen(Consumer<? super T> after)

    public class ConsumerTest02 {
        public static void main(String[] args) {
            List<String> list = Arrays.asList("a", "bb", "ccc", "dddd", "eeeee", "ffffff");

            Consumer<String> print = (s) -> System.out.println(s);
            Consumer<String> printLength = (s) -> System.out.println(s.length());

            filter(list,print.andThen(printLength));

        }

        public static void filter(List<String> list,Consumer<String> consumer){
            for (String s : list) {
                consumer.accept(s);
            }
        }
    }

andThen()方法接收Consumer且返回Consumer,可进行链式操作,与Precidate中and()方法十分类似

由上面两个方法可以看到Consumer是要对某元素进行操作的函数接口

---

Function

先看看它的源码

@FunctionalInterface
public interface Function<T, R> {

    R apply(T t);

    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

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

    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

直接看demo
1. R apply(T t)

    public class FunctionTest01 {

        public static void main(String[] args) {
            List<String> list = Arrays.asList("1", "22", "333", "4444", "55555", "666666");

            Function<String,Integer> valueOf = (s) -> Integer.valueOf(s);
            Function<String,Integer> length = (s) -> s.length();

            List<Integer> filter = filter(list, valueOf);
            for (Integer integer : filter) {
                System.out.println(integer);
            }

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

            List<Integer> filter1 = filter(list, length);
            for (Integer integer : filter1) {
                System.out.println(integer);
            }
        }

        public static List<Integer> filter(List<String> list,Function<String,Integer> consumer){
            List<Integer> result = new ArrayList<>();
            for (String s : list) {
                result.add(consumer.apply(s));
            }

            return result;
        }
    }

Function <T,R>类有两个泛型参数,T代表入参类型,R代表返回类型

2. default <V> Function<V, R> compose(Function<? super V, ? extends T> before)

    public class FunctionTest02 {
        public static void main(String[] args) {
            List<String> list = Arrays.asList("1", "22", "333", "4444", "55555", "666666");

            Function<String,String> valueOf = (s) -> s + "aaa";
            Function<String,String> length = (s) -> s += s;

            List<String> filter = filter(list, valueOf.compose(length));
            for (String integer : filter) {
                System.out.println(integer);
            }
        }

        public static List<String> filter(List<String> list,Function<String,String> consumer){
            List<String> result = new ArrayList<>();
            for (String s : list) {
                result.add(consumer.apply(s));
            }

            return result;
        }
    }

compose()方法接收Function且返回Function,用于合并两个操作,且先执行参数中函数再执行调用的函数.用数学的方式可表示为valueOf(length(x))
3. default <V> Function<T, V> andThen(Function<? super R, ? extends V> after)

    public class FunctionTest03 {
        public static void main(String[] args) {
            List<String> list = Arrays.asList("1", "22", "333", "4444", "55555", "666666");

            Function<String,String> valueOf = (s) -> s + "aaa";
            Function<String,String> length = (s) -> s += s;

            List<String> filter = filter(list, valueOf.andThen(length));
            for (String integer : filter) {
                System.out.println(integer);
            }
        }

        public static List<String> filter(List<String> list,Function<String,String> consumer){
            List<String> result = new ArrayList<>();
            for (String s : list) {
                result.add(consumer.apply(s));
            }

            return result;
        }
    }

andThen()方法也是接收一个Function且返回Function,用于合并两个操作,但与compose不同的是,andThen()方法先执行调用的函数,再执行参数中的函数.用数学的方式可表示为length(valueOf(x))
4. static <T> Function<T, T> identity()

    public class FunctionTest04 {
        public static void main(String[] args) {
            List<String> list = Arrays.asList("1", "22", "333", "4444", "55555", "666666");

            Function<String, String> identity = Function.identity();
            List<String> filter1 = filter(list, identity);
            for (String integer : filter1) {
                System.out.println(integer);
            }
        }

        public static List<String> filter(List<String> list,Function<String,String> consumer){
            List<String> result = new ArrayList<>();
            for (String s : list) {
                result.add(consumer.apply(s));
            }
            return result;
        }
    }

identity()方法简单的返回入参

由上面几个方法可以看出,Function可以理解为映射(或者说可以用来做映射),即将T映射为R

---

Supplier

先来看看它的源码

@FunctionalInterface
public interface Supplier<T> {
    T get();
}

1. T get()

    public class Supplier01 {
        public static void main(String[] args) {
            Supplier<String> supplier1 = () -> "test01";
            Supplier<String> supplier2 = () -> "test02";

            String s1 = filter(supplier1);
            System.out.println(s1);

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

            String s2 = filter(supplier2);
            System.out.println(s2);
        }

        public static String filter(Supplier<String> supplier){
            return supplier.get();
        }
    }

get()方法没有入参,有返回值,可理解为产生一个对象.与其操作相似度的有Callable的call()方法

至此java8中几个常用的函数式接口的用法已全部了解完了,相信大家也看到了使用函数式接口的灵活性,以后在实际项目中多多使用吧

markdown语法不一致真的好烦,排版都调了半天