SpringBoot(五) - Java8 新特性 - ⎝⎛CodingNote.cc ⎞⎠

SpringBoot(五) – Java8 新特性

2022 年 10 月 18 日
筆記
springboot

1、Lambda表達式

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

1.1 語法組成

操作符為” -> ” ，被稱為 Lambda 操作符或箭頭操作符;
將 Lambda 分為兩個部分：
1. 左側:指定了 Lambda 表達式需要的參數列表；
2. 右側:指定了 Lambda 體，是抽象方法的實現邏輯，也即Lambda 表達式要執行的功能。

1.2 基本用法

1.2.1 未使用和使用Lambda表達式的區別

@Slf4j
public class TestLambda {
    
    //未使用和使用lambda表達式，對比
    static void testRunLambdaContrast(){
        // 不使用lambda表達式，創建一個執行緒
        Runnable runnable1 = new Runnable() {
            @Override
            public void run() {
                log.info("------ 不使用lambda表達式，創建一個執行緒 ------");
            }
        };
        // 啟動執行緒
        new Thread(runnable1).start();

        // 使用lambda表達式，創建一個執行緒
        Runnable runnable2 = () -> log.info("------ 使用lambda表達式，創建一個執行緒 ------");
        // 啟動執行緒2
        new Thread(runnable2).start();
    }
    
    public static void main(String[] args) {
        
        //測試 未使用和使用lambda表達式，對比
        testRunLambdaContrast();
        
    }
    
}

總結：未使用和使用Lambda表達式都可以實現抽象方法，但是使用Lambda方法後會更加簡潔；

1.2.2 帶一個參數沒有返回值

1.2.2.1 帶一個參數沒有返回值標準寫法

// 藉助java8中 消費型函數式介面，講解基本用法
// 不使用lambda表達式實現
Consumer<String> consumer1 = new Consumer<String>() {
    @Override
    public void accept(String s) {
        log.info("------ 不使用lambda表達式，實現Consumer1介面，消費數據：{} ------",s);
    }
};

// 使用消費型介面1
consumer1.accept("kh96正在學習lambda表達式，標準寫法");

// 使用lambda表達式，用法：帶 1 個參數，沒有返回值，標準寫法
Consumer<String> consumer2 = (String s) -> {
    log.info("------ 使用lambda表達式，實現Consumer2介面，消費數據：{} ------",s);
};

// 使用消費型介面2
consumer2.accept("kh96正在學習lambda表達式，標準寫法");

1.2.2.2 簡化寫法：一個參數，可以省略類型聲明

//一個參數，可以省略類型聲明
Consumer<String> consumer3 = (s) -> {
    log.info("------ 使用lambda表達式，實現Consumer3介面，消費數據：{} ------",s);
};

consumer3.accept("kh96正在學習lambda表達式，一個參數，可以省略類型聲明");

1.2.2.3 簡化寫法：一個參數，可以省略小括弧（沒有參數，多個參數不能省略）

//一個參數，可以省略小括弧（沒有參數，多個參數不能省略）
Consumer<String> consumer4 = s -> {
    log.info("------ 使用lambda表達式，實現Consumer4介面，消費數據：{} ------",s);
};

consumer4.accept("kh96正在學習lambda表達式，一個參數，可以省略小括弧");

1.2.2.4 簡化寫法：實現只有一條語句，可以省略大括弧（有多條語句，不可以省略）

//實現只有一條語句，可以省略大括弧（有多條語句，不可以省略）
Consumer<String> consumer5 = s -> log.info("------ 使用lambda表達式，實現Consumer3介面，消費數據：{} ------",s);

consumer5.accept("kh96正在學習lambda表達式，實現只有一條語句，可以省略大括弧");

1.2.2.5 簡化寫法：實現有多條語句，不可以省略大括弧

//實現有多條語句，不可以省略大括弧
Consumer<String> consumer6 = s -> {
    log.info("------ 使用lambda表達式，實現Consumer3介面，消費數據：{} ------",s);
    log.info("------ 使用lambda表達式，實現Consumer3介面，消費數據：{} ------",s);
};

consumer6.accept("kh96正在學習lambda表達式，實現有多條語句，不可以省略大括弧");

1.2.3 帶多個參數，有返回值

1.2.3.1 未使用 lambda 表達式，用法：帶多個參數，有返回值

// 藉助Comparator介面，講解多個參數
Comparator<Integer> comparator1 = new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o1.compareTo(o2);
    }
};

