java8介绍

---

java 8可谓是java语言历史上变化最大的一个版本，其承诺要调整java编程向着函数式风格迈进，这有助于编写出更为简洁、表达力更强，并且在很多情况下能够利用并行硬件的代码。

Java8 的新特性主要有：Lambda表达式、 Stream API、全新时间日期 API、ConcurrentHashMap、MetaSpace。

java8新特性优点：速度更快，代码更少（增加了新的语法Lambda表达式），强大的Stream API，便于并行，最大化减少空指针异常Optional。其中最为核心的为Lambda表达式与Stream API

---

为什么使用Lambda表达式？

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

• 匿名内部类代码与Lambda表达式比较

/*
匿名内部类代码与Lambda表达式比较
*/
public class TestLambda {
    @Test
    //匿名内部类
    public void test1(){
        Comparator<Integer> com = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1,o2);
            }
        };
        TreeSet<Integer> ts = new TreeSet<>(com);
    }
   
    @Test
    //Lambda表达式
    public void test2(){
        Comparator<Integer> com = (x,y) -> Integer.compare(x, y);
        TreeSet<Integer> ts = new TreeSet<>(com);
    }
}

测试使用java8的好处

需求：我们要获取一定条件下的员工信息。

• 员工信息实体类

public class Employee {
    private String name;//姓名
    private int age ;//年龄
    private double salary;//工资

    public Employee() {
    }

    public Employee(String name, int 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 int getAge() {
        return age;
    }

    public void setAge(int 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 +
                '}';
    }
}

以前的方法获取需要的信息

import org.junit.Test;
import java.util.*;
public class TestLambda {
    //数组转集合实例化一系列员工
    List<Employee> employees = Arrays.asList(
            new Employee("张三",18,9999),
            new Employee("李四",36,5839),
            new Employee("王五",39,2899),
            new Employee("赵六",40,9392),
            new Employee("田七",50,5999)
    );
    //获取当前公司员工年龄大于35的员工信息
    public List<Employee> filterEmployees(List<Employee> list){
        List<Employee> emps = new ArrayList<>();
        for (Employee emp : list) {
            if (emp.getAge()>=35){
                emps.add(emp);
            }
        }
        return emps;
    }
    @Test
    public void test3(){
        List<Employee> list = filterEmployees(this.employees);
        for (Employee employee : list) {
            System.out.println(employee);
        }
    }

    //获取员工工资大于5000的员工信息
    public List<Employee> filterEmployees2(List<Employee> list){
        List<Employee> emps = new ArrayList<>();
        for (Employee emp : list) {
            if (emp.getSalary()>=5000){
                emps.add(emp);
            }
        }
        return emps;
    }
    @Test
    public void test4(){
        List<Employee> list = filterEmployees2(this.employees);
        for (Employee employee : list) {
            System.out.println(employee);
        }
    }
}

通过上述代码我们可以发现：我们只改了不同的条件，而大部分代码相似，只是条件不一样。

我们可以将相同的代码提取出来。

优化一：策略设计模式

将相同的步骤抽象成接口，然后实行接口的形式。

public interface MyPredicate<T> {
    public boolean test(T t);
}

• 通过年龄过滤员工信息

public class FilterEmployeeByAge implements MyPredicate<Employee>{
    @Override
    public boolean test(Employee employee) {
        return employee.getAge()>=35;
    }
}

• 通过工资过滤员工信息

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

• 测试类

//优化方式一:策略设计模式
public List<Employee> filterEmployee(List<Employee> list,MyPredicate<Employee> mp){
    List<Employee> emps = new ArrayList<>();
    for (Employee employee : list) {
        if (mp.test(employee)){
            emps.add(employee);
        }
    }
    return emps;
}
@Test
public void test5(){
    List<Employee> list = filterEmployee(employees, new FilterEmployeeByAge());
    for (Employee employee : list) {
        System.out.println(employee);
    }
    System.out.println("---------------------");
    List<Employee> list2 = filterEmployee(employees, new FilterEmployeeBySalary());
    for (Employee employee : list2) {
        System.out.println(employee);
    }
}

优化二：匿名内部类

也需要MyPredicate接口。

//优化方式二：匿名内部类
@Test
public void test6(){
    List<Employee> list = filterEmployee(employees, new MyPredicate<Employee>() {
        @Override
        public boolean test(Employee employee) {
            return employee.getAge() >= 35;
        }
    });
    for (Employee employee : list) {
        System.out.println(employee);
    }
}

优化方式三：Lambda表达式

//优化方式三：Lambda表达式
@Test
public void test7(){
    List<Employee> list = filterEmployee(employees, (e) -> e.getAge() >= 35);
    list.forEach(System.out::println);
}

优化方式四:Stream API

//优化方式四:Stream API
@Test
public void test8(){
    employees.stream()
            .filter((e)->e.getAge()>=35)
            .forEach(System.out::println);
}

所以，使用java8的新特性来处理问题，可以写出更简洁、更灵活的代码。