一.java8的主要内容：

二.Lambda表达式

1.为什么使用Lambda表达式？

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

三.举例说明

实例：原来的匿名内部类

//原来的匿名内部类
	@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);
	}

Lambda表达式:

//Lambda表达式 //将核心提取出来
	@Test
	public void test2(){
		Comparator<Integer> com = (x,y) -> Integer.compare(x, y);
		TreeSet<Integer> ts = new TreeSet<>(com);
	}

有没有觉得使用Lambda表达式后，代码简洁了许多
这里再举一个例子：
现有需求：

获取公司中员工年龄大于35的员工信息

作法：
1.定义Employee实体类

package example2;

public class Employee {
	private String name;
	private int age;
	private double 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;
	}
	public Employee(String name, int age, double salary) {
		super();
		this.name = name;
		this.age = age;
		this.salary = salary;
	}
	public Employee() {
		super();
	}
	@Override
	public String toString() {
		return "Employee [name=" + name + ", age=" + age + ", salary=" + salary + "]";
	}
}

传统作法：循环比较

public List<Employee> findEmployees(List<Employee> list) {
		List<Employee> emps = new ArrayList<>();
		for (Employee employee : list) {
			if(employee.getAge() >= 35){
				emps.add(employee);
			}
		}
		return emps;
	}

测试：

List<Employee> employees = Arrays.asList(
			new Employee("张三",18,9999.9),
			new Employee("李四",20,555.5),
			new Employee("王五",35,888.8),
			new Employee("田七",40,333.33)
		);
	@Test
	public void test3(){
		List<Employee> list = findEmployees(employees);
		for (Employee employee : list) {
			System.out.println(employee);
		}
	}	

结果：

需求2：

获取公司中员工年龄大于35的员工信息

传统作法：

public List<Employee> findEmployee2(List<Employee> list){
		List<Employee> emps = new ArrayList<>();
		for (Employee employee : list) {
			if(employee.getSalary() >= 5000){
				emps.add(employee);
			}
		}
		return emps;
	}

有没有发现与上一个需求比较虽然需求改变了，但是产生了很多的重复代码
我们需要优化

优化1：使用策略设计模式
定义接口MyPredicate

package example2;
/**
 * 接口
 * @author Administrator
 *
 */
public interface MyPredicate<T> {
	public boolean test(Employee employee);
}

实现类：FilterEmployeeByAge

package example2;

public class FilterEmployeeByAge implements MyPredicate<Employee>{

	@Override
	public boolean test(Employee employee) {
		return employee.getAge() >= 35;
	}
}

实现类：FilterEmployeeBySalary

package example2;

public class FilterEmployeeBySalary  implements MyPredicate<Employee>{

	@Override
	public boolean test(Employee employee) {
		return employee.getSalary() >= 5000;
	}
}

测试：

@Test
	public void test4(){
		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);
		}
	}

这里定义一个相同接口，只需在实现类中编写业务代码，大大简化了代码量

优化方式2：匿名内部类

@Test
	public void test5(){
		List<Employee> list = filterEmployee(employees, new MyPredicate<Employee>() {
			//过滤
			@Override
			public boolean test(Employee employee) {
				return employee.getSalary()<= 5000;
			}
		});
		for (Employee employee : list) {
			System.out.println(employee);
		}
	}

使用匿名内部类，进行过滤 思想上实际等同与上一种方法，都是改变方法的实现

优化方式3,使用Lambda表达式

@Test
	public void test6(){
		List<Employee> list = filterEmployee(employees,(e) -> e.getSalary() <= 5000);
		for (Employee employee : list) {
			System.out.println(employee);
		}
		System.out.println("********");
		list.forEach(System.out::println);
	}

结果：

可以看到for循环在Lambda表达式中只用一行代码list.forEach(System.out::println);就可以表示，这就是Lambda的方便之处

优化方式四  stream API
//输出工资大于5000的，还有所有人的姓名

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

结果：

总结.java8新特性简介：

1.速度更快，改变内存结构
2.代码更少（增加了新得语法Lambda表达式）
3.强大的Stream API
4.便于并行
5.最大化减少空指针异常 Optional