java8新特性

Lambda表达式和函数式接口

Java8中引入了一个新的操作符“ -> ”，该操作符被称为箭头操作符或Lambda操作符，箭头操作符将Lambda表达式拆分成两部分：

• 左侧：Lambda表达式的参数列表
• 右侧：Lambda表达式中所需要执行的功能，即Lambda体

Lambda表达式（也称为闭包）是Java 8中最大和最令人期待的语言改变。它允许我们将函数当成参数传递给某个方法，或者把代码本身当作数据处理：函数式开发者非常熟悉这些概念。很多JVM平台上的语言（Groovy、Scala等）从诞生之日就支持Lambda表达式，但是Java开发者没有选择，只能使用匿名内部类代替Lambda表达式。

Lambda的设计耗费了很多时间和很大的社区力量，最终找到一种折中的实现方案，可以实现简洁而紧凑的语言结构。最简单的Lambda表达式可由逗号分隔的参数列表、->符号和语句块组成，例如：

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

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

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

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

Arrays.asList( "a", "b", "d" ).forEach( e -> {
    System.out.print( e );
    System.out.print( e );
} );

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

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

和

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

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

Arrays.asList( "a", "b", "d" ).sort( ( e1, e2 ) -> e1.compareTo( e2 ) );

和

Arrays.asList( "a", "b", "d" ).sort( ( e1, e2 ) -> {
    int result = e1.compareTo( e2 );
    return result;
} );

Lambda的设计者们为了让现有的功能与Lambda表达式良好兼容，考虑了很多方法，于是产生了函数接口这个概念。函数接口指的是只有一个函数的接口，这样的接口可以隐式转换为Lambda表达式。java.lang.Runnable和java.util.concurrent.Callable是函数式接口的最佳例子。在实践中，函数式接口非常脆弱：只要某个开发者在该接口中添加一个函数，则该接口就不再是函数式接口进而导致编译失败。为了克服这种代码层面的脆弱性，并显式说明某个接口是函数式接口，Java 8 提供了一个特殊的注解@FunctionalInterface （Java 库中的所有相关接口都已经带有这个注解了），举个简单的函数式接口的定义：

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

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

@FunctionalInterface
public interface FunctionalDefaultMethods {
    void method();
    default void defaultMethod() {            
    }        
}

Lambda表达式作为Java 8的最大卖点，它有潜力吸引更多的开发者加入到JVM平台，并在纯Java编程中使用函数式编程的概念。如果你需要了解更多Lambda表达式的细节，可以参考官方文档。

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

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

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

private interface Defaulable {
    // Interfaces now allow default methods, the implementer may or 
    // may not implement (override) them.
    default String notRequired() { 
        return "Default implementation"; 
    }        
}
private static class DefaultableImpl implements Defaulable {
}
private static class OverridableImpl implements Defaulable {
    @Override
    public String notRequired() {
        return "Overridden implementation";
    }
}

Defaulable接口使用关键字default定义了一个默认方法notRequired()。DefaultableImpl类实现了这个接口，同时默认继承了这个接口中的默认方法；OverridableImpl类也实现了这个接口，但覆写了该接口的默认方法，并提供了一个不同的实现。

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

private interface DefaulableFactory {
    // Interfaces now allow static methods
    static Defaulable create( Supplier< Defaulable > supplier ) {
        return supplier.get();
    }
}

下面的代码片段整合了默认方法和静态方法的使用场景：

public static void main( String[] args ) {
    Defaulable defaulable = DefaulableFactory.create( DefaultableImpl::new );
    System.out.println( defaulable.notRequired() );
    defaulable = DefaulableFactory.create( OverridableImpl::new );
    System.out.println( defaulable.notRequired() );
}

这段代码的输出结果如下：

Default implementation
Overridden implementation

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

尽管默认方法有这么多好处，但在实际开发中应该谨慎使用：在复杂的继承体系中，默认方法可能引起歧义和编译错误。如果你想了解更多细节，可以参考官方文档。

方法引用

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

西门的例子中，Car类是不同方法引用的例子，可以帮助读者区分四种类型的方法引用。

public static class Car {
    public static Car create( final Supplier< Car > supplier ) {
        return supplier.get();
    }              
    public static void collide( final Car car ) {
        System.out.println( "Collided " + car.toString() );
    }
    public void follow( final Car another ) {
        System.out.println( "Following the " + another.toString() );
    }
    public void repair() {   
        System.out.println( "Repaired " + this.toString() );
    }
}

