java8最重要新特性lambda表达式

Lambda 表达式是推动 Java 8发布的最重要新特性。Lambda允许把函数作为一个方法的参数（函数作为参数传递进方法中）。使用Lambda表达式可以使代码变的更加简洁紧凑。

---

什么是Lambda表达式?

Lambda 是一个匿名函数,我们可以把 Lambda 表达式理解为是一段可以传递的代码(将代码像数据一样进行传递)。可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使 Java的语言表达能力得到了提升。

---

1.替代匿名内部类

lambda表达式用得最多的场合就是替代匿名内部类，而实现Runnable接口是匿名内部类的经典例子。lambda表达式的功能相当强大，用()->就可以代替整个匿名内部类。代码如下：
使用匿名内部类：

    public void testRunable() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("测试线程正在运行");
            }
        }).start();
    }

使用lambda表达式：

public void runable() {
        new Thread(() -> System.out.println("lambda 666")).start();
    }

最后的运行结果

测试线程正在运行
lambda 666

lambda表达式牛X之处就是用极少的代码完成了以前一个类做的的事情！

---

2.lambda表达式迭代集合

java的集合类是我们日常开发过程中经常用到的，我们队集合类最常的操作就是迭代遍历了，下面的代码对java8前后进行了对比：

    public void forTest() {
        List<String> languages = Arrays.asList("java","scala","python");
        //java8之前的写法
        for(String each:languages) {
            System.out.println(each);
        }
        //java8的新写法
        languages.forEach(x -> System.out.println(x));
        languages.forEach(System.out::println);
    }

可以说是非常便捷了，这里涉及到一个scala的语法，需要下来学习一下。

---

3.lambda实现map

java8的新特性stream,会有另外的文档来详细记录一下其用法，map函数是函数式编程里最重要的一个方法了，map的作用是将一个对象变换为另外一个，这里看一下例子：

    public void mapTest() {
        List<Double> cost = Arrays.asList(10.0, 20.0,30.0);
        cost.stream().map(x -> x + x*0.05).forEach(x -> System.out.println(x));
    }

---

4.lambda实现map与reduce

reduce实现的则是将所有值合并为一个，还是Stream里的方法，详见stream的文档。
先看我们用循环的方式实现：

    public void sumTest() {
        List<Double> cost = Arrays.asList(10.0, 20.0,30.0);
        double sum = 0;
        for(double each:cost) {
            each += each * 0.05;
            sum += each;
        }
        System.out.println(sum);
    }

再看用lambda表达式实现：

    public void mapReduceTest() {
        List<Double> cost = Arrays.asList(10.0, 20.0,30.0);
        double allCost = cost.stream().map(x -> x+x*0.05).reduce((sum,x) -> sum + x).get();
        System.out.println(allCost);
    }

输出结果为

63.0

lambda+map+reduce简直不要太优雅。

5.lambda的filter操作

通过filter操作从原始集合中过滤掉一些元素。

    public void filterTest() {
        List<Double> cost = Arrays.asList(10.0, 20.0,30.0,40.0);
        List<Double> filteredCost = cost.stream().filter(x -> x > 25.0).collect(Collectors.toList());
        filteredCost.forEach(x -> System.out.println(x));

    }

输出结果为：

30.0
40.0

---

6.函数式接口Predicate

Predicate函数同样也是JAVA8重要的新特性之一。Predicate接口非常适用于做过滤。

    public static void filterTest(List<String> languages, Predicate<String> condition) {
        languages.stream().filter(x -> condition.test(x)).forEach(x -> System.out.println(x + " "));
    }

     public static void main(String[] args) {
        List<String> languages = Arrays.asList("Java","Python","scala","Shell","R");
        System.out.println("Language starts with J: ");
        filterTest(languages,x -> x.startsWith("J"));
        System.out.println("\nLanguage ends with a: ");
        filterTest(languages,x -> x.endsWith("a"));
        System.out.println("\nAll languages: ");
        filterTest(languages,x -> true);
        System.out.println("\nNo languages: ");
        filterTest(languages,x -> false);
        System.out.println("\nLanguage length bigger three: ");
        filterTest(languages,x -> x.length() > 4);
    }

输出结果为：

Language starts with J: 
Java 

Language ends with a: 
Java 
scala 

All languages: 
Java 
Python 
scala 
Shell 
R 

No languages: 

Language length bigger three: 
Python 
scala 
Shell

---

lambda的写法和注意事项总结

Lambda 表达式在Java 语言中引入了一个新的语法元 素和操作符。这个操作符为 “->” , 该操作符被称为 Lambda 操作符或剪头操作符。它将 Lambda 分为 两个部分:
左侧:指定了 Lambda 表达式需要的所有参数
右侧:指定了 Lambda 体,即 Lambda 表达式要执行的功能。

语法格式一：无参，无返回值，Lambda 只需一条语句

Runnable runnable = () -> System.out.println("lamda");

语法格式二：Lambda 只需要一个参数

Consumer<String> consumer=(x)->System.out.println(x);

语法格式三：Lambda 只需要一个参数时,参数的小括号可以省略

Consumer<String> consumer=x->System.out.println(x);

语法格式四：Lambda 需要两个参数

Comparator<Integer> comparator = (x, y) -> Integer.compare(x, y);

语法格式五：当 Lambda 只有一条语句时，return 与大括号可以省略

inaryOperator<Integer> binaryOperator=(x,y)->(x+y);

语法格式六：数据类型可以省略,因为可由编译器推断得出，称为“类型推断”

BinaryOperator<Integer> bo=(x,y)->{
System.out.println("Lambda");
return x+y;};

类型推断

Lambda 表达式中的参数类型都是由编译器推断得出的。Lambda 表达式中无需指定类型，程序依然可以编译，这是因为 javac 根据程序的上下文，在后台 推断出了参数的类型。Lambda 表达式的类型依赖于上 下文环境，是由编译器推断出来的。这就是所谓的 “类型推断”。