JDK8辅助学习(二)：Lambda表达式----常用的内置函数式接口

前言

        当你在学习本文时，如果您还不了解 Lambda表达式的使用，请先跳转链接：JDK8新特性(一)：Lambda表达式 ，来了解一下 Lambda表达式的基本使用。

        从 Lambda表达式 一文，我们了解到使用Lambda表达式的前提条件，如下图所示。

       由于使用条件的限制，明显不利于 Lambda表达式 的推广使用。为了能够让我们更方便的使用 Lambda 表达式，JDK为我们提供了大量的内置函数式接口。

内置函数式接口

       它们都位于 java.util.function 包中，如下图所示。

          

       常用的四大核心内置函数式接口，如上图所示。分别是 ①Supplier   ②Consumer  ③Function  ④Predicate ，接下来我们来分别介绍这四大核心内置函数式接口

1.Supplier

@FunctionalInterface
public interface Supplier {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

  我们重点来看一下 get() 方法（Supplier也就这一个抽象方法）。

  特点：①无参数     ②有返回值     --------->这种无参数 有返回值的接口，称之为"供给性接口"

  Demo：

       使用 Supplier接口作为方法参数类型，通过 Lambda表达式 来求出 int 数组中的最大值。

/**
 * 利用 Supplier接口 1.无参 2.有返回值 特性，返回数组最大值
 */
public class SupplierDemo{
    
    public static void main(String[] args){
        int max = printMax(()->{
            int[] arr = {19,63,15,84,56,38};
            Arrays.sort(arr);//默认为升序排序
            return arr[arr.length-1];
        });
        System.out.println("数组最大值为:"+max);
    }

    public static int printMax(Supplier supplier){
        int max = supplier.get();//通过supplier.get() 方法,获得返回值
        return max;
    }
}

2.Consumer

@FunctionalInterface
public interface Consumer {

    /**
     * Performs this operation on the given argument.
     *
     * @param t the input argument
     */
    void accept(T t);
}

  我们重点来看一下 accept() 方法（该接口还有一个 andThen()方法）。

  特点：①有参数     ②无返回值     --------->这种有参数 无返回值的接口，称之为"消费性接口"

  Demo：

     ①使用 Consumer 接口作为方法参数类型，通过 Lambda表达式 来将传入的"Hello Lambda"字母转为小写。

/**
 * 利用 Consumer接口 1.有参 2.无返回值 特性，将传入字母转为全小写
 */
public class ConsumerDemo{

    public static void main(String[] args){
        printLower((String str)->{
            String lower = str.toLowerCase();
            System.out.println("转为小写为："+lower);
        });

        //简写如下:
        //printLower(str->System.out.println("转为小写为："+str.toLowerCase()));
    }

    public static void printLower(Consumer consumer){
        consumer.accept("Hello Lambda");
    }

}

     ②将传入的"Hello Lambda"字母先转为小写，再转为大写（此处使用 andThen() 方法更精简）

public class ConsumerDemo{

    public static void main(String[] args){
        printLower((String str)->{
            String lower = str.toLowerCase();
            System.out.println("转为小写为:"+lower);
        },(String str)->{
            String upper = str.toUpperCase();
            System.out.println("转为大写为:"+upper);
        });  
    }

    public static void printLower(Consumer c1,Consumer c2){
        String str = "Hello Lambda";
        c1.accept(str);
        c2.accept(str);
    }
}

     ③先转为小写，再转为大写，使用 andThen 精简版，如下所示

public class ConsumerAndThenDemo{

    public static void main(String[] args){
       printLower(str->System.out.println("转为小写为:"+str.toLowerCase()),str->System.out.println("转为大写为:"+str.toUpperCase()));
    }

    public static void printLower(Consumer c1,Consumer c2){
        String str = "Hello Lambda";
        c1.andThen(c2).accept(str);
    }
}

3.Function

@FunctionalInterface
public interface Function {

    /**
     * Applies this function to the given argument.
     *
     * @param t the function argument
     * @return the function result
     */
    R apply(T t);
}

  我们重点来看一下 apply() 方法（该接口还有一个 andThen()、identify()、compose()方法）。