第一种方法引用的类型是构造器引用，语法是Class::new，或者更一般的形式：Class::new。注意：这个构造器没有参数。

final Car car = Car.create( Car::new );
final List< Car > cars = Arrays.asList( car );

第二种方法引用的类型是静态方法引用，语法是Class::static_method。注意：这个方法接受一个Car类型的参数。

cars.forEach( Car::collide );

第三种方法引用的类型是某个类的成员方法的引用，语法是Class::method，注意，这个方法没有定义入参：

cars.forEach( Car::repair );

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

final Car police = Car.create( Car::new );
cars.forEach( police::follow );

运行上述例子，可以在控制台看到如下输出（Car实例可能不同）：

Collided com.javacodegeeks.java8.method.references.MethodReferences$Car@7a81197d
Repaired com.javacodegeeks.java8.method.references.MethodReferences$Car@7a81197d
Following the com.javacodegeeks.java8.method.references.MethodReferences$Car@7a81197d

如果想了解和学习更详细的内容，可以参考官方文档

重复注解

自从Java 5中引入注解以来，这个特性开始变得非常流行，并在各个框架和项目中被广泛使用。不过，注解有一个很大的限制是：在同一个地方不能多次使用同一个注解。Java 8打破了这个限制，引入了重复注解的概念，允许在同一个地方多次使用同一个注解。

在Java 8中使用@Repeatable 注解定义重复注解，实际上，这并不是语言层面的改进，而是编译器做的一个trick，底层的技术仍然相同。可以利用下面的代码说明：

package com.javacodegeeks.java8.repeatable.annotations;
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注解注释（这里并没有提到任何关于Filters的信息）。

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

filter1
filter2

如果你希望了解更多内容，可以参考官方文档。

更好的类型推断

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

package com.javacodegeeks.java8.type.inference;
public class Value< T > {
    public static< T > T defaultValue() { 
        return null; 
    }
    public T getOrDefault( T value, T defaultValue ) {
        return ( value != null ) ? value : defaultValue;
    }
}

下列代码是Value类型的应用：

package com.javacodegeeks.java8.type.inference;
public class TypeInference {
    public static void main(String[] args) {
        final Value< String > value = new Value<>();
        value.getOrDefault( "22", Value.defaultValue() );
    }
}

参数Value.defaultValue()的类型由编译器推导得出，不需要显式指明。在Java 7中这段代码会有编译错误，除非使用Value.<String>defaultValue()。

拓宽注解的应用场景

Java 8拓宽了注解的应用场景。现在，注解几乎可以使用在任何元素上：局部变量、接口类型、超类和接口实现类，甚至可以用在函数的异常定义上。下面是一些例子：

package com.javacodegeeks.java8.annotations;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.util.ArrayList;
import java.util.Collection;
public class Annotations {
    @Retention( RetentionPolicy.RUNTIME )
    @Target( { ElementType.TYPE_USE, ElementType.TYPE_PARAMETER } )
    public @interface NonEmpty {        
    }
    public static class Holder< @NonEmpty T > extends @NonEmpty Object {
        public void method() throws @NonEmpty Exception {            
        }
    }
    @SuppressWarnings( "unused" )
    public static void main(String[] args) {
        final Holder< String > holder = new @NonEmpty Holder< String >();        
        @NonEmpty Collection< @NonEmpty String > strings = new ArrayList<>();        
    }
}

ElementType.TYPE_USER和ElementType.TYPE_PARAMETER是Java 8新增的两个注解，用于描述注解的使用场景。Java 语言也做了对应的改变，以识别这些新增的注解。

新的日期和时间API

java.time

通过local来表示一个国家或地区的日期、时间、数字、货币等格式

特点

• 严格区分日期、时间
• 不变类，类似String
• Month范围
• Week范围

