常用的函数式接口@FunctionalInterface

什么是函数式接口？
有且只有一个抽象方法,接口上被@FunctionalInterface注解修饰,配合1.8Lambda使用

Consumer< T >

java.util.function.Consumer 接口刚好和Supplier接口相反，它不是用来生产一个数据，而是消费一个数据
数据的类型由泛型来指定,内部有2个方法:

accpet()
意思就是消费一个指定泛型的数据
抽象方法,子类需要重写它的抽象方法,这个方法有一个参数,无返回值
andThen()
消费数据的时候，首先做一个消费的操作，在做一个消费的操作,就像工厂的流水线一样。
默认方法,参数为一个consumer接口,无返回值
示例:
创建2个方法,传入consumer接口作为参数,调用它内部的方法

  public  void consumer(String str,Consumer<String> consumer) {
        //有一个参数无返回值
        consumer.accept(str);
    }

    public  void consumer2(String str,Consumer<String> con1,Consumer<String> con2) {
      con1.andThen(con2).accept(str);
    }

       NewClass8 class8 = new NewClass8();
        class8.consumer("accpet方法有一个参数无返回值",System.out::println);

        class8.consumer2("andThrm方法,消费数据的时候,ccccc首先做一个消费的操作,在做一个消费的操作,实现组合",
                (s1)->{
                    //这里加时间测试一下,是不是按顺序执行的
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //把字母转大写
                    String s = s1.toUpperCase();
                    System.out.println(s);
                },
                (s2)->{
                //把c替换成空格
                    String replaceAll = s2.replaceAll("c", "");
                    System.out.println(replaceAll);
                });

执行结果:

accpet方法有一个参数无返回值
ANDTHRM方法,消费数据的时候,CCCCC首先做一个消费的操作,在做一个消费的操作,实现组合
andThrm方法,消费数据的时候,首先做一个消费的操作,在做一个消费的操作,实现组合

Predicate< T >

java.util.function.Predicate 接口用来处理数据,并返回一个boolean类型的结果,内部方法有4个:

test()
抽象方法,参数为泛型,处理传入的数据,并返回一个boolean类型的结果
and()
默认方法,and方法就是做与运算
or()
默认方法,or方法就是做或运算
negate()
默认方法,negate方法就是做非运算。
示例:

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

    public  boolean predicate2(String str1, Predicate<String> predicate1,Predicate<String> predicate2) {
        return predicate1.and(predicate2).test(str1);
    }

    public  boolean predicate3(String str1, Predicate<String> predicate1,Predicate<String> predicate2) {
        return predicate1.or(predicate2).test(str1);
    }
    public  boolean predicate4(String str1, Predicate<String> predicate1,Predicate<String> predicate2) {
        return predicate1.negate().test(str1);
    }

    boolean test = class8.predicate("aaa", s -> {
            return s.length() == 3;
        });
        boolean negate = class8.predicate4("aaa", s -> {
            return s.length() == 3;
        });
        boolean and = class8.predicate2("aaa", s -> {
            return s.length() == 3;
        }, s -> {
            return s.contains("a");
        });
        boolean or = class8.predicate3("aaa", s -> {
            return s.length() == 3;
        }, s -> {
            return s.contains("a");
        });
        log.info("test结果:{},negate结果:{},and结果:{},or结果:{}",test,negate,and,or);

执行结果为:

test结果:true,negate结果:false,and结果:true,or结果:true

Supplier< T >

java.util.function.Supplier接口用来生成数据,内部只有一个方法:

get()
默认方法,无参数,有返回值,类型为泛型
示例:

 public  int supplier( Supplier<Integer> supplier) {
        //无参数有返回值,类型为泛型
        return supplier.get();
    }

  System.out.println(class8.supplier(() -> Integer.MAX_VALUE));

执行结果:

int类型的最大数
2147483647

Function<T, R>

java.util.function.Function接口用来处理一个数据,并重新返回一个数据,内部有3个方法:

apply()
抽象方法,接收一个泛型参数,和consumer的accpet()方法类似,但是这个会返回一个泛型参数,
andThen()
默认方法,它的入参还是Function接口的实例。做完上一个Function的操作以后，再做当前Function的操作
compose()
默认方法,和andThen方法相反的，先做当前Function的操作，然后再做上一个Function的操作
示例:

    public  String function(String str, Function<String,String> function) {
        return function.apply(str);
    }

    public  int function2(int v, Function<Integer,Integer> function1,Function<Integer,Integer> function2) {
        return function1.andThen(function2).apply(v);
    }
    public  int function3(int v, Function<Integer,Integer> function1,Function<Integer,Integer> function2) {
        return function1.compose(function2).apply(v);
    }

  String apply = class8.function("aabbccdd", String::toUpperCase);
        int andThren = class8.function2(10, i -> {
            return i * 2;
        }, i -> {
            return i + 2;
        });
        int compose = class8.function3(10, i -> {
            return i * 2;
        }, i -> {
            return i + 2;
        });
        log.info("apply结果:{},andThren结果:{},compose结果为:{}",apply,andThren,compose);

结果为:

apply结果:AABBCCDD,andThren结果:22,compose结果为:24

Comparator< T >

java.util.function.comparator接口接口代表一个比较器，比较器具有可比性

compare()
抽象方法,比较用来排序的两个相同类型的参数。根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数
示例:

       List<String> list = new ArrayList<String>() {
            {
                add(0, "10000");
                add(1, "1000");
                add(2, "7777");
                add(3, "9999");
                add(4, "0003");
                add(5, "666");
                add(6, "888");
                add(7, "0001");
            }
        };
        Collections.sort(list, (s1, s2) -> {
            //先根据长度排序
            int ct = s1.length() - s2.length();
            if (ct != 0) {
                ct = ct > 0 ? 2 : -1;
            }else {
                //再根据大小排序
               ct = Integer.parseInt(s1)-Integer.parseInt(s2);
                if (ct != 0) {
                    ct = ct > 0 ? 1 : -2;
                }
            }
            return ct;

        });
        list.forEach(System.out::println);

结果:

666
888
0001
0003
1000
7777
9999
10000