JDK8新特性之常用函数式接口

常用的函数式接口主要在java.util.function包下，函数式接口是Lambda表达式使用的前提，而Lambda表达式不关心接口名，抽象方法名，只关心抽象方法的参数列表和返回值类型，因此，为了让Lambda表达式使用更方便，jdk提供了大量函数式接口。(常用的接口：Supplier接口、Consumer接口、Function接口、Predicate接口等)

目录

常用4种函数式接口    

1）、Supplier接口

2）、Consumer接口

3）、Function接口

4）、Predicate 接口

---

常用4种函数式接口    

      本篇文章只介绍常用的Supplier接口、Consumer接口、Function接口、Predicate接口四种接口。

1）、Supplier接口

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

对应的Lambda表达式需要“对外提供"一个符合泛型类型的对象数据。供给型接口，通过Supplier接口中的get方法可以得到一个值，无参有返回的接口。

//获取数组中最大的值
public class GetMaxValue {
    public static void main(String[] args) {
        getMax(()->{
            int[] arr = {13,89,45,32,80};
            Arrays.sort(arr);  //排序 
            return  arr[arr.length - 1];  //数组默认升序排列 最后一个就是最大值
        });
    }
    private static void getMax(Supplier<Integer> sup) {
        Integer max = sup.get();
        System.out.println("max : "+max);
    }
}

2）、Consumer接口

@FunctionalInterface
public interface Consumer<T>{
    public abstract void accept<T t);
}

Consumer<T>接口不是生产一个数据，而是消费一个数据，和Supplier接口相反，其数据类型由泛型参数决定。

//将传入的值转化为大写或小写
public class GetMaxValue {
    public static void main(String[] args) {
       //Consumer将值转化为大写
        changeMax((String s)->{
            System.out.println(s.toUpperCase());//将传入的值转为大写
            System.out.println(s.toLowerCase());//将传入的值转为小写
        });
        
        //Consumer接口中的andThen方法  先打印大写 然后打印小写
        andThenWith(s -> System.out.print(s.toLowerCase() +"  ----  "),s -> System.out.print(s.toUpperCase()));
    }
    private static void changeMax(Consumer<String> con){
        String t = "abcDeH";//传入的值
        con.accept(t);
    }
    
    //Consumer接口中的默认方法andThen
    private  static  void andThenWith(Consumer<String> c1,Consumer<String> c2){
        c2.andThen(c1).accept("HelloWorld");
    }
}

3）、Function接口

@FunctionalInterface
public interface Function<T,R>{
    public abstract R apply(T t);
}

用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件，后置称为后置条件，有参数有返回值。Function转换型接口，对apply方法传入的T类型数据进行处理，返回R类结果，有参有返回的接口。

//将String类型转换为Integer类型
public class GetMaxValue {
    public static void main(String[] args) {
        //Function接口将值转化为数字
        changeSToI(s -> {
            return Integer.parseInt(s);
        });
        
        //Function接口将字符串转换为数字并乘以10
        funAndThen(s -> {
            //将传入的值转换为int类型
           return  Integer.parseInt(s); 
        },s->{
            //将上一步的结果乘以10返回
            return s * 10;
        });
    }
    //Function接口将一个字符串转化为数字
    private static void changeSToI(Function<String,Integer> fun){
       Integer fun =  fun.apply("58");
       System.out.println(" in "+(fu + 10));
    }
    
    //Function接口中的andThen方法
    private  static  void funAndThen(Function<String,Integer> fun1,Function<Integer,Integer> fun2){
        Integer value = fun1.andThen(fun2).apply("56");
        System.out.println("value : "+value);
    }
}

4）、Predicate 接口

@FunctionalInterface
public interface Predicate<T>{
    public abstract boolean test(T t);
}
//该接口用于做判断，返回boolean类型的值

有时我们需要对某种数据类型进行判断，从而得到一个boolean值结果，使用Predicate接口即可，该接口用于做判断，返回boolean类型的值。

public class GetMaxValue {
    public static void main(String[] args) {       
        //Predicate接口用于判断 返回Boolean值
        tesetPre(s -> s.length() >= 3,"太极张三丰");

        //Predicate接口判断是否包含 and 其他两个值
        testContain( s->
            s.contains("H")
        ,   s->
            s.contains("W")
        ,"HelloWorld");

        //Predicate接口包含H或W
        testContain2(s->s.contains("H"),s->s.contains("W"),"HelloBlus");
        //不包含H
        testContain3(s->s.contains("H"),"youyouku");
    }
    //Predicate接口判断返回一个Boolean值
    private static  void tesetPre(Predicate<String> pre,String name){
        boolean bool = pre.test(name);
        System.out.println("如果名字超过三个则名字太长 ： "+bool);
    }

    //使用Predicate接口and方法判断一个字符串既包含H也包含W
    private  static  void testContain(Predicate<String> pre1,Predicate<String> pre2,String str){
        boolean test = pre1.and(pre2).test(str);
        System.out.println("该值是否既包含其他两值 ： "+test);
    }

    //使用Predicate接口or方法判断一个字符串包含H或包含W
    private static  void testContain2(Predicate<String> pre1,Predicate<String> pre2,String str){
        boolean test = pre1.or(pre2).test(str);
        System.out.println("包含H或W :" +test);
    }

    //使用Predicate中negate默认方法判断字符串不包含
    private  static  void testContain3(Predicate<String> pre1,String str){
        boolean test = pre1.negate().test(str);
        System.out.println("不包含 ： "+test);
    }
}

 路漫漫其修远兮，吾将上下而求索，希望该篇文章对大家有所帮助.....