您知道Java8有哪些新特性吗？

Java8新特性概览

​

• Lambda表达式
• 函数式接口
• 方法引用与构造器引用
• Stream API
• 接口的默认方法与静态方法
• 新时间日期API
• 其他新特性

最广泛的新特性是Lambda表达式和Stream API。

Java8优点

​

1. 什么是Lambda表达式？

Lambda表达式是一个匿名函数，使用Lambda表达式能够使Java的语言表达能力得到提升。

匿名内部类：

Comparator<Integer> com = new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) { 
        return Integer.compare(o1, o2); 
    }
};

在上述代码中，我们使用匿名内部类实现了比较两个Integer类型数据的大小。接下来，我们就可以将上述匿名内部类的实例作为参数，传递到其他方法中了，如下所示：

Comparator<Integer> com = new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) { 
        return Integer.compare(o1, o2); 
    }
};
TreeSet<Integer> treeSet = new TreeSet<>(com);

我们分析下上述代码，在整个匿名内部类中，实际上真正有用的就是下面一行代码。

return Integer.compare(o1, o2);

其他的代码本质上都是“冗余”的。但是为了书写上面的一行代码，我们不得不在匿名内部类中书写更多的代码。如果使用Lambda表达式完成两个Integer类型数据的比较，我们该如何实现呢？

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

看到没，使用Lambda表达式，我们只需要使用一行代码就能够实现两个Integer类型数据的比较。

我们也可以将Lambda表达式传递到TreeSet的构造方法中，如下所示。

TreeSet<Integer> treeSet = new treeSet<>((x,y) -> Integer.compare(x,y));

直观的感受就是使用Lambda表达式一行代码就能搞定匿名内部类多行代码的功能。

看到这，不少读者会问：我使用匿名内部类的方式实现比较两个整数类型的数据大小并不复杂啊！我为啥还要学习一种新的语法呢？

其实，我想说的是：上面咱们只是简单的列举了一个示例，接下来，咱们写一个稍微复杂一点的例子，来对比下使用匿名内部类与Lambda表达式哪种方式更加简洁。

对比常规方法和Lambda表达式

例如，现在有这样一个需求：获取当前公司中员工年龄大于30岁的员工信息。

首先，我们需要创建一个Employee实体类来存储员工的信息。

@Data
@Builder
@ToString
@NoArgsConstructor
@AllArgsConstructor
public class Employee implements Serializable {
    private static final long serialVersionUID = -9079722457749166858L;
    private String name;
    private Integer age;
    private Double salary;
}

在Employee中，我们简单存储了员工的姓名、年龄和薪资。接下来，我们创建一个存储多个员工的List集合，如下所示：

protected List<Employee> employees = Arrays.asList( 
new Employee("张三", 18, 9999.99), 
new Employee("李四", 38, 5555.55), 
new Employee("王五", 60, 6666.66), 
new Employee("赵六", 16, 7777.77), 
new Employee("田七", 18, 3333.33));

1）常规遍历集合

我们先使用常规遍历集合的方式来查找年龄大于等于30的员工信息。

public List<Employee> filterEmployeesByAge(List<Employee> list){
    List<Employee> employees = new ArrayList<>();
    for(Employee e : list) { 
        if(e.getAge() >= 30) { 
            employees.add(e); 
        }
    }
    return employees;
}

总体来说，查找年龄大于或者等于30的员工信息，使用常规遍历集合的方式稍显复杂了。

例如，需求发生了变化：获取当前公司中员工工资大于或者等于5000的员工信息。

此时，我们不得不再次创建一个按照工资过滤的方法。

public List<Employee> filterEmployeesBySalary(List<Employee> list) { 
    List<Employee> employees = new ArrayList<>();
    for(Employee e : list){
        if(e.getSalary() >= 5000){ 
            employees.add(e); 
        } 
    }
    return employees;
}

对比filterEmployeesByAge()方法和filterEmployeesBySalary方法后，我们发现，大部分的方法体是相同的，只是for循环中对于条件的判断不同。

如果此时我们再来一个需求，查找当前公司中年龄小于或者等于20的员工信息，那我们又要创建一个过滤方法了。看来使用常规方法是真的不方便啊！那么如何优化代码咧？

2）使用设计模式优化代码

我们先定义一个泛型接口 MyPredicate，对传递过来的数据进行过滤，符合规则返回true，不符合规则返回false。

public interface MyPredicate<T> {
    /*对传递过来的T类型的数据进行过滤/符合规则返回true/不符合规则返false*/
    booleanfilter(T t);
}

接下来，我们创建MyPredicate接口的实现类FilterEmployeeByAge来过滤年龄大于或者等于30的员工信息。

public class Filter EmployeeByAge implements MyPredicate<Employee {
    @Override
    public boolean filter(Employee employee) {
        return employee.getAge() >= 30; 
    }
}

我们定义一个过滤员工信息的方法，此时传递的参数不仅有员工的信息集合，同时还有一个我们定义的接口实例，在遍历员工集合时将符合过滤条件的员工信息返回。

