java8新特性

1、对底层数据结构的改变，体现在诸如（hashmap，要写一篇专门的日志详解）
2、对底层的内存结构也变得不一样了，元空间metespace。原来的方法区
3、最为核心的是Lambda表达式与StreamAPI

Lambda

• lambda是一个匿名函数（方法），我们可以把lambda表达式理解为，一段可以传递的代码。

直观感受Lambda效果
Pojo类

public class Employee {
    private String name;
    private Integer age;
    private Double salary;
    public Employee(){
    }
    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 void setSalary(Double salary){
        this.salary = salary;
    }
    public Double getSalary(){
        return salary;
    }
    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", salary=" + salary +
                '}';
    }
}

List<Employee> employees = Arrays.asList(
            new Employee("张三",18,3318.44),
            new Employee("李四",15,2238.44),
            new Employee("王五",16,5627.44),
            new Employee("赵六",23,9274.44),
            new Employee("田七",54,8888.44)
    );

需求：//获取公司员工年龄大于35的员工信息
//获取当前公司中员工工资大于5000的员工信息

    //获取当前公司中员工工资大于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 test3(){
        List<Employee> emps = filterEmployees2(employees);
        for (Employee employee : emps){
            System.out.println(employee);
        }
    }
 //获取公司员工年龄大于35的员工信息
    public List<Employee> filterEmployees(List<Employee> list){
        List<Employee> emps = new ArrayList<>();
        for (Employee emp : list){
            if(emp.getAge() >20){
                emps.add(emp);
            }
        }
        return emps;
    }
    @Test
    public void test2(){
        List<Employee> emps = filterEmployees(employees);
        for (Employee employee : emps){
            System.out.println(employee);
        }
    }

优化方式一：策略设计模式+匿名内部类
设计接口：

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

实现需求：

    public List<Employee> filterEmployee(List<Employee> list,MyPredicate<Employee> mp){
        List<Employee> emps = new ArrayList<>();
        for (Employee emp : list){
            if(mp.test(emp)){
                emps.add(emp);
            }
        }
        return emps;
    }
 @Test
    public void test6(){
        List<Employee> emps =filterEmployee(employees, new MyPredicate<Employee>(){
            @Override
            public boolean test(Employee employee) {
                return employee.getAge()<20;
            }
        });
        for(Employee employee: emps){
            System.out.println(employee);
        }
    }
    @Test
    public void test7(){
        List<Employee> emps =filterEmployee(employees, new MyPredicate<Employee>(){
            @Override
            public boolean test(Employee employee) {
                return employee.getSalary()<5000;
            }
        });
        for(Employee employee: emps){
            System.out.println(employee);
        }
    }

优化方式二： Lambda表达式
将上述的匿名内部类写的更简洁。

    public List<Employee> filterEmployee(List<Employee> list,MyPredicate<Employee> mp){
        List<Employee> emps = new ArrayList<>();
        for (Employee emp : list){
            if(mp.test(emp)){
                emps.add(emp);
            }
        }
        return emps;
    } 
@Test
    public void test8(){
        List<Employee> emps = filterEmployee(employees,(e) -> e.getSalary() < 5000);
        emps.forEach(System.out::println);
    }

优化方式三：Stream API

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

Lambda表达式的语法

java8中引入了一个新的操作符“->”该操作符将Lambda表达式拆分为两部分。
左侧：Lambda表达式的参数列表
右侧：Lambda表达式中所需执行的功能，即Lambda体。
Lambda表达式需要“函数式接口”的支持。
函数式接口：接口中只有一个抽象方法。可以使用注解@FunctionalInterface修饰

语法格式一：无参数，无返回值
() -> System.out.println("Hello Lambda!");

    @Test
    public void test10(){
        int num = 99; //在jdk1.8以前，规则：在局部内部类中用了同级别的局部变量时，该变量必须被final修饰。
                        //jdk1.8之后，不需要手动final修饰了，自动final修饰。
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello World!" + num);
            }
        };
        r.run();
        System.out.println("------------");
        Runnable r1 = () -> System.out.println("Hello Lambda!" + num);
        r1.run();
    }

语法格式二：有一个参数，并且无返回值。
(x) -> System.out.println(x);

    @Test
    public void test11(){
        Consumer<String> con = (x) -> System.out.println(x);
        con.accept("朱柳洪牛逼");
    }

语法格式三：若只有一个参数，小括号可以省略不写
x -> System.out.println(x);

    @Test
    public void test12(){
        Consumer<String> con = x -> System.out.println(x);
        con.accept("朱柳洪牛逼");
    }

语法格式四：有两个及以上的参数，有返回值，并且Lambda体中有多条语句。

    @Test
    public void test13(){
        Comparator<Integer> comparator = (x, y) -> {
            System.out.println("朱柳洪牛逼");
            return Integer.compare(x,y); 
        };
    }

语法格式五：若Lambda体中只有一条语句，return和大括号都可以省略不写。

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

语法格式六：Lambda中的 参数列表的数据类型可以不写，因为JVM编译器通过上下文推断出数据类型，即“类型推断”。
Java8中有许多可以类型推断，而Java7中不可以的地方。