// 未使用lambda表達式，用法：帶多個參數，有返回值
log.info("------ 不使用lambda表達式，實現Comparator介面，比較12,23的大小：{} ------",comparator1.compare(12,23));// 小於 -1,大於 1，等於 0

1.2.3.2 簡化寫法：省略參數類型，但是不可以省略小括弧，一條語句省略大括弧，跟返回值無關（不用手動加return）

//省略參數類型，但是不可以省略小括弧，一條語句省略大括弧，跟返回值無關（不用手動加return）
Comparator<Integer> comparator2 = (o1,o2) -> o1.compareTo(o2);

log.info("------ 使用lambda表達式，實現Comparator介面，比較23,12的大小：{} ------",comparator2.compare(23,12));// 大於 1

1.2.3.3 簡化寫法：多條語句不可以省略大括弧，帶返回值（需手動加return）

//多條語句不可以省略大括弧，帶返回值（需手動加return）
Comparator<Integer> comparator3 = (o1,o2) -> {
    log.info("------ 比較原數值為：{}，{}",o1,o2);
    return o1.compareTo(o2);
};
log.info("------ 使用lambda表達式，實現Comparator介面，比較22,22的大小：{} ------",comparator3.compare(22,22));// 等於 0

1.3 java8中提供的函數式介面

1.3.1 消費型介面 Consumer (方法有一個參數，沒有返回值)

1.3.1.1 自定義方法 (使用介面的 void accept(T t) )

//自定義方法，帶有一個消費型介面參數，可以實現一個方法，處理不同的業務場景
static void useConsumer(Double salary,Consumer<Double> consumerDate){
    consumerDate.accept(salary);
}

1.3.1.2 方法調用

static void testLambdaConsumer(){
    //場景，同一個介面，有多個實現，以前，必須要創建介面的多個實現類，現在使用lambda，把介面的實現交給調用方法傳遞

    //實現1：Tom發了5000工資，去買手機,模擬介面的第一個實現
    //以前，必須提供介面的實現類對象
    useConsumer(5000.0,salary -> log.info("Tom,工資：{}，5000買手機",salary));

    //實現1：Tom發了10000工資，去買手機,買平板，模擬介面的第二個實現
    //以前，必須提供介面的 兩個 實現類對象
    useConsumer(10000.0,slary -> {
        log.info("JiMe工資：{}，5000買手機",slary);
        log.info("JiMe工資：{}，4000買平板",slary);
    });

}

1.3.1.3 測試結果

1.3.2 供給型介面 Supplier(方法沒有參數，可以返回任意類型的結果)

1.3.2.1 自定義方法（使用介面的 T get() ）

//帶一個供給型參數，可以實現同一個方法，處理實現同一個方法，處理不同的業務場景，給的數據不同，返回的結果不同
static String useSupplier(Double salary, Supplier<Double> supplierData){
    //判斷是否高薪的邏輯
    if(salary > supplierData.get()){
        return "高薪";
    }
    return "底薪";
}

1.3.2.2 方法調用

static void testLambdaSupplier(){

    //場景：不同的部門，針對高薪的判斷條件不同，比如：學術部高於8000算高薪，教職部門高於5000算高薪
    //以前的寫法：根據不同的不同，增加if...else 判斷，隨著部門的增加，你分的判斷會越來越複雜

    log.info("--- 學術部：工資：{}，是否高薪：{} ---",9000.0,useSupplier(9000.0,() -> 8000.0));
    log.info("--- 學術部：工資：{}，是否高薪：{} ---",7000.0,useSupplier(7000.0,() -> 8000.0));
    log.info("--- 教職部：工資：{}，是否高薪：{} ---",7000.0,useSupplier(7000.0,() -> 5000.0));
    log.info("--- 教職部：工資：{}，是否高薪：{} ---",4000.0,useSupplier(7000.0,() -> 5000.0));

}

1.3.2.3 測試結果

1.3.3 斷言型介面 Predicate（方法有一個參數，有返回值-布爾類型）

1.3.3.1 自定義方法 (使用介面的 boolean test(T t) )

//將判斷條件交給調用方法
static List<String> userPredicate(List<String> nameList, Predicate<String> predicateData){

    //定義要返回的姓名集合
    List<String> returnNameList = new ArrayList();

    //使用斷言型介面，根據傳過來的實現，返回不同的結果
    nameList.forEach(name ->{
        //調用斷言型介面的test方法，進行挑選數據
        if(predicateData.test(name)){
            returnNameList.add(name);
        }
    });

    //返回符合條件的集合數據
    return  returnNameList;

}

