Lambda表达式

函数式接口

函数式接口在Java中是指：有且仅有一个抽象方法的接口。
函数式接口，即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda，所以函数式接口就是可
以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。
备注：“语法糖”是指使用更加方便，但是原理不变的代码语法。例如在遍历集合时使用的for-each语法，其实
底层的实现原理仍然是迭代器，这便是“语法糖”。从应用层面来讲，Java中的Lambda可以被当做是匿名内部
类的“语法糖”，但是二者在原理上是不同的。

@FunctionalInterface注解

@FunctionalInterface
public interface ParentInterface {
    String method();
}

　

性能浪费的日志案例
注:日志可以帮助我们快速的定位问题，记录程序运行过程中的情况，以便项目的监控和优化。
一种典型的场景就是对参数进行有条件使用，例如对日志消息进行拼接后，在满足条件的情况下进行打印输出：

package com.lamda;

import org.junit.Test;

import java.util.*;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

public class DemoChild {
    /**
     * 自定义函数式编程
     */
    @Test
    public void test01() {
        doSomeThing(() -> {
            System.out.println("1111");
            return "";
        });
    }

    private static void doSomeThing(ParentInterface child) {
        child.method();
    }

    //延迟加载
    @Test
    public void test02() {
        String msgA = "a";
        String msgB = "ab";
        String msgC = "acb";
        log(1, () -> {
            return msgA + msgB + msgC;
        });
    }

    public void log(int level, ParentInterface p) {
        if (level == 1) {
            System.out.println(p.method());
        }
    }

    //作为参数
    @Test
    public void test03() {
        startThread(() -> {
            System.out.println("abc");
        });
    }

    public static void startThread(Runnable task) {
        new Thread(task).start();
    }

    //返回值
    private static Comparator<String> newComparator() {
        return (a, b) -> b.length() - a.length();
    }

    @Test
    public void test04() {
        String[] array = {"abc", "bcd", "bbcd"};
        Arrays.sort(array, newComparator());
        System.out.println(Arrays.toString(array));
    }

