亚洲激情专区-91九色丨porny丨老师-久久久久久久女国产乱让韩-国产精品午夜小视频观看

溫馨提示×

溫馨提示×

您好，登錄后才能下訂單哦！

密碼登錄×
登錄注冊×
其他方式登錄
點擊 登錄注冊 即表示同意《億速云用戶服務條款》

jdk1.8為什么使用lambda表達式

發布時間：2021-08-25 10:47:06 來源：億速云 閱讀：136 作者：chen 欄目：開發技術

本篇內容主要講解“jdk1.8為什么使用lambda表達式”，感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷，實用性強。下面就讓小編來帶大家學習“jdk1.8為什么使用lambda表達式”吧!

目錄

  • 一、為什么使用Lambda表達式

  • 二、匿名內部類的方式與Lambda表達式方式的比較（示例）

  • 三、需求演示示例

    • 一、創建一個員工實體類

    • 二、普通方式實現

      • 1、代碼如下

      • 2、運行main函數，輸出結果如下圖：

      • 3、 普通方式實現的缺點

    • 三、優化方式一（策略模式實現）

      • 1、定義一個策略接口

      • 2、定義一個過濾年齡的接口實現類

      • 3、定義一個過濾薪資的接口實現類

      • 4、測試類如下：

      • 5、運行main函數，輸出如下:

      • 6、 策略模式實現的缺點

    • 四、優化方式二（匿名內部類實現）

      • 1、定義一個策略接口

      • 2、測試類如下：

      • 3、運行main函數，輸出如下:

    • 五、優化方式三（Lambda實現）

      • 1、定義一個策略接口

      • 2、測試類如下：

      • 3、運行main函數，輸出如下:

    • 六、優化方式四（Stream API和Lambda表達式實現）

      • 1、代碼如下：

      • 2、運行main函數，輸出結果如下：


一、為什么使用Lambda表達式

Lambda是一個匿名函數，我們可以把Lambda表達式理解為是一段可以傳遞的代碼（將代碼像數據一樣進行傳遞）。可以寫出更簡潔、更靈活的代碼。作為一種更緊湊的代碼風格，使java的語言表達能力得到了提升。

二、匿名內部類的方式與Lambda表達式方式的比較（示例）

場景：比較2個數，一種采用內部類的方式，一種采用lambda表達式的方式；如下圖：

jdk1.8為什么使用lambda表達式

三、需求演示示例

場景演示：獲取員工年齡小于35的員工信息，然后再獲取員工工資大于5000的員工信息。

一、創建一個員工實體類

package com.xz.springboot_java8.day1.entity;
/**
 * @description:
 * @author: xz
 * @create: 2021-08-23 21:07
 */
public class Employee {
    private int id;//id
    private String name;//名稱
    private int age;//年齡
    private Double salary; //薪水
		//無參構造方法
    public Employee() { }
		//帶參構造方法
    public Employee(int id, String name, int age, Double salary) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.salary = salary;
    }
	 //getter、setter、及toString方法此處省略
	 ........
}

二、普通方式實現

1、代碼如下
package com.xz.springboot_java8.day1.test;
import com.xz.springboot_java8.day1.entity.Employee;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
 * @description:普通方式實現
 *              員工年齡小于35的員工信息和員工工資大于5000的員工信息。
 *              
 * @author: xz
 * @create: 2021-08-23 21:10
 */
public class Test1 {
    public static void main(String[] args) {
        //初始化員工數據并轉成list
        List<Employee> emps = Arrays.asList(
                new Employee(1, "張三", 18, 2222.22),
                new Employee(2, "李四", 25, 3333.33),
                new Employee(3, "王五", 38, 5555.55),
                new Employee(4, "趙六", 45, 8888.88)
        );
        //調用年齡小于35的員工信息方法
        List<Employee> list = filterEmployeeAge(emps);
        for (Employee employee : list) {
            System.out.println(employee);
        }
        System.out.println("============================");
        //調用工資大于5000的員工信息方法
        List<Employee> list1 = filterEmployeeSalary(emps);
        for (Employee employee : list1) {
            System.out.println(employee);
        }
    }
    /**
     * 獲取公司中年齡小于 35 的員工信息
     * @param emps
     * @return
     */
    public static List<Employee> filterEmployeeAge(List<Employee> emps){
        List<Employee> list = new ArrayList<>();
        for (Employee emp : emps) {
            if(emp.getAge() <= 35){
                list.add(emp);
            }
        }
        return list;
    }
    /**
     * 獲取公司中工資大于 5000 的員工信息
     * @param emps
     * @return
     */
    public static List<Employee> filterEmployeeSalary(List<Employee> emps){
        List<Employee> list = new ArrayList<>();
        for (Employee emp : emps) {
            if(emp.getSalary() >= 5000){
                list.add(emp);
            }
        }
        return list;
    }
}
2、運行main函數，輸出結果如下圖：