1.3.3.2 方法調用

static void testLambdaPredicate(){

    //使用場景
    //已知姓名集合，根據不同的場景，篩選不同的姓名結果
    List<String> nameList = Arrays.asList("Lilei","Hanmeinei","lisi","zhangsan","xiaolong","xiaohu");

    //獲取姓名集合中所有包含n的姓名集合,可以定義第一個方法，實現
    //獲取集合中包含i 或者a的姓名集合，可以定義第二個方法，實現
    //隨著規則的改變，實現的方法越來越多，去簡化，所有的方法就是判斷規則不同，其他都一樣，可以使用斷言型介面，優化

    //獲取姓名集合中所有包含n的姓名集合
    List<String> nameList_n = userPredicate(nameList,name -> name.contains("n"));
    log.info("姓名集合中所有包含n的姓名集合:{}",nameList_n);

    //獲取集合中包含i 或者a的姓名集合
    List<String> nameList_i_a = userPredicate(nameList,name -> name.contains("i") || name.contains("a"));
    log.info("獲取集合中包含i 或者a的姓名集合:{}",nameList_i_a);

}

1.3.3.3 測試結果

1.3.4 函數介面 Function,有任意類型參數，有任意類型返回值

1.3.4.1 自定義方法（使用介面的R apply(T t) ）和方法調用

static void testLambdaFunction(){

    Function<Integer,Double> function = num -> new Random().nextInt(num)*1.0;

    log.info("--- 使用函數型介面，接收整數：{}，返回隨機浮點型結果：{} ---",96,function.apply(96));
    
}

1.3.4.2 測試結果

1.3.5 自定義函數式介面

// 自定義的函數式介面：帶一個任意類型參數，返回String類型值
// 定義：凡是一個介面中，只有一個抽象方法，那這個介面就是函數式介面，可以別註解 //@FunctionalInterface修飾
@FunctionalInterface
public interface MyFunctionInterface<T> {

    //函數式介面中的唯一抽象方法
    String helloKh96(T t);

    //可以增加默認方法，允許的
    default void hiKH96(){
     //默認方法
    }

}

2、StreamAPI

2.1 創建流有限流和無限流

2.1.1 有限流

//有限流， 輸出1，3，5，7，9 的平方
log.info("\n----- 輸出1，3，5，7，9 的平方 -----");
Stream.of(1,3,5,7,9).forEach(num -> System.out.print(num * num + ";"));

測試結果：

2.1.2 無線流

2.1.2.1 iterate

//無限流：輸出前18個奇數
log.info("\n ----- 輸出前18個奇數 ------");
Stream.iterate(1,n -> n+2).limit(10).forEach(num -> System.out.print(num + ";"));

2.1.2.2 generate

//無限流：輸出10個隨機數
log.info("\n ----- 輸出前18個隨機數 ------");
Stream.generate(() -> new Random().nextInt(100)).limit(10).forEach(num -> System.out.print(num+";"));

測試結果：

2.2 創建流基於數組和集合

2.2.1 基於數組

//基於數組
int[] nums = {66,99,44,11,22,55,77,88};

//通過Arrays工具類提供的stream 方法
int min = Arrays.stream(nums).min().getAsInt();
int max = Arrays.stream(nums).max().getAsInt();
log.info("\n ------ 數組最小值為 ：{} --------",min);
log.info("\n ------ 數組最大值為 ：{} --------",max);

測試結果：

2.2.2 基於集合

//基於集合
List<String> nameList = Arrays.asList("Lilei","Hanmeinei","lisi","zhangsan","xiaolong","xiaohu");

//通過集合對象的stream方法
nameList.stream().map(name -> name.toLowerCase()).forEach(System.out::println);

測試結果：

2.3 流的中間操作

2.3.1 篩選和切片

2.3.1.0 數據準備

2.3.1.0.1 bean

//小說實體
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class Story {

    // 編號
    private Integer id;

    // 書名
    private String name;

    // 作者
    private String author;

    // 價格
    private Double price;

    // 章節
    private Integer sections;

    // 分類
    private String category;

}

2.3.1.0.2 StoryUtil

