Java8新特性 Lambda表达式(二)

四大核心内置函数

阅读本文需要注意：下面在用到<>这个符号的时候，也就是泛型，我在里面加了’’，变成了<’’>，这是因为表格中的数据如果加了泛型，<>会解析成HTML标签，内容就不显示了，至于怎么转义，我没有去Google，只是加了单引号以便区分，所以在这里强调一下，避免误导读者，其实这个锅应该优快云来背锅，哈哈 ~

回归正题，上一篇博文，主要讲了Lambda表达式的基本使用和自定义函数式接口，这篇博文总结了Java8为我们提供了几个内置的函数式接口。

首先说的是常用的四大核心函数式接口，如下表：

核心函数式接口	参数类型	返回类型	用法
Consumer<'T'>消费型接口	T	void	对类型为T的对象进行操作，包含方法：void accept(T t);
Supplier<'T'>供给型接口	无	T	返回类型为T的对象，包含方法：T get();
Function<'T,R'>函数型接口	T	R	对类型为T的对象进行操作，并返回R类型的结果。包含方法：R apply(T t);
Predicate<'T'>断言型接口	T	boolean	判断类型为T的对象是否满足某约束，并返回boolean值。包含方法boolean test(T t)

上面的表中记录的就是四大核心内置函数了。各位读者也可以通过IDE查看源码。下面就讲讲这些函数的使用。

函数练习

使用上述的函数进行编码练习。

①、Consumer

    private static final Book JAVA_BOOK = new Book("MySQL从零开始学", 75D, "王英英", 1L);

    @Test
    public void test1() {
        readBook(JAVA_BOOK, (book) -> System.out.println("我最近在读'" + book.getBookName() + "'这本书"));
    }

    private void readBook(Book book, Consumer<Book> consumer) {
        consumer.accept(book);
    }

因为这个函数式接口是消费型，所以对传入的对象进行操作，这里就以读书为例。

②、Supplier

这个是供给类型的函数，因此，需要用它返回指定位数的随机数。

    @Test
    public void test2() {
        String str = getRandomStr(6, () -> {
            String model = "0123456789";
            String upperStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
            String lowerStr = upperStr.toLowerCase();
            StringBuilder builder = new StringBuilder();
            builder.append(model).append(upperStr).append(lowerStr);
            char[] m = builder.toString().toCharArray();
            char ch = m[(int) (Math.random() * builder.length())];
            return ch;
        });
        System.out.println(str);
    }

    private String getRandomStr(int num, Supplier<Character> supplier) {
        String linkNo = "";
        for (int i = 0; i < num; i++) {
            final Character c = supplier.get();
            //保证随机数没有重复的
            if (linkNo.contains(String.valueOf(c))) {
                i--;
                continue;
            }
            linkNo = linkNo + c;
        }
        return linkNo;
    }

上面的方法可能写的比较冗余，主要是为了演示这个函数的用法。

③、Function<T,R>

这个函数既有入参还有返回值，所以方便我们对字符串的处理。

    @Test
    public void test3() {
        final String handleStr = "hello world \t\t\t";
        String trimStr = getStr(handleStr, (params) -> params.trim());
        System.out.println(trimStr.length());
        System.out.println(handleStr.length());

        String subStr = getStr(handleStr, (params) -> params.substring(0, 7));
        System.out.println(subStr);
    }

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

上面就是对字符串去除空格以及字符串截取的操作。

④、Predicate

这个断言型的函数，可以对入参进行判断，结果返回boolean类型。所以，我们要将长度大于3的字符串放入集合中。

    @Test
    public void test4() {
        String str1 = "hello";
        String str2 = "world";
        String str3 = "abc";
        String str4 = "123";
        String str5 = "cxk";
        String[] strArray = {str1, str2, str3, str4, str5};
        List<String> list = Arrays.asList(strArray);
        List<String> stringList = operatorStr(list, (str) -> str.length() > 3);
        stringList.forEach(System.out::println);
    }

    private List<String> operatorStr(List<String> list, Predicate<String> predicate) {
        List<String> stringList = new ArrayList<>();
        for (String str : list) {
            if (predicate.test(str)) {
                stringList.add(str);
            }
        }
        return stringList;
    }

基本上四大核心内置函数的使用方法就是这样，也是非常简单的，最后下表列出了一些其他的内置函数。基本上使用方法和上面的四个函数一致。唯一不同的就是对参数列表进行了扩展。

其他接口	参数类型	返回值类型	用法
BiFunction<'T,U,R'>	T,U	R	对类型为T，U的参数进行操作，返回R类型的结果，包含方法：R apply(T t, U u);
UnaryOperator<'T'>	T	T	对类型为T的对象进行一元运算，并返回T类型的结果，包含方法：T apply(T t);实则继承了Function<'T,R'>
BinaryOperator<'T'>	T,T	T	对类型为T的对象进行二元运算，并返回T类型的结果，包含方法：T apply(T t1, T t2);
BiConsumer<'T, U'>	T,U	void	对类型为T ，U的参数进行操作。包含方法：void accept(T t, U u);
ToIntFunction<'T'>	T	int	返回int值的函数，包含方法：int applyAsInt(T value);
ToLongFunction<'T'>	T	long	返回long值的函数，包含方法：long applyAsLong(T value);
ToDoubleFunction<'T'>	T	double	返回double值的函数，包含方法：double applyAsDouble(T value);
IntFunction<'R'>	int	R	参数是int类型的函数，包含方法：R apply(int value);
LongFunction<'R'>	long	R	参数是long类型的函数，包含方法：R apply(long value);
DoubleFunction<'R'>	double	R	参数是double类型的函数，包含方法：R apply(double value);

上面表格中就是Java8中的其他函数了，通过查看参数、返回值和使用方法，大致可以确定，这些函数都是以前四个核心内置函数为基石，扩展出来的。所以在使用上面不用担心，基本上，弄懂了前四个函数，后面的函数也大同小异了。

所有人都想成功，但是成功的诀窍又是什么呢？