    //另外一种排序写法
    private void sortOrder() {
        ArrayList<String> list = new ArrayList<String>();
        list.add("cba");
        list.add("aba");
        list.add("sba");
        list.add("nba");
        //排序方法  按照第一个单词的降序
        Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o2.charAt(0) - o1.charAt(0);
            }
        });
    }

    /**
     * java.util.function.Supplier<T> 接口仅包含一个无参的方法： T get() 。用来获取一个泛型参数指定类型的对
     * 象数据。由于这是一个函数式接口，这也就意味着对应的Lambda表达式需要“对外提供”一个符合泛型类型的对象
     * 数据。
     * 打印结果 Helloworld
     */
    @Test
    public void test05() {
        String msgA = "Hello";
        String msgB = "world";
        System.out.println(get(() -> msgA + msgB));
    }

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

    //案例求最大值
    @Test
    public void test06() {
        int[] array = {2, 183, 1, 9};
        Integer max = getMax(() -> {
            int num = array[0];
            for (int i : array) {
                if (i > num)
                    num = i;
            }
            return num;

        });
        System.out.println(max);
    }

    public static Integer getMax(Supplier<Integer> p) {
        return p.get();
    }

    /**
     * java.util.function.Consumer<T> 接口则正好与Supplier接口相反，它不是生产一个数据，而是消费一个数据，
     * 其数据类型由泛型决定。
     */
    @Test
    public void test7() {
        consumeStr(s -> System.out.println(s.toUpperCase()),
                s -> System.out.println(s.toLowerCase())
        );
    }

    public void consumeStr(Consumer<String> s, Consumer<String> b) {
        s.andThen(b).accept("zhaNgSAN");
    }

    //demo,打印数组
    public static void printInfo(Consumer<String> a, Consumer<String> b, String[] arr) {
        for (String info : arr) {
            a.andThen(b).accept(info);
        }
    }

    @Test
    public void test8() {
        String[] array = {"迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男"};
        printInfo(s -> System.out.println(s.split(",")[0]),
                s -> System.out.println(s.split(",")[1]),
                array
        );
    }

    /**
     * 有时候我们需要对某种类型的数据进行判断，从而得到一个boolean值结果。这时可以使用
     * java.util.function.Predicate<T> 接口。
     */
    @Test
    public void test9() {
        demo9(s -> s.length() > 5);
    }

    private void demo9(Predicate<String> p) {
        boolean helloWorld = p.test("HelloWorld");
        System.out.println(helloWorld);
    }

    /**
     * 既然是条件判断，就会存在与、或、非三种常见的逻辑关系。其中将两个 Predicate 条件使用“与”逻辑连接起来实
     * 现“并且”的效果时，可以使用default方法 and 。其JDK源码为：
     */
    @Test
    public void test10() {
        demo10(s -> s.contains("H"), d -> d.contains("D"));
    }

    private void demo10(Predicate<String> p, Predicate<String> b) {
        boolean helloWorld = p.and(b).test("HelloWorld");
        System.out.println(helloWorld);
    }

    /**
     * 既然是条件判断，就会存在与、或、非三种常见的逻辑关系。其中将两个 Predicate 条件使用“与”逻辑连接起来实
     * 现“并且”的效果时，可以使用default方法 and 。其JDK源码为：
     */
    @Test
    public void test11() {
        demo11(a -> a.contains("H"),
                b -> b.contains("e")
        );
    }

    private void demo11(Predicate<String> p, Predicate<String> b) {
        boolean helloWorld = p.or(b).or(b).test("HelloWorld");
        System.out.println(helloWorld);
    }

    /**
     * 既然是条件判断，就会存在与、或、非三种常见的逻辑关系。其中将两个 Predicate 条件使用“与”逻辑连接起来实
     * 现“并且”的效果时，可以使用default方法 and 。其JDK源码为：
     */
    @Test
    public void test12() {
        demo12(a -> a.contains("b"),
                b -> b.length() > 11
        );
    }

    private void demo12(Predicate<String> p, Predicate<String> b) {
        boolean helloWorld = p.negate().test("HelloWorld");
        System.out.println(helloWorld);
    }

    /**
     * 既然是条件判断，就会存在与、或、非三种常见的逻辑关系。其中将两个 Predicate 条件使用“与”逻辑连接起来实
     * 现“并且”的效果时，可以使用default方法 and 。其JDK源码为：
     */
    @Test
    public void test13() {
        demo13(a -> a.contains("b"),
                b -> b.length() > 11
        );
    }

    private void demo13(Predicate<String> p, Predicate<String> b) {
        boolean helloWorld = p.negate().test("HelloWorld");
        System.out.println(helloWorld);
    }

    /**
     * 数组当中有多条“姓名+性别”的信息如下，请通过 Predicate 接口的拼装将符合要求的字符串筛选到集合
     * ArrayList 中，需要同时满足两个条件：
     * 1. 必须为女生；
     * 2. 姓名为4个字。
     */
    @Test
    public void test14() {
        String[] array = {"迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男", "杨颖,女", "杨幂,女"};
        List list = demo14(array,
                s -> "女".equals(s.split(",")[1]),
                s -> s.split(",")[0].length() == 4
        );
        System.out.println(list);

    }

    private List demo14(String[] array, Predicate<String> p, Predicate<String> b) {
        List data = new ArrayList<String>();
        for (String s : array) {
            if (p.and(b).test(s))
                data.add(s);
        }
        return data;
    }


    /**
     * java.util.function.Function<T,R> 接口用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件，
     * 后者称为后置条件
     */
    @Test
    public void test15() {
        String b = "5";
        demo15(b, s -> Integer.parseInt(s));


    }

    private void demo15(String b, Function<String, Integer> f) {
        Integer apply = f.apply(b);
        System.out.println(apply + 10);

    }

    @Test
    public void test16() {
        String b = "5";
        demo16(b,
                s -> Integer.parseInt(s),
                c -> c *= 10);


    }

    private void demo16(String b, Function<String, Integer> f, Function<Integer, Integer> c) {
        Integer apply = f.andThen(c).apply(b);
        System.out.println(apply);

    }

    /**
     * 请使用 Function 进行函数模型的拼接，按照顺序需要执行的多个函数操作为
     * 1. 将字符串截取数字年龄部分，得到字符串；
     * 2. 将上一步的字符串转换成为int类型的数字；
     * 3. 将上一步的int数字累加100，得到结果int数字。
     */
    @Test
    public void test17() {
        String nameAge="赵丽颖,18";

        int age = demo17(nameAge, s -> s.split(",")[1],
                b -> Integer.parseInt(b),
                n -> n += 100
        );
        System.out.println(age);

    }
    private int demo17(String b, Function<String, String> one, Function<String, Integer> two,Function<Integer, Integer> three) {
        return one.andThen(two).andThen(three).apply(b);
    }




}