LocalDateTime

        LocalDate d = LocalDate.now(); // 当前日期
        LocalTime t = LocalTime.now(); //当前时间
        LocalDateTime dt = LocalDateTime.now(); // 当前日期时间
        System.out.println(dt); // 严格按照ISO 8601格式打印 2020-07-05T16:38:37.356
        //指定日期和时间
        LocalDate d2 = LocalDate.of(2020, 7, 5); // 2020-07-05,注意 7=7月
        LocalTime t2 = LocalTime.of(16, 38, 37); // 16:38:37
        LocalDateTime dt2 = LocalDateTime.of(2020, 7, 5,16, 38, 37); // 2020-07-05T16:38:37
        LocalDateTime dt3 = LocalDateTime.of(d2, t2); // 2020-07-05T16:38:37
        //对日期进行格式化a
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        System.out.println(dtf.format(LocalDateTime.now())); // 2020-07-05 16:45:08
        //将字符串解析成日期
        LocalDateTime parse = LocalDateTime.parse("2020-07-05 16:45:08", dtf);
        System.out.println(parse); // 2020-07-05T16:45:08
        // +5 天
        LocalDate today = LocalDate.now();
        LocalDate after5Days = today.plusDays(5);
        System.out.println(after5Days); //2020-07-10
        // -2小时
        LocalTime now = LocalTime.now();
        LocalTime before2Hours = now.minusHours(2);
        System.out.println(before2Hours); // 14:59:22.526
        // +1月-2周
        LocalDate date = today.plusMonths(1).minusWeeks(2);
        System.out.println(date); // 2020-07-22
        //本月第一天
        LocalDate firstDay = LocalDate.now().withDayOfMonth(1);
        System.out.println(firstDay); // 2020-07-01
        //把秒和纳秒调整为0
        LocalTime at = LocalTime.now().withSecond(0).withNano(0);
        System.out.println(at); // 17:08
        //本月最后一天
        LocalDate lastDay = LocalDate.now().with(TemporalAdjusters.lastDayOfMonth());
        System.out.println(lastDay); // 2020-07-31
        //本月第一个周日
        LocalDate firstSunday = LocalDate.now().with(TemporalAdjusters.firstInMonth(DayOfWeek.SUNDAY));
        System.out.println(firstSunday); //2020-07-05
        LocalDate d01 = LocalDate.of(2020,7,5);
        LocalDate d02 = LocalDate.of(2020,7,4);
        System.out.println(d01.isBefore(d02)); // false
        System.out.println(d01.isAfter(d02)); // true
        LocalDate d03 = LocalDate.of(2020,7,5);
        LocalDate d04 = LocalDate.of(2018,3,28);
        //通过until()方法获取Period对象，判断两个日期相差？年？月？天
        Period period = d03.until(d04);
        System.out.println(period); // P-2Y-3M-8D 表示2020年7月5日到2018年3月28日中相差 2年3个月8天
        //两个日期一共相差多少天？
        long day01 = LocalDate.of(2020, 7, 5).toEpochDay();
        long day02 = LocalDate.of(2018,3,28).toEpochDay();
        System.out.println(day01-day02); // 830

ZonedDateTime

Stream API

Stream使用一种类似用SQL语句从数据库查询数据的直观方式来提供一种对java集合运算和表达的高阶抽象。这种风格将要处理的元素集合看作一种流，流在管道中传输，并且可以在管道的节点上进行处理，比如筛选、排序、聚合等。元素流在管道中进过中间操作的处理，最后又最终操作得到前面处理的结果。

注意

Stream自己不会存储元素

Stream不会改变源对象，相反，它们会返回一个持有结果的新Stream

Stream操作时延迟执行的，这意味着他们回等到需要结果的时候执行

步骤

创建Stream：一个数据源（如数组、集合等），获取一个流

    //创建Stream
    @Test
    public void test01(){
        //1.可以通过Collection系列集合提供的stream() 或 parallelStream()
        List<String> list = new ArrayList();
        Stream<String> stream01 = list.stream();
        //2、通过Arrays中的静态方法stream() 获取数组流
        Emp[] emps = new Emp[10];
        Stream<Emp> stream02 = Arrays.stream(emps);
        //3.通过Stream类中的静态方法of()
        Stream<String> stream03 = Stream.of("aa","bb","cc");
        //4.创建无限流
        //迭代
        Stream<Integer> stream04 = Stream.iterate(0,(x) -> x+2);
        stream04.forEach(System.out::println);
        //只要10个数据
        stream04.limit(10).forEach(System.out::println);
        //生成5个随机数
        Stream.generate(() -> Math.random()).limit(5).forEach(System.out::println);
    }

中间操作：一个中间操作链，对数据源的数据进行处理

多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理。而在终止操作时一次性全部处理，称为惰性求值
筛选与切片：
    filter，接收lambda，从流中排除某些元素
    limit，截断流，使其元素不超过给定数量
    skip(n)，跳过元素，返回一个扔掉了前n个元素的流，若六中元素不足n个，则返回一个空流，与limit(n)互补
    distinct，筛选，通过流所生成元素的hashcode()和equals()去重
映射：
    map，接收lambda，将元素转换为其他形式或提取信息（接收一个函数作为参数，该函数被应用到每个元素上，并将其映射成一个新的元素）
    flatMap，接收一个函数作为参数，将流中的每个值都换成另外一个流，然后把所有的流连凑成一个流
