java8新特性-lambda表达式

java10都要来了，才才才说java8新特性？好吧，大神，再见，这不是写给你看的
-_-!
为什么要要使用lambda表达式？
lambda表达式能以简洁的代码代替复杂、啰嗦的代码，也更易阅读！
最后也附上简单的性能测试，总体上数量越大，lambda性能越好，可能不同的业务逻辑及方法都不会一样，仅供参考！
没有理论，上来就撸代码！

public class LambdaTest extends BaseTest {
    @Data
    @AllArgsConstructor
    public class Apple {
        private int weight;
        private Double price;
        private String color;
    }

    public interface Predicate<T> {
        boolean test(T t);
    }


    private List<Apple> apples;

    @Before

    public void init() {
        apples = Arrays.asList(
                new Apple(115, 1.2, "red"),
                new Apple(4, 1.5, "red"),
                new Apple(3, 2.2, "green"),
                new Apple(10, 1.2, "green"),
                new Apple(11, 0.2, "red"),
                new Apple(2, 2.2, "green")
        );
    }

    @Test
    public void sortTest() {
        //一般排序
        apples.sort(new Comparator<Apple>() {
            @Override
            public int compare(Apple o1, Apple o2) {
                return o1.getWeight() - o2.getWeight();
            }
        });
        Assert.assertEquals(apples.get(0).getWeight(), 2);
    }

    @Test
    public void lambdaSortTest() {
        //lambda排序 是不是简洁很多 并且也好理解
        apples.sort((Apple o1, Apple o2) -> o1.getWeight() - o2.getWeight());
        //可以去掉参数类型，通过上下文推断  个人还是加上参数类型，不介意多敲几个代码
        //apples.sort((o1, o2) -> o1.getWeight() - o2.getWeight());
        Assert.assertEquals(apples.get(0).getWeight(), 2);
    }


    @Test
    public void searchTest() {
        //一般匿名查询
        List<Apple> list = filter(apples, new Predicate<Apple>() {
            @Override
            public boolean test(Apple apple) {
                return apple.getColor().equals("green");
            }
        });
        Assert.assertEquals(list.get(0).getColor(), "green");
    }

    @Test
    public void lambdaSearchTest() {
        //lambda匿名方法查询 要理解函数式接口，通俗点讲就是一个接口中，只有一个方法
        List<Apple> list = filter(apples, (Apple o1) -> o1.getColor().equals("grenn"));
        Assert.assertEquals(list.get(0).getColor(), "green");
    }

    @Test
    public void lambdaBlockTest() {
        //代码块，可赋值
        Runnable run = () -> System.out.println("Thread run********");
        Thread t = new Thread(run);
        t.run();
    }


    @Test
    public void functionTest() {
        //方法引用，可以看做是lambda的快捷写法 如果允许可以大胆的使用 比lambda更简洁
        //再借用Function 包，可以省去很多代码
        //

        //方法引用排序，主要排序规则在comparing方法中实现
        apples.sort(comparing(Apple::getWeight));
        Assert.assertEquals(apples.get(0).getWeight(), 2);
        //使用String的length方法,下面对应参数自身的length方法
        Function<String, Integer> function = String::length;
        Integer len = function.apply("123");
        Assert.assertEquals(len, (Integer) 3);
    }

    @Test
    public void compositeTest() {
        //lambda复合，其实就是执行多个条件,这主要是基于function包的工具类的实现，实现很简单
        //使用的接口默认方法，也是java8中的新特性，
        java.util.function.Predicate<Apple> predicate = (Apple o1) -> o1.getPrice() > 1.0;
        predicate.and(a -> a.getWeight() > 5)
                .or(a -> "green".equals(a.getColor()));
    }
@Test
    public void test() {

        //简单的性能测试
        apples = new ArrayList<>();
        int max = 10000;
        for (int i = 0; i < max; i++) {
            apples.add(new Apple(max - i, 2.0, ""));
        }
        long t1 = new Date().getTime();
        sortTest();
        long t2 = new Date().getTime();
        lambdaSortTest();
        long t3 = new Date().getTime();
        System.out.println("for：" + (t2 - t1));
        System.out.println("lambda：" + (t3 - t2));

        //性能旗鼓相当，数据量少的时候 for性能要好于lambda，反之亦然
        //当max为10000的时候，lambda就好于for了，当然这只是粗略的测试
    }
    private <T> List<T> filter(
            List<T> list, Predicate<T> predicate)

    {
        List<T> realList = new ArrayList();
        for (T t : list
                ) {
            if (predicate.test(t)) {
                realList.add(t);
            }

        }
        return realList;
    }
}