Java8新特性

主要内容

1. Lambda表达式

2. 函数式接口

3. 方法引用与构造器引用

4. Stream API

5. 接口中的默认方法 与静态方法

6. 新时间日期API

7. 其他新特性

Java8新特性简介

• 速度更快

  • 底层数据结构 :

    • hash表的改进从数组-链表结构 -> 数组-链表-红黑树，

    • ConcurrentHashMap底层变成CAS算法

  • 底层内存结构

    • 把永久区和方法区合并成元空间

• 代码更少（增加了新的语法Lambda表达式）

• 强大的StreamAPI

• 便于并行

• 最大化减少空指针异常 Optional

Lambda表达式

需求：根据员工的 工资/年龄 来选择输出员工信息

//创建一个员工类
public class Employee {
private String name;
private int age;
private double sarlary;

public Employee() {
    super();
}

public Employee(String name, int age, double sarlary) {
    super();
    this.name = name;
    this.age = age;
    this.sarlary = sarlary;
}
// 这里省略所有的get and set的封装 ~~~
}

//根据需求写业务代码
public class Lambda01 {
    //创建一个列表，往里边添加内容
    List<Employee> emplpoyees = Arrays.asList(
            new Employee("张三",23,888.88),
            new Employee("张四",33,988.88),
            new Employee("张吴",43,9988.88),
            new Employee("张六",53,8998.88)
            );
    //根据年龄判断
    public List<Employee> filterEmpByAge(List<Employee> list){
        List<Employee> emps = new ArrayList<>();
        for (Employee employee : list) {
            if(employee.getAge()>=35) {
                emps.add(employee);
            }
        }
        return emps; 
    }

        //测试一个员工的年龄大于35岁的方法
    @Test
    public void test1() {
        List<Employee> filterEmp = filterEmpByAge(emplpoyees);
        for (Employee employee : filterEmp) {
            System.out.println(employee);
        }
    }
    /**
     * test1()测试输入结果：
            Employee [name=张吴, age=43, sarlary=9988.88]
            Employee [name=张六, age=53, sarlary=8998.88]
     */

优化一：策略设计模式

//第一步：创建一个接口：
public interface MyPredicate<T> {
  public boolean test(T t);
}

//第二步：创建一个根据年龄判断员工的实现类：
public class FiltyerByAge implements MyPredicate<Employee>{  
  @Override
  public boolean test(Employee t) {
    // TODO Auto-generated method stub
    return t.getAge()>=35;
  }
}

//第三步：编写策略方法
public List<Employee> filterEmpee(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 test2() {
    List<Employee> filterEmp = filterEmpee(emplpoyees,new FiltyerByAge());
    for (Employee employee : filterEmp) {
        System.out.println("—————————————优化一根据年龄———————————————："+employee);
    }
}

//第五步：根据工资判断创建工资类
public class FilterBySalary implements MyPredicate<Employee>{
    @Override
    public boolean test(Employee t) {
        return t.getSarlary()<=1000;
    }
}

//第六步：测试优化一>>>>>>工资判断
@Test
public void test3() {
    List<Employee> filterEmp = filterEmpee(emplpoyees,new FilterBySalary());

    for (Employee employee : filterEmp) {
        System.out.println("—————————————优化一根据工资———————————————："+employee);
    }
}

@Test
public void test4() {
    List<Employee> filterEmpAge = filterEmpee(emplpoyees,new MyPredicate<Employee>() {
        @Override
        public boolean test(Employee t) {
            return t.getAge()<=40;//使用了匿名内部类之后根据年龄/工资，只需要修改这里即可（不用再创建太多相关的实现类）
        }
    });
    for (Employee employee : filterEmpAge) {
        System.out.println("—————————————优化二》》匿名内部类———————————————："+employee);
    }
}

优化三：lambda表达式

@Test
public void test5() {//整个逻辑写下来，代码非常简洁（这就是lambda魅力所在）
    List<Employee> filterEmpee = filterEmpee(emplpoyees,(e) -> e.getSarlary() >=5000);
    filterEmpee.forEach(System.out::println);
}

下面还有最终优化版本：---------------优化方式四：Stream API

@Test
public void test6() {//这里什么方法都没有调用，单单只用了stream就对员工进行了判断！
    emplpoyees.stream().filter((e)->e.getSarlary()
            >=5000).forEach(System.out::println);
}