jdk1.8為什么使用lambda表達式

3、 普通方式實現的缺點

每新增一個新的需求就要重新寫一個方法，方法中只有判斷邏輯部分不同，其他都相同，出現代碼冗余。如下圖：

jdk1.8為什么使用lambda表達式

三、優化方式一（策略模式實現）

1、定義一個策略接口
package com.xz.springboot_java8.day1.test2;
/**
 * 定義一個策略接口
 */
public interface MyStrategy<T> {
    //該方法默認為public abstract修飾
    public abstract boolean getEmployeeInfo(T t);
}
2、定義一個過濾年齡的接口實現類
package com.xz.springboot_java8.day1.test2;
import com.xz.springboot_java8.day1.entity.Employee;
/**
 * @description: 定義一個過濾年齡的接口實現類
 * @author: xz
 * @create: 2021-08-23 21:24
 */
public class FilterEmployeeAge implements MyStrategy<Employee>{
    @Override
    public boolean getEmployeeInfo(Employee employee) {
        return employee.getAge() <= 35;
    }
}
3、定義一個過濾薪資的接口實現類
package com.xz.springboot_java8.day1.test2;
import com.xz.springboot_java8.day1.entity.Employee;
/**
 * @description:  定義一個過濾薪資的接口實現類
 * @author: xz
 * @create: 2021-08-23 21:35
 */
public class FilterEmployeeSalary implements MyStrategy<Employee>{
    @Override
    public boolean getEmployeeInfo(Employee employee) {
        return employee.getSalary() >= 5000;
    }
}
4、測試類如下：
package com.xz.springboot_java8.day1.test2;
import com.xz.springboot_java8.day1.entity.Employee;
import java.util.*;
/**
 * @description: 策略模式實現
 *               員工年齡小于35的員工信息和員工工資大于5000的員工信息。
 * @author: xz
 * @create: 2021-08-23 11:21
 */
public class test {
    public static void main(String[] args) {
        //初始化員工數據并轉成list
        List<Employee> emps = Arrays.asList(
                new Employee(1, "張三", 18, 2222.22),
                new Employee(2, "李四", 25, 3333.33),
                new Employee(3, "王五", 38, 5555.55),
                new Employee(4, "趙六", 45, 8888.88)
        );
        //調用年齡小于35的員工信息方法
        List<Employee> list = getEmployee(emps,new FilterEmployeeAge());
        for (Employee employee : list) {
            System.out.println(employee);
        }
        System.out.println("------------------------");
        //調用調用工資大于5000的員工信息方法
        List<Employee> list1 = getEmployee(emps,new FilterEmployeeSalary());
        for (Employee employee : list1) {
            System.out.println(employee);
        }
    }
    /**
     * @param list 需要傳入員工信息
     * @param strategy 需要傳入具體策略
     */
    public static List<Employee> getEmployee(List<Employee> list,MyStrategy<Employee> strategy){
        List<Employee> empList = new ArrayList<>();
        for(Employee emp:list){
            if(strategy.getEmployeeInfo(emp)){
                empList.add(emp);
            }
        }
        return empList;
    }
}
5、運行main函數，輸出如下:

jdk1.8為什么使用lambda表達式

6、 策略模式實現的缺點

每新增一個新的需求就要重新寫一個實現策略接口的實現類，類圖如下:

jdk1.8為什么使用lambda表達式

四、優化方式二（匿名內部類實現）

1、定義一個策略接口
package com.xz.springboot_java8.day1.test2;
/**
 * 定義一個策略接口
 */
public interface MyStrategy<T> {
    //該方法默認為public abstract修飾
    public abstract boolean getEmployeeInfo(T t);
}
2、測試類如下：
package com.xz.springboot_java8.day1.test3;
import com.xz.springboot_java8.day1.entity.Employee;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
 * @description: 匿名內部類實現
 *               員工年齡小于35的員工信息和員工工資大于5000的員工信息。
 * @author: xz
 * @create: 2021-08-23 21:58
 */
public class Test {
    public static void main(String[] args) {
        //初始化員工數據并轉成list
        List<Employee> emps = Arrays.asList(
                new Employee(1, "張三", 18, 2222.22),
                new Employee(2, "李四", 25, 3333.33),
                new Employee(3, "王五", 38, 5555.55),
                new Employee(4, "趙六", 45, 8888.88)
        );
        //調用年齡小于35的員工信息方法(匿名內部類的方式)
        List<Employee> list = getEmployee(emps, new MyStrategy<Employee>(){
            @Override
            public boolean getEmployeeInfo(Employee employee) {
                return employee.getAge()  <= 35;
            }
        });
        for (Employee employee : list) {
            System.out.println(employee);
        }
        System.out.println("------------------------");
        //調用調用工資大于5000的員工信息方法(匿名內部類的方式)
        List<Employee> list1 = getEmployee(emps, new MyStrategy<Employee>(){
            @Override
            public boolean getEmployeeInfo(Employee employee) {
                return employee.getSalary() >= 5000;
            }
        });
        for (Employee employee : list1) {
            System.out.println(employee);
        }
    }
   /**
     * @param list 需要傳入員工信息
     * @param strategy 需要傳入具體策略
     */
    public static List<Employee> getEmployee(List<Employee> list, MyStrategy<Employee> strategy){
        List<Employee> empList = new ArrayList<>();
        for(Employee emp:list){
            if(strategy.getEmployeeInfo(emp)){
                empList.add(emp);
            }
        }
        return empList;
    }
}
3、運行main函數，輸出如下:

jdk1.8為什么使用lambda表達式

五、優化方式三（Lambda實現）

1、定義一個策略接口
package com.xz.springboot_java8.day1.test2;
/**
 * 定義一個策略接口
 */
public interface MyStrategy<T> {
    //該方法默認為public abstract修飾
    public abstract boolean getEmployeeInfo(T t);
}
2、測試類如下：
package com.xz.springboot_java8.day1.test4;
import com.xz.springboot_java8.day1.entity.Employee;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
 * @description: Lambda實現
 *               員工年齡小于35的員工信息和員工工資大于5000的員工信息。
 * @author: xz
 * @create: 2021-08-23 22:10
 */
public class Test {
    public static void main(String[] args) {
        //初始化員工數據并轉成list
        List<Employee> emps = Arrays.asList(
                new Employee(1, "張三", 18, 2222.22),
                new Employee(2, "李四", 25, 3333.33),
                new Employee(3, "王五", 38, 5555.55),
                new Employee(4, "趙六", 45, 8888.88)
        );
        //調用年齡小于35的員工信息方法(Lambda表達式實現)
        List<Employee> list = getEmployee(emps, (e) -> e.getAge() <= 35);
        for (Employee employee : list) {
            System.out.println(employee);
        }
        System.out.println("------------------------");
        //調用調用工資大于5000的員工信息方法(Lambda表達式實現)
        List<Employee> list1 = getEmployee(emps, (e) -> e.getSalary() >= 5000);
        for (Employee employee : list1) {
            System.out.println(employee);
        }
    }
    /**
     * 獲取條件過濾后的員工信息
     * @param list 需要傳入員工信息
     * @param strategy 需要傳入具體策略
     */
    public static List<Employee> getEmployee(List<Employee> list, MyStrategy<Employee> strategy){
        List<Employee> empList = new ArrayList<>();
        for(Employee emp:list){
            if(strategy.getEmployeeInfo(emp)){
                empList.add(emp);
            }
        }
        return empList;
    }
}
3、運行main函數，輸出如下:

jdk1.8為什么使用lambda表達式

六、優化方式四（Stream API和Lambda表達式實現）

1、代碼如下：
package com.xz.springboot_java8.day1.test5;
import com.xz.springboot_java8.day1.entity.Employee;
import java.util.Arrays;
import java.util.List;
/**
 * @description:
 *              員工年齡小于35的員工信息和員工工資大于5000的員工信息。
 * @author: xz
 * @create: 2021-08-23 22:18
 */
public class Test {
    public static void main(String[] args) {
        //初始化員工數據并轉成list
        List<Employee> emps = Arrays.asList(
                new Employee(1, "張三", 18, 2222.22),
                new Employee(2, "李四", 25, 3333.33),
                new Employee(3, "王五", 38, 5555.55),
                new Employee(4, "趙六", 45, 8888.88)
        );
        //調用年齡小于35的員工信息方法(Lambda表達式實現)
        emps.stream()
                .filter((e)->e.getAge() <= 35)
                .forEach(System.out::println);
        System.out.println("=======================");
        //調用調用工資大于5000的員工信息方法(Lambda表達式實現)
        emps.stream()
                .filter((e)->e.getSalary() >= 5000)
                .forEach(System.out::println);
    }
}
2、運行main函數，輸出結果如下：

jdk1.8為什么使用lambda表達式

到此，相信大家對“jdk1.8為什么使用lambda表達式”有了更深的了解，不妨來實際操作一番吧！這里是億速云網站，更多相關內容可以進入相關頻道進行查詢，關注我們，繼續學習！

向AI問一下細節

免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。

AI
助
手
湛江市| 集安市| 阜康市| 崇信县| 嘉善县| 海伦市| 沙洋县| 奉贤区| 海阳市| 扬中市| 威远县| 安溪县| 阿拉尔市| 金秀| 德保县| 安徽省| 弋阳县| 阜城县| 泰安市| 曲松县| 沙坪坝区| 孟州市| 新竹县| 宁陵县| 时尚| 军事| 叶城县| 武隆县| 伊金霍洛旗| 大同县| 嘉峪关市| 凌云县| 曲沃县| 紫云| 娄底市| 马山县| 巴林右旗| 怀柔区| 凯里市| 察隅县| 二连浩特市|