JAVA8 新特性

一、接口的默认方法
Java 8允许我们给接口添加一个非抽象的方法实现，只需要使用 default关键字即可，这个特征又叫做扩展方法，代码示例如下：

package com.ken.code.jdk8;

public interface Formula {
    public double fun(int a);
    default double fun2(int a){
        return a;
    }
}

二、Lambda 表达式
首先看看之前版本的Java中是如何排列字符串的：
代码如下：

public static void main(String[] args) {
		//转成list集合
        List<String> names = Arrays.asList("peter", "anna", "mike", "xenia");
        System.out.println("names:"+names);
        Collections.sort(names, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });
        System.out.println("names2:"+names);
    }

只需要给静态方法 Collections.sort 传入一个List对象以及一个比较器来按指定顺序排列。通常做法都是创建一个匿名的比较器对象然后将其传递给sort方法。

在Java 8 中你就没必要使用这种传统的匿名对象的方式了，Java 8提供了更简洁的语法，lambda表达式：

Collections.sort(names,(String a,String b) ->{
            return a.compareTo(b);
        });

还可以写得更短：
代码如下:

Collections.sort(names, (String a, String b) -> b.compareTo(a));

对于函数体只有一行代码的，你可以去掉大括号{}以及return关键字，但是你还可以写得更短点：
代码如下:

Collections.sort(names, (a, b) -> b.compareTo(a));

Java编译器可以自动推导出参数类型，所以你可以不用再写一次类型。接下来我们看看lambda表达式还能作出什么更方便的东西来：
三、函数式接口
Lambda表达式是如何在java的类型系统中表示的呢？每一个lambda表达式都对应一个类型，通常是接口类型。而“函数式接口”是指仅仅只包含一个抽象方法的接口，每一个该类型的lambda表达式都会被匹配到这个抽象方法。因为 默认方法 不算抽象方法，所以你也可以给你的函数式接口添加默认方法。
我们可以将lambda表达式当作任意只包含一个抽象方法的接口类型，确保你的接口一定达到这个要求，你只需要给你的接口添加 @FunctionalInterface 注解，编译器如果发现你标注了这个注解的接口有多于一个抽象方法的时候会报错的。

代码如下:

@FunctionalInterface
interface Converter<F, T> {
    T convert(F from);
}
Converter<String, Integer> converter = (from) -> Integer.valueOf(from);
Integer converted = converter.convert("123");
System.out.println(converted);    // 123

需要注意如果@FunctionalInterface如果没有指定，上面的代码也是对的。
译者注 将lambda表达式映射到一个单方法的接口上，这种做法在Java 8之前就有别的语言实现，比如Rhino JavaScript解释器，如果一个函数参数接收一个单方法的接口而你传递的是一个function，Rhino 解释器会自动做一个单接口的实例到function的适配器，典型的应用场景有 org.w3c.dom.events.EventTarget 的addEventListener 第二个参数 EventListener。
四、方法与构造函数引用
上面代码还可以通过静态方法引用来表示：
代码如下：

Converter<String, Integer> converter = Integer::valueOf;
Integer converted = converter.convert("123");
System.out.println(converted);   // 123

Java 8 允许你使用 :: 关键字来传递方法或者构造函数引用，上面的代码展示了如何引用一个静态方法，我们也可以引用一个对象的方法：
代码如下:

 converter = something::startsWith;
String converted = converter.convert("Java");
System.out.println(converted);    // "J"

接下来看看构造函数是如何使用::关键字来引用的，首先我们定义一个包含多个构造函数的简单类：
代码如下:

class Person {
    String firstName;
    String lastName;
    Person() {}

    Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
}

接下来我们指定一个用来创建Person对象的对象工厂接口：
代码如下:

interface PersonFactory<P extends Person> {
    P create(String firstName, String lastName);
}

这里我们使用构造函数引用来将他们关联起来，而不是实现一个完整的工厂：
代码如下:

PersonFactory<Person> personFactory = Person::new;
Person person = personFactory.create("Peter", "Parker");

我们只需要使用 Person::new 来获取Person类构造函数的引用，Java编译器会自动根据PersonFactory.create方法的签名来选择合适的构造函数。