排序：
    sorted，自然排序
    sorted(Comparator comparator)，定制排序

下面通过代码来练习这些中间操作，先创建一个Employee实体类：

public class Employee {
    private String name;
    private Integer age;
    private Double salary;
    public Employee(String name, Integer age, Double salary) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public Double getSalary() {
        return salary;
    }
    public void setSalary(Double salary) {
        this.salary = salary;
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee employee = (Employee) o;
        return Objects.equals(name, employee.name) &&
                Objects.equals(age, employee.age) &&
                Objects.equals(salary, employee.salary);
    }
    @Override
    public int hashCode() {
        return Objects.hash(name, age, salary);
    }
    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", salary=" + salary +
                '}';
    }
}

测试中间操作filter的用法：

    List<Employee> emps = Arrays.asList(
            new Employee("张三",21,4500.00),
            new Employee("李四",25,6000.00),
            new Employee("王五",56,3500.00),
            new Employee("王五",56,3500.00),
            new Employee("田七",30,8000.00),
            new Employee("田七",30,8000.00)
    );
    @Test
    public void test02(){
        //中间操作：不会执行任何操作
        Stream<Employee> stream = employeeList.stream().filter(e -> e.getAge()>25);
        //终止操作:一次型执行全部内容，即”惰性求值“
        //内部迭代：迭代操作由Stream API 完成
        stream.forEach(System.out::println);
    }
    //外部迭代
    @Test
    public void test03(){
        Iterator<Employee> it = emps.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }

中间操作：limit —只要找到符合条件的指定条数数据，就不会执行后面的数据过滤操作了，可以提高效率

    @Test
    public void test04(){
        emps.stream().filter(e -> e.getSalary()>3000.00)
                .limit(2) //短路 : 只要找到符合条件的两条数据，就不会执行后面的数据过滤操作了，可以提高效率
                .forEach(System.out::println);
    }

中间操作：skip(n) ——跳过n个元素，返回一个扔掉了前n个元素的流，若流中元素不足n个，则返回一个空流，与limit(n)互补

    @Test
    public void test05(){
        emps.stream().filter(e -> e.getSalary()>3000.00)
                .skip(2)
                .forEach(System.out::println);
    }

中间操作： distinct —— 筛选，通过流所生成元素的hashCode() 和 equals() 去除重复元素

    @Test
    public void test06(){
        emps.stream().filter(e -> e.getSalary()>3000.00)
                .distinct ()
                .forEach(System.out::println);
    }

中间操作： map ——— 接受一个函数作为参数，该函数或被应用到每个元素上，并将其映射成一个新的元素

    @Test
    public void test07(){
        List<String> list = Arrays.asList("aaa","bbb","ccc","ddd","hello");
        list.stream()
                //toUpperCase()函数被应用到流中每个元素上，并将其映射成一个新的元素
                .map((str) -> str.toUpperCase())
                .forEach(System.out::println); //输出结果：AAA BBB CCC DDD HELLO
        System.out.println("------------------------------");
        emps.stream()
                .map(Employee::getName)
                .forEach(System.out::println);//输出结果：张三 李四 王五 王五 田七 田七
        System.out.println("------------------------------");
        Stream<Stream<Character>> stream01 = list.stream()
                //调用filterCharacter()，将流中的字符串元素都转为字符流，返回值类型为Stream<Stream<Character>>
                .map(StreamApiTest::filterCharacter);
        stream01.forEach((sm) -> {
            sm.forEach(System.out::println);
        });
        System.out.println("------------------------------");
    }
    //字符串转为字符流
    public static Stream<Character> filterCharacter(String str){
        List<Character> list = new ArrayList<>();
        for(Character ch : str.toCharArray()){
            list.add(ch);
        }
        return list.stream();
    }

中间操作： flatMap —- 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有的流连凑成一个流

    @Test
    public void test08(){
        List<String> list = Arrays.asList("aaa","bbb","ccc","ddd","hello");
        Stream<Character> stream02 = list.stream()
                //调用filterCharacter()，将流中的字符串元素都转为字符流，并将这些流加入到一个新流中，返回值类型为Stream<Character>
                .flatMap(StreamApiTest::filterCharacter);
        stream02.forEach(System.out::println);
    }

中间操作： sorted() —— 自然排序

    @Test
    public void test09(){
        List<String> list  = Arrays.asList("ccc","aaa","ddd","bbb","eee");
        list.stream().sorted().forEach(System.out::println);
    }

