Java 8

Java 8 是Java 自Java 5（2004年）之后的最重要的版本，这个版本包含语言、编译器、库、工具盒JVM等方面的十多个新特性。

Java语言的新特性

1.Lambda表达式和函数式接口

　　Lambda表达式（也称为闭包）是java 8中最令人期待的语言改变。它允许我们将函数当成参数传递给某个方法，或者把代码本身当做数据处理。

基本语法:
(parameters) -> expression
或
(parameters) ->{ statements; }

　　最简单的Lambda表达式可由逗号分隔参数列表、 ->符号和语句块组成，如：

Arrays.asList("a", "b", "c").forEach(e -> System.out.println(e));

在上面的代码中参数e的类型是由编译器推理得出的，也可以显示指定该参数的类型，如：

Arrays.asList("a", "b", "c").forEach((String e) ->System.out.println(e));

如果Lambda表达式需要更复杂的语句块，则可以使用花括号将该语句块扩起来，类似于java的函数体，如：

Arrays.asList("a","b","c").forEach(c->{
    System.out.println("lala");
    System.out.println(c);
});

Lambda表达式可以引用类成员和局部变量（会将这些变量隐式转换成final），例如下面两个代码块完全相同：

        String separator = ",";
        Arrays.asList("a", "b", "c").forEach(e -> System.out.println(e + separator));

        final String separator = ",";
        Arrays.asList("a", "b", "c").forEach(e -> System.out.println(e + separator));

Lambda表达式有返回值，返回值的类型也由编译器推理得出。例如Lambda表达式中的语句块只有一行，则可以不用使用return语句，下面两个代码块相同：

        Arrays.asList("a","b","c").sort((n1,n2)->n1.compareTo(n2));

        Arrays.asList("a","b","c").sort((n1,n2)->{
            int result = n1.compareTo(n2);
            return result;
        });

Lambda还有函数接口这个概念，函数接口指的是只有一个函数的接口，这样的接口可以隐式转换为Lambda表达式。java.lang.Runnable和java.util.concurrent.Callable是函数接口的最佳例子。在实践中，函数接口非常脆弱：只要某个开发者在该接口中添加一个函数，则该接口就不再是函数式接口而导致编译失败。为了客户这种代码层面的脆弱性，并显示说明某个接口是函数式接口，java 8提供了一个特殊的注解@FunctionInterface(java库中的所有相关接口都已经带有这个注解了)，函数式接口的定义：

package com.spring.boot.utils;

@FunctionalInterface
public interface Functional {
    void method();
}

不过有一点需要注意，默认方法和静态方法不会破坏函数式接口的定义，因此如下的代码是合法的。

package com.spring.boot.utils;

@FunctionalInterface
public interface Functional {
    void method();

    default void defaultMethod(){

    }

    static void staticMethod(){

    }
}

Lambda表达式作为Java 8 最大的卖点，它又潜力吸引更多的开发者加入到JVM平台，并在纯Java编程中使用函数式编程的概念。

2.接口的默认方法和静态方法

　　Java 8 使用两个新概念扩展了接口的含义：默认方法和静态方法。默认方法使得开发者可以再补破坏二进制兼容性的前提下，往现存接口中添加新的方法，即不强制那些实现了该接口的类也同时实现这个新加的方法。

默认方法和抽象方法之间的区别在于抽象方法需要实现，而默认方法不需要。接口提供的默认方法会被接口的实现类继承或者复写，代码如下：

package com.spring.boot.utils;

public interface Functional {

    default String notRequired(){
        return "default implemetation";
    }
}

实现此接口可以没有方法体 也可以重写他

public class testClass implements Functional {
    
}

Java 8 带来另一个有趣的特性是在接口中可以定义静态方法，代码如下：

package com.spring.boot.utils;

public interface Functional {

    static String hello(){
        return "hello";
    }
}

在类中使用接口的静态方法

String hello = Functional.hello();

由于JVM上的默认方法的实现在字节码层面提供了支持，因此效率非常高。默认方法允许在不打破现有继承体系的基础上改进接口。该特性在官方库中的应用是：给java。util。Collection接口添加新方法，如stream()、parallelStream()、forEach()、removeIf()等等

3 方法引用

　　方法引用使得开发者可以直接引用现存的方法、java类的构造方法或者实力对象。方法引用和Lambda表达式配合使用，使得java类的构造方法 看起来紧凑而间接，没有很多复杂的模板代码。