//小說工具類
public class StoryUtil {
    public static List<Story> stories = new ArrayList<>();
    static {
        stories.add(Story.builder().id(101).name("斗破蒼穹").author("zhangsan").price(109.9).sections(1202).category("玄幻").build());
        stories.add(Story.builder().id(201).name("斗羅大陸").author("lisi").price(88.9).sections(999).category("科幻").build());
        stories.add(Story.builder().id(301).name("凡人修仙傳").author("wangwu").price(77.9).sections(1303).category("武俠").build());
        stories.add(Story.builder().id(401).name("聖墟").author("zhuliu").price(121.9).sections(1404).category("玄幻").build());
        stories.add(Story.builder().id(501).name("吞噬星空").author("sunqi").price(135.9).sections(996).category("歷史").build());
        stories.add(Story.builder().id(601).name("完美世界").author("zhaoba").price(66.9).sections(999).category("玄幻").build());
        stories.add(Story.builder().id(701).name("大王饒命").author("qianjiu").price(135.9).sections(997).category("玄幻").build());
        stories.add(Story.builder().id(801).name("大奉打更人").author("zhoushi").price(133.9).sections(1606).category("軍事").build());
    }
}

2.3.1.1 篩選：filter

//篩選： filter,相當於資料庫中的where條件
log.info("-------------- 篩選： filter ----------------");
//查看小說集合中，價格大於100塊的所有小說
StoryUtil.stories.stream().filter(story -> story.getPrice() > 100).forEach(System.out::println);

//練習：查看小說集合中，所有章節數大於1000且作者中包含n的小說
log.info("\n------- 查看小說集合中，所有章節數大於1000且作者中包含n的小說 ---------");
StoryUtil.stories.stream().filter(story -> story.getSections() > 1000 && story.getAuthor().contains("n") ).forEach(System.out::println);

測試結果1：

測試結果2：

2.3.1.2 截斷：limit

//截斷： limit 相當於資料庫的limit條數
log.info("\n---------- 截斷： limit ---------");
//查詢小說集合，所有價格大於100的前三本
StoryUtil.stories.stream().filter(story -> story.getPrice() >100).limit(3).forEach(System.out::println);

測試結果：

2.3.1.3 跳過：skip

//跳過：skip,相當於資料庫跳過數據條數
log.info("\n------------- 跳過：skip-----------------");
//查詢小說集合，所有價格大於100的前三本,後的所有小說
log.info("\n------------- 查詢小說集合，所有價格大於100的前三本,後的所有小說-----------------");
StoryUtil.stories.stream().filter(story -> story.getPrice() >100).skip(3).forEach(System.out::println);

測試結果：

2.3.1.4 去重：distinct

//去重：distinct,相當於資料庫中的去重,了解
log.info("\n------------- 去重：distinct,相當於資料庫中的去重 -----------------");
Stream.of(22,33,55,11,66,33,55,11,55).distinct().forEach(System.out::println);

測試結果：

2.3.2 映射和排序

2.3.2.1 映射：map

 //已知姓名集合
List<String> nameList = Arrays.asList("Lilei","Hanmeinei","lisi","zhangsan","xiaolong","xiaohu");

//映射：map,可以將流中發的元素進行轉換或這提取，會自動指定的規則作用到所有的元素上，並返回一個新的流
log.info("-------------- 映射： map ----------------");

//將姓名集合中，所有包含i的姓名，轉換為大寫並輸出
//nameList.stream().filter(name -> name.contains("i")).map(name -> name.toUpperCase()).forEach(System.out::println);
nameList.stream().filter(name -> name.contains("i")).map(String::toUpperCase).forEach(System.out::println);

測試結果：

2.3.2.2 映射：map 輸出單個屬性

 //將小說集合中,章節小於1000的作者轉換為大寫，輸出作者
log.info("\n-------------- 將小說集合中,章節小於1000的作者轉換為大寫，輸出作者 --------------");
//StoryUtil.stories.stream().filter(story -> story.getSections() < 1000).map(story -> story.getAuthor()).map(string -> string.toUpperCase()).forEach(System.out::println);
StoryUtil.stories.stream().filter(story -> story.getSections() < 1000).map(Story::getAuthor).map(string -> string.toUpperCase()).forEach(System.out::println);

測試結果：

2.3.2.3 映射： mapToInt

//獲取所有小說的書名長度
log.info("\n-------------- 獲取所有小說的書名長度 --------------");
// StoryUtil.stories.stream().map(story -> story.getName().length()).forEach(System.out::println);
StoryUtil.stories.stream().mapToInt(story -> story.getName().length()).forEach(System.out::println);

測試結果：

2.3.2.4 消費：peek