中间操作： sorted(Comparator comparator) ——— 定制排序（Comparator ）
自定义排序规则，这个根据员工年龄排序，若员工年龄相同，则根据员工姓名排序 —- 升序

    @Test
    public void test10(){
        emps.stream()
                .sorted((e1,e2) -> {
                    if(e1.getAge().equals(e2.getAge())){
                        return e1.getName().compareTo(e2.getName());
                    }else{
                        return e1.getAge().compareTo(e2.getAge());
                    }
                })
                .forEach(System.out::println);
    }

终止操作：一个终止操作，执行中间操作链，并产生结果

查找与匹配：
    allMatch,检查是否匹配所有元素
    anyMatch，检查是否至少匹配一个元素
    noneMatch，检查是否至少匹配一个元素
    findFirst，返回第一个元素
    findAny，返回流中的任意元素
    count，返回六中元素的总个数
    max，返回流中的最大值
    min，返回流中的最小值
归约：可以将流中元素反复结合起来，得到一个值
    reduce(T indentity,BinaryOperator bin)，indentity为起始值
    reduce(BinaryOperator bin)
收集：
collect，将流装换为其他形式，接收一个Collector接口的实现，用于给Stream中元素汇总的方法

终止操作练习：在此之前，我们先创建一个员工实体类，方便测试效果

public class Employee {
    private String name;
    private Integer age;
    private Double salary;
    private Status status;
    public Employee(String name, Integer age, Double salary) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }
    public Employee(String name, Integer age, Double salary, Status status) {
        this.name = name;
        this.age = age;
        this.salary = salary;
        this.status = status;
    }
    public Status getStatus() {
        return status;
    }
    public void setStatus(Status status) {
        this.status = status;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public Double getSalary() {
        return salary;
    }
    public void setSalary(Double salary) {
        this.salary = salary;
    }
    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", salary=" + salary +
                ", status=" + status +
                '}';
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Employee)) return false;
        Employee employee = (Employee) o;
        return Objects.equals(getName(), employee.getName()) &&
                Objects.equals(getAge(), employee.getAge()) &&
                Objects.equals(getSalary(), employee.getSalary()) &&
                getStatus() == employee.getStatus();
    }
    @Override
    public int hashCode() {
        return Objects.hash(getName(), getAge(), getSalary(), getStatus());
    }
    public enum Status{
        BUSY,FREE,VACATION;
    }
}

接下来我们先对 查找与匹配 中的几个终止操作进行代码测试：

    List<Employee> employees = Arrays.asList(
            new Employee("张三",21,4500.00, Employee.Status.BUSY),
            new Employee("李四",25,6000.00,Employee.Status.VACTION),
            new Employee("王五",56,3500.00,Employee.Status.BUSY),
            new Employee("王五",56,3500.00,Employee.Status.BUSY),
            new Employee("田七",30,8000.00,Employee.Status.FREE),
            new Employee("田七",30,8000.00,Employee.Status.FREE)
    );
    @Test
    public void test11(){
        //allMatch ----- 检查是否匹配所有元素
        boolean b1 = employees.stream().allMatch((e) -> e.getStatus().equals(Employee.Status.FREE));
        System.out.println(b1); //输出结果： false
        //anyMatch ------ 检查是否至少匹配一个元素
        boolean b2 = employees.stream().anyMatch((e) -> e.getStatus().equals(Employee.Status.BUSY));
        System.out.println(b2); //输出结果： true
        //noneMatch --------- 检查是否没有匹配所有元素
        boolean b3 = employees.stream().noneMatch((e) -> e.getStatus().equals(Employee.Status.BUSY));
        System.out.println(b3); //输出结果： false
        //findFirst ------- 返回第一个元素
        //Optional --- 是Java8 提供的处理空指针异常的类
        Optional<Employee> employee = employees.stream()
                //按员工的薪资排序
                .sorted((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()))
                //获取第一个员工信息，即薪资最新的员工信息
                .findFirst();
        System.out.println(employee.get());
        //findAny -------- 返回流中的任意元素
        //parallelStream --- 获取并行流
        Optional<Employee> any = employees.parallelStream()
                //获取状态为 FREE 的任意一个员工信息
                .filter(e -> e.getStatus().equals(Employee.Status.FREE))
                .findAny();
        System.out.println(any.get());
    }