public class Car {
    public static Car create(final Supplier<Car> supplier){
        return supplier.get();
    }

    public static void didi(final Car car){
        System.out.println(car.getName() + "正在 滴滴滴");
    }

    public void baba(final Car car){
        System.out.println(car.getName()+"正在 叭叭叭");
    }

    public void repair(){
        System.out.println(this.toString());
    }

1.构造器引用：语法Class::new，或者更一般的形式： Class<T>::new。 这个构造器是没有参数的！

在实例化时这样使用：

Car car = Car.create(Car::new);
car.setId(1);
car.setName("sdf");

List<Car> cars = Arrays.asList(car);

2.方法引用的类型是静态方法，语法是Class::static_method，这个方法接受一个Car类型的参数

cars.forEach( Car::didi );

sdf正在 滴滴滴 成功调用方法 输出该name属性以及滴滴滴

3.方法引用的类型是某个类的成员方法，语法是Class::method，注意这个方法没有定义参数

cars.forEach( Car::repair );

com.spring.boot.bean.Car@9ead783 成功调用方法 输出这个对象的引用了

4.方法引用的类型是某个实例对象的成员方法 ，语法是instance::method。注意这个方法接受一个Car类型参数。

cars.forEach( car::baba );

sdf正在 叭叭叭

4.重复注解

注解有一个很大的限制是：在同一个地方不能多次使用同一个注解，Java 8 打破了这个限制，引入了重复注解的概念，允许在某一个地方多次使用同一个注解。

使用@Repoatable注解定义重复注解。

package com.spring.boot.bean;

import java.lang.annotation.ElementType;
import java.lang.annotation.Repeatable;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

public class RepeatingAnnotations {
    @Target( ElementType.TYPE )
    @Retention( RetentionPolicy.RUNTIME )
    public @interface Filters {
        Filter[] value();
    }

    @Target( ElementType.TYPE )
    @Retention( RetentionPolicy.RUNTIME )
    @Repeatable( Filters.class )
    public @interface Filter {
        String value();
    };

    @Filter( "filter1" )
    @Filter( "filter2" )
    public interface Filterable {
    }

    public static void main(String[] args) {
        for( Filter filter: Filterable.class.getAnnotationsByType( Filter.class ) ) {
            System.out.println( filter.value() );
        }
    }
}

Filter类使用了@Repeatable(Filters.class)注解修饰，而Filters是存放Filter注解的容器，编译器尽量对开发者屏蔽这些细节。这样，Filterable接口可以用两个Filter注解结实。

另外，反射API提供了一个新的方法：getAnnotationsByType()，可以返回某个类型的重复注解，例如Filterable.class.getAnnoation(Filters.class)将返回两个Filter实例，输出到控制台如下：

filter1
filter2

5.更好的类型推断

　　Java 8在编译器类型推断方面有很大的提升，在很多场景下编译器可以推断出某个参数的数据类型，从而使得代码更加简洁，如下：

package com.spring.boot.bean;

public class Value<T> {
    public static <T> T defaultValue() {
        return null;
    }

    public T getOrDefault(T value, T defaultValue) {
        return (value != null) ? value : defaultValue;
    }
}

final Value<String> value = new Value<>();
value.getOrDefault("22", Value.defaultValue());

Value.defaultValue()的类型由编译器推断得出，不需要显示声明，在java 7中以上代码会变异报错，需要强制转换为String。如：Value.<String>defaultValue();

6.Stream

新增的Stream API 将生成环境的函数式编程引入了java库中，这是目前为止最大的一次对java库的完善，以便开发者能够写出更加有效、更加简洁的代码

        List<Car> cars = Arrays.asList(
                new Car(1,"大众"),
                new Car(2,"宝马"),
                new Car(2,"奔驰"),
                new Car(3,"大众")
        );

        long  num =cars.stream().filter(c->c.getName() == "大众").mapToInt(Car::getId).sum();
        System.out.println(num);

以前想干点啥 上来先弄个foreach循环遍历 去判断， 但是在Java 8中可以利用stream解决：并且支持顺序和并行处理。

以上代码找出所有名字为大众的 id的sum 输出4

首先cars集合会被转换成stream表示，然后在stream上的filter操作会过滤掉其他名字的，然后mapToInt操作基于每个car势力的getId方法转换成Integer集合，最后通过sum方法计算综合，得到最后结果。