java8新特性_02_为什么要用Lambda表达式

匿名内部类

@Test
public void test01(){
    //匿名内部类
    Comparator<Integer> comparator = new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            return Integer.compare(o1,o2);
        }

        @Override
        public boolean equals(Object obj) {
            return false;
        }
    };
    //调用
    TreeSet<Integer> set = new TreeSet<>(comparator);
}

Lambda

@Test
public void test02(){
    // Lambda 表达式
    Comparator<Integer> comparator = (a, b) -> Integer.compare(a, b);

    TreeSet<Integer> set = new TreeSet<>(comparator);
}

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

//创建一个员工类
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 List<Employee> filterEmpSalary(List<Employee> emps){
        List<Employee> result = new ArrayList<>();
        for (Employee emp:emps){
            if(emp.getSalary()>=1000)result.add(emp);
        }
        return result;
    }
    @Test
    public void test04(){
        List<Employee> employees = filterEmpSalary(emplpoyees);
        for (Employee emp:employees
        ) {
            System.out.println(emp);
        }
    }

    ***按年龄过滤的方法和按工资过滤的方法本质上只有一行代码的区别
    ***if(employee.getAge()>=35)
    ***if(emp.getSalary()>=1000)
    ***代码优化的最好方式，就是设计模式
	
      
  //优化一：策略设计模式
    //第一步：创建一个接口：
    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表达式写法------------优化方式三：lambda表达式
    
    //优化三：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).limit(2).forEach(System.out::println); 
            
            System.out.println("================================");

            emplpoyees.stream().map(Employee::getName).forEach(System.out::println);
		}
}