测试终止操作中,count,max,min的运用

    @Test
    public void test12(){
        //返回流中元素的总个数
        long count = employees.stream().count();
        System.out.println(count); //输出结果为：6
        Optional<Employee> max = employees.stream().
                //获取年龄最大的员工信息
                max((e1, e2) -> Integer.compare(e1.getAge(), e2.getAge()));
        System.out.println(max.get()); // 输出结果为：Employee{name='王五', age=56, salary=3500.0, status=BUSY}
        Optional<Double> min = employees.stream()
                .map((e) -> e.getSalary())
                //获取最低的薪资
                .min(Double::compare);
        System.out.println(min.get());//输出结果为：3500.0
    }

终止操作：归约 —— reduce(T indentity,BinaryOperator) / reduce(BinaryOperator),可以将流中元素反复结合起来，得到一个值

    @Test
    public void test13(){
        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
        Integer reduce = list.stream()
                //0为初始值，将流中的元素按照 lambda体中的方式进行汇总，这里即是通过求和的方式汇总
                .reduce(0, (x, y) -> x + y);
        System.out.println(reduce); // 输出结果为：55
        Optional<Double> sum = employees.stream()
                //获取员工的薪资信息
                .map((e) -> e.getSalary())
                //调用Double的sum()，对员工薪资进行求和
                .reduce(Double::sum);
        System.out.println(sum.get()); //输出结果为：33500.0
    }

终止操作：收集：collect ———- 将流装换为其它形式，接收一个Collector 接口的实现，用于给Stream中元素汇总的方法

    @Test
    public void test14(){
        //Collectors工具类对Collector接口提供了很多实现
        List<String> list = employees.stream()
                .map(e -> e.getName())
                .collect(Collectors.toList());
        System.out.println(list);//输出结果为：[张三, 李四, 王五, 王五, 田七, 田七]
        Set<Integer> set = employees.stream()
                .map(e -> e.getAge())
                .collect(Collectors.toSet());
        System.out.println(set);//输出结果为：[21, 56, 25, 30]
        HashSet<String> hashSet = employees.stream()
                .map(e -> e.getName())
                .collect(Collectors.toCollection(HashSet::new));
        System.out.println(hashSet);//输出结果为：[李四, 张三, 王五, 田七]
    }

因为collect收集使用是很常见的，接下来我们通过使用collect进行统计、求平均值、总和、最大值、最小值，更加熟悉collect的使用，并了解工具类Collectors中常用的方法

    @Test
    public void test15(){
        //总数
        Long count = employees.stream()
                .collect(Collectors.counting());
        System.out.println(count); // 输出结果为：6
        //获取员工薪资的平均值
        Double avgSalary = employees.stream()
                .collect(Collectors.averagingDouble(Employee::getSalary));
        System.out.println(avgSalary);// 输出结果为：5583.333333333333
        //获取员工薪资的总和
        Double total = employees.stream()
                .collect(Collectors.summingDouble(Employee::getSalary));
        System.out.println(total); // 输出结果为：33500.0
        //获取最高薪资的员工信息
        Optional<Employee> maxSalary = employees.stream()
                .collect(Collectors.maxBy((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())));
        System.out.println(maxSalary.get()); //输出结果为：Employee{name='田七', age=30, salary=8000.0, status=FREE}
        //获取最低薪资的员工信息
        Optional<Employee> minSalary = employees.stream()
                .collect(Collectors.minBy((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())));
        System.out.println(minSalary.get()); //输出结果为：Employee{name='王五', age=56, salary=3500.0, status=BUSY}
    }

通过使用collect,对流中元素进行分组、多级分组、分区操作。

    @Test
    public void test16(){
        //通过员工状态进行分组
        Map<Employee.Status, List<Employee>> statusListMap = employees.stream()
                .collect(Collectors.groupingBy(Employee::getStatus));
        System.out.println(statusListMap);
    }
    /**
     * 多级分组
     */
    @Test
    public void test17(){
        //通过员工状态进行分组
        Map<Employee.Status, Map<String, List<Employee>>> map = employees.stream()
                .collect(Collectors.groupingBy(Employee::getStatus, Collectors.groupingBy(e -> {
                    if (e.getAge() < 30) {
                        return "青年";
                    } else if (e.getAge() < 50) {
                        return "中年";
                    } else {
                        return "老年";
                    }
                })));
        System.out.println(map);
    }
    /**
     * 分区
     */
    @Test
    public void test18(){
        Map<Boolean, List<Employee>> map = employees.stream()
                .collect(Collectors.partitioningBy(e -> e.getSalary() > 6000));
        System.out.println(map);
    }
    /**
     * 将流中的元素，按照指定格式连接
     */
    @Test
    public void test19(){
        String str = employees.stream()
                .map(e -> e.getName())
                .collect(Collectors.joining(","));
        System.out.println(str); //输出结果为： 张三,李四,王五,王五,田七,田七
    }