五、Lambda 作用域
在lambda表达式中访问外层作用域和老版本的匿名对象中的方式很相似。你可以直接访问标记了final的外层局部变量，或者实例的字段以及静态变量。

六、访问局部变量
我们可以直接在lambda表达式中访问外层的局部变量：

代码如下:

final int num = 1;
Converter<Integer, String> stringConverter =
        (from) -> String.valueOf(from + num);
stringConverter.convert(2);     // 3

但是和匿名对象不同的是，这里的变量num可以不用声明为final，该代码同样正确：
代码如下:

int num = 1;
Converter<Integer, String> stringConverter =
        (from) -> String.valueOf(from + num);
stringConverter.convert(2);     // 3

不过这里的num必须不可被后面的代码修改（即隐性的具有final的语义），例如下面的就无法编译：
代码如下:

int num = 1;
Converter<Integer, String> stringConverter =
        (from) -> String.valueOf(from + num);
num = 3;

在lambda表达式中试图修改num同样是不允许的。

七、Lambda表达式特别篇
本文简单认识JDK8的重要新特性之一——Lambda表达式。 在JDK8之前，Java是不支持函数式编程的，所谓的函数编程，即可理解是将一个函数（也称为“行为”）作为一个参数进行传递。通常我们提及得更多的是面向对象编程，面向对象编程是对数据的抽象（各种各样的POJO类），而函数式编程则是对行为的抽象（将行为作为一个参数进行传递）。在JavaScript中这是很常见的一个语法特性，但在Java中将一个函数作为参数传递这却行不通，好在JDK8的出现打破了Java的这一限制。

认识Lambda表达式
　　首先来引入一个示例，不知给是否有在IDEA编写代码的经历，如果在JDK8的环境下如下所示按照Java传统的语法规则编写一个线程。

1 new Thread(new Runnable() {
2     @Override
3     public void run() {
4         System.out.println("Hello World!");
5     }
6 });

IDEA会给出提示可以使用Lambda表达式替换。

使用Lambda表达式则只需要使用一句话就可代替上面使用匿名类的方式

new Thread(() -> System.out.println("Hello World!"));

在这个例子中，传统的语法规则，我们是将一个匿名内部类作为参数进行传递，我们实现了Runnable接口，并将其作为参数传递给Thread类，这实际上我们传递的是一段代码，也即我们将代码作为了数据进行传递，这就带来许多不必要的“样板代码”。、
Lambda表达式一共有三部分组成：

后面的示例中我们会详解这个结构，包括有无参数，有无返回值的问题。 那么这个看起来奇奇怪怪的不太像Java的语法规则，其本身含义到底什么呢？这也是开始困扰我的问题，什么时候在什么场景下可以使用Lambda表达式。

能够接收Lambda表达式的参数类型，是一个只包含一个方法的接口。只包含一个方法的接口称之为“函数接口”。
　　例如上面创建一个线程的示例，Runnable接口只包含一个方法，所以它被称为“函数接口”，所以它可以使用Lambad表达式来代替匿名内部类。根据这个规则，我们试着来写一个函数接口，并使用Lambda表达式作为参数传递。

package com.coderbuff.custom;

/**
 * 函数接口：只有一个方法的接口。作为Lambda表达式的类型
 * Created by Kevin on 2018/2/17.
 */
public interface FunctionInterface {
    void test();
}

测试：

package com.coderbuff.custom;

import org.junit.Test;

/**
 * 函数接口测试
 * Created by Kevin on 2018/2/17.
 */
public class FunctionInterfaceTest {

    @Test
    public void testLambda() {
        func(new FunctionInterface() {
            @Override
            public void test() {
                System.out.println("Hello World!");
            }
        });
        //使用Lambda表达式代替上面的匿名内部类
        func(() -> System.out.println("Hello World"));
    }

    private void func(FunctionInterface functionInterface) {
        functionInterface.test();
    }
}

可以看到，只要是一个接口中只包含一个方法，则可以使用Lambda表达式，这样的接口称之为“函数接口”。

上面的函数接口比较简单不包含参数，也不包含返回值。

我们再来修改FunctionInterface函数接口逐步加大Lambda表达式的难度——包含参数，不包含返回值。

package com.coderbuff.custom;

/**
 * 函数接口：只有一个方法的接口。作为Lambda表达式的类型
 * Created by Kevin on 2018/2/17.
 */