//消費：peek,  將小說價格增加50元後，價格大於130的
log.info("\n-------------- 消費：peek,  將小說價格增加50元後，價格大於130的 --------------");
StoryUtil.stories.stream().peek(story -> story.setPrice(story.getPrice()+50)).filter(story -> story.getPrice()>130).forEach(System.out::println);

測試結果：

2.3.2.5 排序：sorted

 //排序：sorted ,給姓名排序
log.info("\n -------------- 排序：sorted ,給姓名排序 --------------");
nameList.stream().sorted().forEach(System.out::println);

2.3.2.6 自定義排序規則

//自定義排序，先按照價格排序，價格相同，按照章節排序
log.info("\n--------- 自定義排序，先按照價格排序，價格相同，按照章節排序 ---------");
StoryUtil.stories.stream().sorted((s1,s2)->{
    int sortPrice = Double.compare(s1.getPrice(),s2.getPrice());
    if(sortPrice == 0){
        return Double.compare(s1.getSections(),s2.getSections());
    }
    return sortPrice;

}).forEach(System.out::println);

測試結果：

Tags: springboot

SpringBoot(五) – Java8 新特性

1、Lambda表達式

1.1 語法組成

1.2 基本用法

1.2.1 未使用和使用Lambda表達式的區別

1.2.2 帶一個參數沒有返回值

1.2.2.1 帶一個參數沒有返回值 標準寫法

1.2.2.2 簡化寫法：一個參數，可以省略類型聲明

1.2.2.3 簡化寫法：一個參數，可以省略小括弧（沒有參數，多個參數不能省略）

1.2.2.4 簡化寫法：實現只有一條語句，可以省略大括弧（有多條語句，不可以省略）

1.2.2.5 簡化寫法：實現有多條語句，不可以省略大括弧

1.2.3 帶多個參數，有返回值

1.2.3.1 未使用 lambda 表達式，用法：帶多個參數，有返回值

1.2.3.2 簡化寫法：省略參數類型，但是不可以省略小括弧，一條語句省略大括弧，跟返回值無關（不用手動加return）

1.2.3.3 簡化寫法：多條語句不可以省略大括弧，帶返回值（需手動加return）

1.3 java8中提供的函數式介面

1.3.1 消費型介面 Consumer (方法有一個參數，沒有返回值)

1.3.1.1 自定義方法 (使用介面的 void accept(T t) )

1.3.1.2 方法調用

1.3.1.3 測試結果

1.3.2 供給型介面 Supplier(方法沒有參數，可以返回任意類型的結果)

1.3.2.1 自定義方法 （使用介面的 T get() ）

1.3.2.2 方法調用

1.3.2.3 測試結果

1.3.3 斷言型介面 Predicate（方法有一個參數，有返回值-布爾類型）

1.3.3.1 自定義方法 (使用介面的 boolean test(T t) )

1.3.3.2 方法調用

1.3.3.3 測試結果

1.3.4 函數介面 Function,有任意類型參數，有任意類型返回值

1.3.4.1 自定義方法（使用介面的R apply(T t) ） 和 方法調用

1.3.4.2 測試結果

1.3.5 自定義函數式介面

2、StreamAPI

2.1 創建流 有限流 和 無限流

2.1.1 有限流

2.1.2 無線流

2.1.2.1 iterate

2.1.2.2 generate

2.2 創建流 基於數組 和 集合

2.2.1 基於數組

2.2.2 基於集合

2.3 流的中間操作

2.3.1 篩選和切片

2.3.1.0 數據準備

2.3.1.0.1 bean

2.3.1.0.2 StoryUtil

2.3.1.1 篩選：filter

2.3.1.2 截斷：limit

2.3.1.3 跳過：skip

2.3.1.4 去重：distinct

2.3.2 映射和排序

2.3.2.1 映射：map

2.3.2.2 映射：map 輸出單個屬性

2.3.2.3 映射： mapToInt

2.3.2.4 消費：peek

2.3.2.5 排序：sorted

2.3.2.6 自定義排序規則

分享此文：

Related Posts

用Python預測你有沒有女朋友

HelloDjango 第 09 篇：讓部落格支援 Markdown 語法和程式碼高亮

聊聊運營活動的設計與實現邏輯

vulnhub靶場|NAPPING: 1.0.1

VirMach 便宜 VPS

QNews

熱門搜尋

1.2.2.1 帶一個參數沒有返回值標準寫法

1.3.2.1 自定義方法（使用介面的 T get() ）

1.3.4.1 自定義方法（使用介面的R apply(T t) ）和方法調用

2.1 創建流有限流和無限流

2.2 創建流基於數組和集合