public List<Employee> filterEmployee(List<Employee> list, MyPredicate<Employee> myPredicate){ 
    List<Employee> employees = new ArrayList<>();
    for(Employee e : list) {
        if(myPredicate.filter(e)){
            employees.add(e); 
        } 
    }
    return employees;
}

写到这里，大家是否有一种豁然开朗的感觉呢？

没错，这就是设计模式的魅力！

我们继续获取当前公司中工资大于或者等于5000的员工信息，此时，我们只需要创建一个FilterEmployeeBySalary类实现MyPredicate接口，如下所示：

public class FilterEmployeeBySalary implements MyPredicate<Employee>{
    @Override
    public boolean filter(Employee employee) {
        return employee.getSalary() >= 5000; 
    }
}

可以看到，使用设计模式对代码进行优化后，无论过滤员工信息的需求如何变化，我们只需要创建MyPredicate接口的实现类来实现具体的过滤逻辑，然后在测试方法中调用filterEmployee(List<Employee> list, MyPredicate<Employee> myPredicate)方法将员工集合和过滤规则传入即可。

​

使用设计模式优化代码也有不好的地方：每次定义一个过滤策略的时候，我们都要单独创建一个过滤类！！

那还有没有更加简化的方式呢？

4）重头戏：Lambda表达式

在使用Lambda表达式时，我们还是要调用之前写的filterEmployee(List<Employee> list, MyPredicate<Employee> myPredicate)方法。注意看，获取年龄大于或者等于30的员工信息。

@Test
public void test() { 
    filterEmployee(this.employees, (e) -> e.getAge() >=30)
.forEach(System.out::println);
}

看到没，使用Lambda表达式只需要一行代码就完成了员工信息的过滤和输出。是不是很6呢。

​

@Test
public void test() { 
    filterEmployee(this.employees, (e) -> e.getSalary() >= 5000)
    .forEach(System.out::println);
}

没错，使用Lambda表达式，又是一行代码就搞定了！！另外，使用Lambda表达式时，只需要给出需要过滤的集合，我们就能够实现从集合中过滤指定规则的元素，并输出结果信息。

5）重头戏：Stream API

使用Lambda表达式结合Stream API，只要给出相应的集合，我们就可以完成对集合的各种过滤并输出结果信息。例如，此时只要有一个employees集合，我们使用Lambda表达式来获取工资大于或者等于5000的员工信息。

@Test
public void test() { 
    employees.stream().filter((e) -> e.getSalary() >= 5000)
    .forEach(System.out::println);
}

没错，只给出一个集合，使用Lambda表达式和Stream API，一行代码就能够过滤出想要的元素并进行输出。

@Test
public void test(){ 
    employees.stream().filter((e) -> e.getSalary() >= 5000)
    .map(Employee::getName)
    .forEach(System.out::println);
}

可以看到，使用map过滤出了工资大于或者等于5000的员工姓名。

​

6）匿名类到Lambda表达式

我们先来看看从匿名类如何转换到Lambda表达式呢？

这里，我们可以使用两个示例来说明如何从匿名内部类转换为Lambda表达式。

匿名内部类到Lambda表达式使用匿名内部类如下所示。

Runnable r = new Runnable(){
    @Override 
    public void run() {     
        System.out.println("Hello Lambda"); 
    }
}

转化为Lambda表达式如下所示。

Runnable r = () -> System.out.println("Hello Lambda");
TreeSet<Integer> ts = new TreeSet<>( (o1, o2) -> Integer.compare(o1, o2););

从直观上看，Lambda表达式要比常规的语法简洁的多。

Lambda表达式的语法

Lambda表达式在Java语言中引入了 “->” 操作符， “->” 操作符被称为Lambda表达式的操作符或者箭头操作符，它将Lambda表达式分为两部分：

• 左侧部分指定了Lambda表达式需要的所有参数。Lambda表达式本质上是对接口的实现，Lambda表达式的参数列表本质上对应着接口中方法的参数列表。
• 右侧部分指定了Lambda体，即Lambda表达式要执行的功能。Lambda体本质上就是接口方法具体实现的功能。

我们可以将Lambda表达式的语法总结如下。

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

具体示例如下所示。

语法格式二：Lambda表达式需要一个参数，并且无返回值

具体示例如下所示。

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

具体示例如下所示。

@Test
public void test3() { 
    Consumer<String> consumer = x -> System.out.println(x); consumer.accept("Hello Lambda");

}

语法格式四：Lambda需要两个参数，并且有返回值

具体示例如下所示：

@Test
public void test4() { 
    Comparator<Integer> comparator = (x, y) -> { System.out.println("函数式接口");
    return Integer.compare(x, y); };
}

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

具体示例如下所示：

@Test
public void test5(){ 
    Comparator<Integer> comparator = (x, y) -> Integer.compare(x, y);
}

语法格式六：Lambda表达式的参数列表的数据类型可以省略不写，因为JVM编译器能够通过上下文推断出数据类型，这就是“类型推断”

BinaryOperator<Integer> bo = (Integer a, Integer b) -> {return a + b;};

等同于

BinaryOperator<Integer> bo = (a, b) -> {return a + b;};

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

待续～