  特点：①有参数     ②有返回值     --------->这种有参数 有返回值的接口，称之为"类型转换接口"

  Demo：

     ①使用 Function 接口作为方法参数类型，通过 Lambda表达式 来将传入的"Hello Lambda"字母转为小写，并返回。

/**
 * 利用 Function接口 1.有参 2.有返回值 特性，将传入字母转为小写，并返回
 */
public class FunctionDemo{

    public static void main(String[] args){
        String lower = showLower(str->str.toLowerCase());
        System.out.println("转为小写为:"+lower);
    }

    public static String showLower(Function function){
        String resVal = function.apply("Hello Lambda");
        return resVal;
    }

}

     ②传入一个 String 类型值，将其转换为 Integer 类型，并将返回值 * 5，再次返回（此处使用andThen()方法）

/**
 * andThen() 方法，简写版
 */
public class FunctionAndThenDemo{

    public static void main(String[] args){
        int num = printNum(str->Integer.parseInt(str),str->str*5);
        System.out.println("转为Integer,*5后为:"+num);
    }

    public static Integer printNum(Function f1,Function f2){
    Integer num = f1.andThen(f2).apply("10");
    return num;
    }
}

4.Predicate

@FunctionalInterface
public interface Predicate {

    /**
     * Evaluates this predicate on the given argument.
     *
     * @param t the input argument
     * @return {@code true} if the input argument matches the predicate,
     * otherwise {@code false}
     */
    boolean test(T t);
}

     我们重点来看一下 test() 方法（该接口还有一个 and()、or()、negate()、isEqual()方法）。

     特点：①有参数     ②返回 bollean值     --------->这种 返回 bollean 类型 接口，就是用来做判断的。

  Demo：

     ①使用 Predicate 接口作为方法参数类型，通过 Lambda表达式 来判断 传入的值是否大于10，并返回 true/false

/**
 * 利用 Predicate接口 1.有参 2.返回值为boolean 特性，将传入参数与20进行比较，并返回true/false
 */
public class PredicateDemo{

    public static void main(String[] args){
        boolean flag = flag(num->num > 20);
        System.out.println("传入值是否大于20："+flag);
    }

    public static boolean flag(Predicate predicate){
        boolean flag = predicate.test(15);
        return flag;
    }
}

     ②判断传入参数包含H，同时包含 W(使用 and()方法更精简，如下所示)

public class PredicateDemo{

    public static void main(String[] args){
        boolean flag = flag(str->str.contains("H"),str->str.contains("W"));
        if(flag){
            System.out.println("包含H,同时包含W");
        }else{
            System.out.println("Ohters...");
        }
    }

    public static boolean flag(Predicate p1,Predicate p2){
        String str = "Hello World";
        boolean flag1 = p1.test(str);
        boolean flag2 = p2.test(str);
        if(flag1 && flag2){
            return true;
        }else{
            return false;
        }
    }
}

     ③使用and()方法判断传入参数包含H，同时包含 W

public class PredicateDemo{

    public static void main(String[] args){
        boolean flag = flag(str->str.contains("H"),str->str.contains("W"));
        if(flag){
            System.out.println("包含H,同时包含W");
        }else{
            System.out.println("Ohters...");
        }
    }

    public static boolean flag(Predicate p1,Predicate p2){
        String str = "Hello orld";
        boolean flag = p1.and(p2).test(str);
        if(flag){
            return true;
        }else{
            return false;
        }
    }
}

     ④使用 or()方法、negate()方法   同 与或非

        negate() 方法就是非的意思。本文就不在此处过多的介绍 or()方法 和 negate()方法 的使用了

---

附：JDK8新特性（目录）

    本目录为 JDK8新特性 学习目录，包含JDK8 新增全部特性的介绍。

    如需了解，请跳转链接查看：我是跳转链接

---

博主写作不易，来个关注呗

求关注、求点赞，加个关注不迷路 ヾ(◍°∇°◍)ﾉﾞ

博主不能保证写的所有知识点都正确，但是能保证纯手敲，错误也请指出，望轻喷 Thanks♪(･ω･)ﾉ