SpringBoot(五) - Java8 新特性-有解無憂

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);

測驗結果：

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/517496.html

標籤：Java

上一篇：聊聊運營活動的設計與實作邏輯

下一篇：Spring Boot 實作跨域的 5 種方式，總有一種適合你，建議收藏！！

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 自定義排序規則

1.2.2.1 帶一個引數沒有回傳值標準寫法

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

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

2.1 創建流有限流和無限流

2.2 創建流基于陣列和集合