public interface FunctionInterface {
    void test(int param);
}

测试：

package com.coderbuff.custom;

import org.junit.Test;

/**
 * 函数接口测试
 * Created by Kevin on 2018/2/17.
 */
public class FunctionInterfaceTest {

    @Test
    public void testLambda() {
        //使用Lambda表达式代替匿名内部类
        func((x) -> System.out.println("Hello World" + x));
    }

    private void func(FunctionInterface functionInterface) {
        int x = 1;
        functionInterface.test(x);
    }
}

关注Lambda表达式“(x) -> Sysout.out.println(“Hello World” + x)”，左边传递的是参数，此处并没有指明参数类型，因为它可以通过上下文进行类型推导，但在有些情况下不能推导出参数类型（在编译时不能推导通常IDE会提示），此时则需要指明参数类型。我个人建议，任何情况下指明函数的参数类型。

哪种情况不能推导出参数类型呢？就是函数接口是一个泛型的时候。

package com.coderbuff.custom;

/**
 * 函数接口：只有一个方法的接口。作为Lambda表达式的类型
 * Created by Kevin on 2018/2/17.
 */
public interface FunctionInterface<T> {
    void test(T param);
}

测试：

package com.coderbuff.custom;

import org.junit.Test;

/**
 * 函数接口测试
 * Created by Kevin on 2018/2/17.
 */
public class FunctionInterfaceTest {

    @Test
    public void testLambda() {
        //使用Lambda表达式代替匿名内部类
        func((Integer x) -> System.out.println("Hello World" + x));
    }

    private void func(FunctionInterface<Integer> functionInterface) {
        int x = 1;
        functionInterface.test(x);
    }
}

上面的示例提到了Lambda表达式的两种情况：

无参数，无返回值；

有参数，无返回值。

接下来就是有参数，有返回值这种较为复杂的情况。

package com.coderbuff.custom;

/**
 * 函数接口：只有一个方法的接口。作为Lambda表达式的类型
 * Created by Kevin on 2018/2/17.
 */
public interface FunctionInterface<T> {
    boolean test(T param);
}

测试：

package com.coderbuff.custom;

import org.junit.Test;

/**
 * 函数接口测试
 * Created by Kevin on 2018/2/17.
 */
public class FunctionInterfaceTest {

    @Test
    public void testLambda() {
        //使用Lambda表达式代替匿名内部类
        func((Integer x) -> true);
    }

    private void func(FunctionInterface<Integer> functionInterface) {
        int x = 1;
        functionInterface.test(x);
    }
}

此时的Lambda表达式“(Integer x) -> true”，右边是表达式的主体，直接返回true，如果有多行代码，则可以直接使用花括号表示，例如：

func((Integer x) -> {
    System.out.println("Hello World" + x);
    return true;
});

Lambda表达式基本的语法规则：

无参数，无返回值；

有参数，无返回值；

有参数，有返回值。

这三种基本情况已经大致清楚了，特别是需要弄清，什么时候可以使用Lambda表达式代替匿名内部类，也就是Lambda表达式的应用场景是函数接口。Lambda表达式这一新特性在JDK8中的引入，更大的好处则是集合API的更新，新增的Stream类库，使得我们在遍历使用集合时不再像以往那样不断地使用for循环。
　　
JDK8使用集合的正确姿势
　　示例：计算来自“chengdu”的学生数量有多少。

在JDK8前的代码：

for (Student student : studentList) {
    if (student.getCity().equals("chengdu")) {
        count++;
    }
}

JDK8使用集合的正确姿势：

count = studentList.stream().filter((student -> student.getCity().equals("chengdu"))).count();

API的使用“难度”恰似提高了，实际只是不熟悉而已。传统迭代的方式需要阅读完整个循环才能明白代码逻辑，JDK8通过流的方式则可以望文生义且代码量大大减小。

其中最为重要的是——Stream流。Stream的是通过函数式编程方式实现的在集合类上进行复杂操作的工具。若要详细讲解Stream的实现方式我相信再写一篇博客也不为过，所以此处不再考查Stream的内部实现。这里是想告诉大家，如果有幸使用JDK8的开发环境进行开发，尽量学习使用新的集合操作API