并行流与顺序流

并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。java8中将并行流进行了优化，可以很容易的对数据进行并行操作。Stream API可以声明性地通过Paralle()与Sequential()在并行流与顺序流之间进行切换

以下实例我们使用 parallelStream 来输出空字符串的数量：

    @Test
    public void test20(){
        List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
        // 获取空字符串的数量
        long count = strings.parallelStream().filter(string -> string.isEmpty()).count();
        System.out.println(count); //输出结果为：2
    }

应用

Java8中的Stream API可以极大提高我们的的生产力，让我们写出高效率、干净、简洁的代码。
例如：使用Java8来求两个集合的交集、差集、并集

    @Test
    public void test(){
        //准备两个集合
        List<String> list1 = new ArrayList<String>();
        list1.add("aa");
        list1.add("bb");
        list1.add("cc");
        list1.add("dd");
        list1.add("ee");
        List<String> list2 = new ArrayList<String>();
        list2.add("bb");
        list2.add("cc");
        list2.add("ff");
        list2.add("gg");
        // 交集
        List<String> intersection = list1.stream().filter(item -> list2.contains(item)).collect(toList());
        System.out.println("---交集 intersection---");
        intersection.parallelStream().forEach(System.out :: println);
        // 差集
        List<String> reduce = list2.stream().filter(item -> !list1.contains(item)).collect(toList());
        System.out.println("---差集 reduce2 (list2 - list1)---");
        reduce.parallelStream().forEach(System.out :: println);
        //并集
        list1.addAll(list2);
        List<String> collect = list1.stream().distinct().collect(toList());
        System.out.println("并集----去重");
        collect.stream().forEach(System.out::println);
    }

Java编译器的新特性

参数名称

为了在运行时获得Java程序中方法的参数名称，老一辈的Java程序员必须使用不同方法，例如Paranamer liberary。Java 8终于将这个特性规范化，在语言层面（使用反射API和Parameter.getName()方法）和字节码层面（使用新的javac编译器以及-parameters参数）提供支持。

package com.javacodegeeks.java8.parameter.names;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
public class ParameterNames {
    public static void main(String[] args) throws Exception {
        Method method = ParameterNames.class.getMethod( "main", String[].class );
        for( final Parameter parameter: method.getParameters() ) {
            System.out.println( "Parameter: " + parameter.getName() );
        }
    }
}

在Java 8中这个特性是默认关闭的，因此如果不带-parameters参数编译上述代码并运行，则会输出如下结果：

Parameter: arg0

如果带-parameters参数，则会输出如下结果（正确的结果）：

Parameter: args

如果你使用Maven进行项目管理，则可以在maven-compiler-plugin编译器的配置项中配置-parameters参数：

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.1</version>
    <configuration>
        <compilerArgument>-parameters</compilerArgument>
        <source>1.8</source>
        <target>1.8</target>
    </configuration>
</plugin>

动态代理和静态代理

动态代理

我们大家都知道微商代理，简单地说就是代替厂家卖商品，厂家“委托”代理为其销售商品。把微商代理和厂家进一步抽象，前者可抽象为代理类，后者可抽象为委托类(被代理类)
通过使用代理，通常有两个优点，并且能够分别与我们提到的微商代理的两个特点对应起来：优点一：可以隐藏委托类(工厂)的实现;——-(关于微商代理，首先我们从他们那里买东西时通常不知道背后的厂家究竟是谁，也就是说，“委托者”对我们来说是不可见的)优点二：可以实现客户与委托类间的解耦，在不修改委托类代码的情况下能够做一些额外的处理。

概念

代理类在程序运行时创建的代理方式被成为 动态代理。 也就是说，这种情况下，代理类并不是在Java代码中定义的，而是在运行时根据我们在Java代码中的“指示”动态生成的。相比于静态代理， 动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类的函数。

动态代理实现

使用 动态代理 来完成 执行委托类中的方法之前输出“before”，在执行完毕后输出“after”。
(1)InvocationHandler接口在使用动态代理时，我们需要定义一个位于代理类与委托类之间的中介类，这个中介类被要求实现InvocationHandler接口，这个接口的定义如下:

public interface InvocationHandler { 
Object invoke(Object proxy, Method method, Object[] args); 
}

