Lambda表达式学习与实践

最近项目从Java7升级Java8，感觉新的代码已经可以完全拥抱Java8的新特性了：Lambda表达式、函数式接口、流API、默认方法和新Date/Time Api。这里整理一点Lambda表达式的使用场景和示例。

首先声明两个重要的概念：

1. Lambda表达式不是Java独有的概念，它代表的是一个匿名函数，是基于数学中的λ演算得名，直接对应于其中的lambda抽象(lambda abstraction)，是一个匿名函数，即没有函数名的函数。在C#、C++、Python、Scala等语言已经支持Lambda表达式，甚至Java看起来是从JVM语言Scala中学习过来的。
2. Lambda表达式是一个语法糖。它编译后的结果这个下面还会讲到。

Lambda表达式两大功能：1. 代替了内部类，使代码更美观；2. 操作集合数据。
Lambda结构：

(params) -> expression
(params) -> statement
(params) -> { statements }

一、下面我们先看看如何替代内部类，类似的可以替换Runnable,*Listener,Comparator等：

public class TestLambda {

    public static void main(String[] args) {
        lambdaRaplaceInnerClass();
    }

    public static void lambdaRaplaceInnerClass() {
        //1. 替换runnable实现
        new Thread(new Runnable(){
            @Override
            public void run() {
                System.out.println("Before Java8, too much code for too little to do");
            }
        }).start();

        new Thread(() -> System.out.println("In Java8, Lambda expression get shorter")).start();

        //2. 替换comparator实现
        List<Integer> lists = Arrays.asList(1,8,4,6,7,8,4,5,7);
        Collections.sort(lists, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1>o2 ? -1 : 1;
            }
        });
        lists.forEach(System.out::print);
        Collections.sort(lists, (o1,o2) -> o1<o2 ? -1 : 1);
        System.out.println();
        lists.forEach(System.out::print);
    }
}

执行结果：

Before Java8, too much code for too little to do
In Java8, Lambda expression get shorter
887765441
144567788

二、操作集合类，迭代、过滤、复制、聚合、统计、去重

public class TestLambda {

    public static void main(String[] args) {
        lambdaHandleCollection();
    }
    
    public static void lambdaHandleCollection() {
        //1. 迭代
        List<Integer> lists = Arrays.asList(1,8,4,6,7,8,4,5,7);
        lists.forEach(n -> System.out.print(n));
        System.out.println();
        //使用方法应用::双冒号，使代码看起来更简洁
        lists.forEach(System.out::print);
        System.out.println();

        //2. 函数式接口java.util.function.Predicate
        filter(lists, (n)->Integer.valueOf(n.toString())>6);
        System.out.println();
        filter2(lists, (n)->Integer.valueOf(n.toString())<5);
        System.out.println();
        filter3(lists, (n)->Integer.valueOf(n.toString())<8, (n)->Integer.valueOf(n.toString())>3);
        System.out.println();

        //3. map和Reduce进行映射和聚合
        double total =0;
        for(Integer price : lists) {
            double cost = price * 0.8;
            total += cost;
        }
        System.out.println("total: " + total);
        double total2 = lists.stream().map(n -> n*0.8).reduce((sum, n) -> sum+n).get();
        System.out.println("total: " + total);

        //4. 过滤
        List<Integer> listsTem = lists.stream().filter((n)->Integer.valueOf(n.toString())<5).collect(Collectors.toList());
        listsTem.forEach(System.out::print);
        System.out.println();
        List<String> strList = Arrays.asList("a", "B", "C");
        //5. 对每个元素进行操作，对结果在进行聚合、拼接等
        String strListTem = strList.stream().map((x)->x.toLowerCase()).collect(Collectors.joining(","));
        System.out.println(strListTem);

        //5. 去重
        lists.stream().distinct().forEach(n ->System.out.print(n));
    }

    public static void filter(List<Integer> lists, Predicate predicate) {
        for(Integer n : lists) {
            if (predicate.test(n)) {
                System.out.print(n);
            }
        }
    }
    public static void filter2(List<Integer> lists, Predicate predicate) {
        lists.stream().filter(predicate).forEach(n -> System.out.print(n));
    }
    public static void filter3(List<Integer> lists, Predicate predicate1,Predicate predicate2) {
        lists.stream().filter(predicate1.and(predicate2)).forEach(n -> System.out.print(n));
    }
}

当然，这里只列了几个较为简单的，还有很多函数没有一一列举，另外，对lambda表达式、函数、流的原理并没有介绍，后面研究完后会整理到后面的博客里。

List转Map：使用java8的lambda将list转为map（转）
Map转List：https://blog.csdn.net/wonder_dog/article/details/81784159