java8—lambda表達式（一）

<1.初識lambda表達式>

  需求1：擷取目前公司中目前員工年齡大于35的員工資訊

/**
 * 定義一個員工角色類
 */
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 void setName(String name){
   this.name = name;
}   
   public String getName(){
   return name;
}
   public void setAge(int age){
   this.age = age;
}
   public int getAge(){
   return age;
}
   public void setSalary(double salary){
   this.salary = salary;
}
   public double getSalary(){
   return salary;
}
} 
           

//引入junit Test測試工具類
import org.junit.Test
public class Test{
   //初始化員工資訊
   List<Employee> emps = Arrays.asList(new Employee("Kiven",24,10000),new Employee("Nick",40,39999),new Employee("Lily",25,8000));
   @Test
   public void test1(){
   List<Employee> newEmps = filterEmployees(emps);
   for(Employee employee:newEmps){
   System.out.println(employee);
}
}
   private List<Employee> filterEmployees(List<Employee> emps){
   List<Employee> list = new ArrayList<>();
   for(Employee emp : list){
      if(emp.getAge()>35){
       list.add(emp);
}
    return emps;
}
}
           

需求2：擷取目前公司中員工薪水大于5000的員工

//引入junit Test測試工具類
import org.junit.Test
public class Test{
   //初始化員工資訊
   List<Employee> emps = Arrays.asList(new Employee("Kiven",24,10000),new Employee("Nick",40,39999),new Employee("Lily",25,8000));
   @Test
   public void test1(){
   List<Employee> newEmps = filterEmployees(emps);
   for(Employee employee:newEmps){
   System.out.println(employee);
}
}
   private List<Employee> filterEmployees(List<Employee> emps){
   List<Employee> list = new ArrayList<>();
   for(Employee emp : list){
      if(emp.getSalary()>5000){    //相比需求1的實作隻改變了一行代碼
       list.add(emp);
}
    return emps;
}
}
           

優化方式1：政策模式，定義一系列算法，将每個算法單獨封裝，使之可以互相替換，具體方法政策的選擇由用戶端決定。

/**
 * 定義一個條件判斷接口
 */
public interface MyPredicate<T>{
   boolean test(T t);
}
           

/**
 * 條件接口的具體實作-根據年齡過濾
 */
public class FilterEmployeeByAge{
  @Override 
  public boolean test(Employee e){
     return e.getAge >35;
}
}
           

/**
 * 條件接口的具體實作-根據薪水過濾
 */
public class FilterEmployeeBySalary{
  @Override 
  public boolean test(Employee e){
     return e.getSalary>5000;
}
}
           

//引入junit Test測試工具類
import org.junit.Test
public class Test{
   //初始化員工資訊
   List<Employee> emps = Arrays.asList(new Employee("Kiven",24,10000),new Employee("Nick",40,39999),new Employee("Lily",25,8000));
   @Test
   public void test1(){
   List<Employee> newEmps = filterEmployees(emps,new FilterEmployeeByAge());  //适應各種判斷條件，而不需要改變filterEmployees()方法，政策模式
   for(Employee employee:newEmps){
   System.out.println(employee);
}
}
   private List<Employee> filterEmployees(List<Employee> emps,MyPredicate<T> mp){ //新增一個MyPredicat類型的參數
   List<Employee> list = new ArrayList<>();
   for(Employee emp : list){
      if(mp.test(emp)){
       list.add(emp);
}
    return emps;
}
}
           

優化方式2：匿名内部類，需要MyPredicate接口的具體實作，通過匿名内部類實作具體的操作

/**
 * 定義一個條件判斷接口
 */
public interface MyPredicate<T>{
   boolean test(T t);
}                定義一個條件判斷接口
 */
public interface MyPredicate<T>{
   boolean test(T t);
}      

//引入junit Test測試工具類
import org.junit.Test
public class Test{
   //初始化員工資訊
   List<Employee> emps = Arrays.asList(new Employee("Kiven",24,10000),new Employee("Nick",40,39999),new Employee("Lily",25,8000));
   @Test
   public void test1(){
   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);
     }
}
   private List<Employee> filterEmployees(List<Employee> emps,MyPredicate<T> mp){ //新增一個MyPredicat類型的參數
   List<Employee> list = new ArrayList<>();
   for(Employee emp : list){
      if(mp.test(emp)){
       list.add(emp);
}
    return emps;
}
}
           

優化方式3：lambda表達式

/**
 * 定義一個條件判斷接口
 */
public interface MyPredicate<T>{
   boolean test(T t);
}
           

//引入junit Test測試工具類
import org.junit.Test
public class Test{
   //初始化員工資訊
   List<Employee> emps = Arrays.asList(new Employee("Kiven",24,10000),new Employee("Nick",40,39999),new Employee("Lily",25,8000));
   @Test
   public void test1(){
   List<Employee> list = filterEmployee(employees, employee -> employee.getSalary() >= 5000); //lambda表達式
   list.forEach(System.out::println);
}
}
   private List<Employee> filterEmployees(List<Employee> emps,MyPredicate<T> mp){ //新增一個MyPredicat類型的參數
   List<Employee> list = new ArrayList<>();
   for(Employee emp : list){
      if(mp.test(emp)){
       list.add(emp);
}
    return emps;
}
}
           

優化方式4：streamApi

//引入junit Test測試工具類
import org.junit.Test
public class Test{
   public void test(){
   //streamApi 一步到位~
   emps.stream().filter(e->e.getSalary)>-5000).forEach(System.out::println);
}
}
}
           

<2.lambda表達式基礎文法>：Java8中引入一個新的操作符 “->”，該操作符稱為箭頭操作符或lambda操作符

     箭頭操作符将lambda表達式拆分成兩部分：

            左側：lambda表達式的參數清單

            右側：lambda表達式所需要執行的功能，即lambda體

①文法格式1：無參數，無傳回值

()->System.out.println("hello lambda!");
           

②文法格式2：有一個參數，無傳回值 

Consumer c = x -> System.out.println(x);
c.accept("hello");
           

③文法格式3：有兩個以上的的參數，并且lambda體中有多條語句

Comparator<Integer> com = (x,y) -> {
   System.out.println("函數式接口");
   return Integer.compare(x,y);
};
System.out.println(com.compare(2,2));
           

備注：

*左側若隻有一個參數，小括号可以不寫

*若lambda體中隻有一條語句，return 和 大括号都可以不寫

*lambda表達式參數清單的參數類型省略不寫，JVM編譯器可以通過上下文推斷出類型，即“類型推斷”