从InvocationHandler这个名称我们就可以知道，实现了这个接口的中介类，用做“调用处理器”。当我们调用代理类对象的方法时，这个“调用”会转送到invoke方法中，代理类对象作为proxy参数传入，参数method标识了我们具体调用的是代理类的哪个方法，args为这个方法的参数。这样一来，我们对代理类中的所有方法的调用都会变为对invoke的调用，这样我们可以在invoke方法中添加统一的处理逻辑(也可以根据method参数对不同的代理类方法做不同的处理)。因此我们只需在中介类的invoke方法实现中输出“before”，然后调用委托类的invoke方法，再输出“after”。下面我们来一步一步具体实现它。
(2)委托类的定义动态代理方式下，要求委托类必须实现某个接口，这里我们实现的是Sell接口。委托类Vendor类的定义如下：

public class Vendor implements Sell 
{ 
    public void sell()
     { 
         System.out.println("In sell method"); 
    } 
    public void ad()
    { 
        System,out.println("ad method") 
    } 
}

(3)中介类上面我们提到过，中介类必须实现InvocationHandler接口，作为调用处理器”拦截“对代理类方法的调用。中介类的定义如下：

public class DynamicProxy implements InvocationHandler 
{ 
    private Object obj; //obj为委托类对象; 
    public DynamicProxy(Object obj) 
    { 
        this.obj = obj; 
    } 
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
     {   
        System.out.println("before"); 
//在invoke方法中添加统一的处理逻辑(也可以根据method参数对不同的代理类方法做不同的处理)
        Object result = method.invoke(obj, args); 
        System.out.println("after"); 
        return  result; 
    } 
}

从以上代码中我们可以看到，中介类持有一个委托类对象引用，在invoke方法中调用了委托类对象的相应方法(第11行)，看到这里是不是觉得似曾相识?通过聚合方式持有委托类对象引用，把外部对invoke的调用最终都转为对委托类对象的调用。这不就是我们上面介绍的静态代理的一种实现方式吗?实际上，中介类与委托类构成了静态代理关系，在这个关系中，中介类是代理类，委托类就是委托类; 代理类与中介类也构成一个静态代理关系，在这个关系中，中介类是委托类，代理类是代理类。也就是说，动态代理关系由两组静态代理关系组成，这就是动态代理的原理。下面我们来介绍一下如何”指示“以动态生成代理类。
(4)动态生成代理类动态生成代理类的相关代码如下：

public class Main { 
    public static void main(String[] args) 
    { 
        //创建中介类实例 
        DynamicProxy inter = new DynamicProxy(new Vendor()); 
        //加上这句将会产生一个$Proxy0.class文件，这个文件即为动态生成的代理类文件 
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true"); 
        //获取代理类实例sell 
        Sell sell = (Sell)(Proxy.newProxyInstance(Sell.class.getClassLoader(), new Class[] {Sell.class}, inter)); 
        //通过代理类对象调用代理类方法，实际上会转到invoke方法调用 
        sell.sell(); 
        sell.ad(); 
    }   
}

在以上代码中，我们调用Proxy类的newProxyInstance方法来获取一个代理类实例。这个代理类实现了我们指定的接口并且会把方法调用分发到指定的调用处理器。这个方法的声明如下

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException

方法的三个参数含义分别如下：loader：定义了代理类的ClassLoder;interfaces：代理类实现的接口列表h：调用处理器，也就是我们上面定义的实现了InvocationHandler接口的类实例我们运行一下，看看我们的动态代理是否能正常工作。我这里运行后的输出为：
说明我们的动态代理确实奏效了。上面我们已经简单提到过动态代理的原理，这里再简单的总结下：首先通过newProxyInstance方法获取代理类实例，而后我们便可以通过这个代理类实例调用代理类的方法，对代理类的方法的调用实际上都会调用中介类(调用处理器)的invoke方法，在invoke方法中我们调用委托类的相应方法，并且可以添加自己的处理逻辑。

JDK动态代理

a、定义一个接口Car：

public interface Car {
    void drive(String driverName, String carName);
}

b、定义接口Car的一个实现类Audi：

public class Audi implements Car {
    @Override
    public void drive(String driverName, String carName) {
        System.err.println("Audi is driving... " + "driverName: " + driverName + ", carName" + carName);
    }
}

c、定义一个动态调用的控制器CarHandler：

public class CarHandler implements InvocationHandler {
    private Car car;
    public CarHandler(Car car) {
        this.car = car;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.err.println("before");
        method.invoke(car, args);
        System.err.println("after");
        return null;
    }
}