讓代碼變得優雅簡潔的神器:Java8 Stream流式編程

image


本文主要基於實際項目常用的Stream Api流式處理總結。


因筆者主要從事風控反欺詐相關工作,故而此文使用比較熟悉的三要素之一的【手機號】黑名單作代碼案例說明。


我在項目當中,很早就開始使用Java 8的流特性進行開發了,但是一直都沒有針對這塊進行開發總結。這次就對這一塊代碼知識做一次全面總結,在總結的過程中去發現自己的不足,同時方便日後開發查詢。


在實際項目當中,若能熟練使用Java8 的Stream流特性進行開發,就比較容易寫出簡潔優雅的代碼。目前市面上很多開源框架,如Mybatis- Plus、kafka Streams以及Flink流處理等,都有一個相似的地方,即用到Stream流特性,其寫出的代碼簡潔而易懂,當然,若是在不熟悉流特性的基礎上而貿然去使用Stream開發的話,難免會寫出一手bug。

此文主要適合新手。


一、Stream中間操作

​ Stream的中間操作是指在流鏈當中,可以對數據進行處理操作,包括filter過濾、map映射轉換、flatMap合併、distinct去重、sorted排序等操作。這些操作都會返回一個新的Stream流對象,可以通過鏈式調用多箇中間操作進行復雜的數據處理。需要注意的是,中間操作需要具有終止操作纔會觸發。

​ 下面按類別講解Stream常見的中間操作。

1.1、filter:過濾出符合條件的元素。

​ filter()方法常用於實現數據過濾,即可以對集合、數組等數據源篩選出符合指定條件的元素,並返回一個新的流。

​ 假設有一個黑名單手機號列表,需要篩選出其中所有開頭爲“133”的元素,那麼可以通過filter()實現——

//將數組轉換爲一個字符串列表
List<String> numbers = Arrays.asList("13378520000","13278520000","13178520000","13358520000");
//通過stream()方法創建一個流,接着使用filter()方法過濾出前綴爲“133”的元素,最終通過collect() 方法將結果收集到一個新列表中
List<String> filterdNumbers = numbers.stream().filter(s -> s.startsWith("133")).collect(Collectors.toList());
System.out.println(filterdNumbers);


打印結果:[13378520000, 13358520000]

1.2、map:映射轉換元素。

​ map()方法用於對流中的每個元素進行映射操作,將其轉換爲另一個元素或者提取其中的信息,並返回一個新的流。

​ 根據以下兩個案例分別學習map()將元素轉換爲另一個元素以及提取元素其中的信息——

1.2.1、轉換元素

​ 假設有一個手機號字符列表,需要根據前7位來確定手機號歸屬地,那麼就需要獲取所有手機號前7位子字符串,可以使用map()方法實現:

List<String> numbers = Arrays.asList("13378520000","13278520000","13178520000","13558520000");
//通過stream()方法創建一個流,使用map()方法將每個字符串轉換爲截取前7位的字符,最後使用collect()方法將結果收集到一個新列表中
List<String> filterdNumbers = numbers.stream().map(s -> s.substring(0,7)).collect(Collectors.toList());
System.out.println(filterdNumbers);


打印結果:[1337852, 1327852, 1317852, 1355852]

1.2.2、提取元素信息

​ 假設有一個用戶對象列表,我們需要提取其中每個對象的手機號,可以使用map()方法實現:

List<People> peopleList = Arrays.asList(
        new People("王二","13378520000"),
        new People("李二","13278520000"),
        new People("張四","13178520000")
);
//通過stream()方法創建一個流,使用map()方法提取每個用戶的手機號,最後使用collect()方法將結果收集到一個新列表中
List<String> tel = peopleList.stream().map(People::getTel).collect(Collectors.toList());
System.out.println(tel);


打印結果:[13378520000, 13278520000, 13178520000]

1.3、flatMap:將多個流合併爲一個流。

​ flatMap()方法可以實現多對多的映射,或者將多個列表合併成一個列表操作。


1.3.1、實現多對多的映射

​ 假設有兩組餘額列表A和B,需要將A組每個元素都與B組所有元素依次進行相加,可以使用flatMap實現該多對多的映射——

List<Integer> listA = Arrays.asList(1, 2, 3);
List<Integer> listB = Arrays.asList(4, 5, 6);
List<Integer> list = listA.stream().flatMap(a -> listB.stream().map(b -> a +b)).collect(Collectors.toList());
System.out.println(list);


打印結果:  [5, 6, 7, 6, 7, 8, 7, 8, 9]	  

1.3.2、將多個列表合併成一個列表

​ 假設有一個包含多個手機號字符串列表的列表,現在需要合併所有手機號字符串成爲一個列表,可以使用flatMap()方法實現:

List<List<String>> listOfLists = Arrays.asList(
        Arrays.asList("13378520000", "13278520000"),
        Arrays.asList("13178520000", "13558520000"),
        Arrays.asList("15138510000", "15228310000")
);
List<String> flatMapList = listOfLists.stream().flatMap(Collection::stream).collect(Collectors.toList());
System.out.println(flatMapList);


打印結果:[13378520000, 13278520000, 13178520000, 13558520000, 15138510000, 15228310000]

1.4、distinct:去除重複的元素。

​ distinct()方法可以用來去除流中的重複元素,生成無重複的列表。

​ 假設有一個包含重複手機號字符串的列表,可以使用distinct()去重操作——

List<String> numbers = Arrays.asList("13378520000", "15138510000","13178520000", "15138510000");
List<String> disNumbers = numbers.stream().distinct().collect(Collectors.toList());
System.out.println(disNumbers);		


打印結果:[13378520000, 15138510000, 13178520000]		

​ 注意一點的是,distinct用於針對流作去重操作時,需要確定流中元素實現了equals()和hashCode()方法,因爲這兩個方法是判斷兩個對象是否相等的標準。


1.5、sorted:排序元素。

​ sorted()方法用於對流中的元素進行排序。

​ 假設需要對一組People對象按照年齡排序,下面分別按照升序排序和降序排序——


1.5.1、升序排序

​ 默認情況下,是升序排序——

List<People> peopleList = Arrays.asList(
        new People("王二",20),
        new People("李二",30),
        new People("張四",31)
);
List<People> newpeopleList=peopleList.stream().sorted(Comparator.comparing(People::getAge)).collect(Collectors.toList());
//打印結果
newpeopleList.stream().forEach(System.out::println);


打印結果:
People{name='王二', age=20}
People{name='李二', age=30}
People{name='張四', age=31}

1.5.2、降序排序

通過reversed()方法進行逆序排序,也就是將升序排序進行倒序排序——

List<People> peopleList = Arrays.asList(
        new People("王二",20),
        new People("李二",30),
        new People("張四",31)
);
List<People> newpeopleList = peopleList.stream().sorted(Comparator.comparing(People::getAge).reversed()).collect(Collectors.toList());
//打印結果
newpeopleList.stream().forEach(System.out::println);


打印結果:
People{name='張四', age=31}
People{name='李二', age=30}
People{name='王二', age=20}

1.6、peek:查看每個元素的信息,但不修改流中元素的狀態。

​ peek()方法用於查看流中的元素而不會修改流中元素的狀態,可以在流中的任何階段使用,不會影響到流的操作,也不會終止流的操作。

List<String> telList = Arrays.asList("13378520000","13278520000","13178520000","13558520000");
telList.stream().peek(t -> System.out.println(t))
        .map(t -> t.substring(0,3))
        .peek(t -> System.out.println(t))
        .collect(Collectors.toList());


打印結果:
			13378520000
			133
			13278520000
			132

peek()方法和forEach很類似,都是可以用於遍歷流中的元素,但是,兩者之間存在較大的區別。主要一點是,forEach在流中是一個終止操作,一旦調用它,就意味着Stream流已經被處理完成,不能再進行任何操作,例如,無法在forEach之後針對流進行map、filter等操作,但peek方法可以,以上的案例可以看出,在第一次調用peek打印一個元素後,該元素還可以接着進行map操作,進行字符串的前三位截取。

這是peek()方法和forEach最大的區別。


1.7、limit 和 skip:截取流中的部分元素。

​ limit()和skip()都是用於截取Stream流中部分元素的方法,兩者區別在於,limit()返回一個包含前n個元素的新流,skip()則返回一個丟棄前n個元素後剩餘元素組成的新流。

int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
System.out.print("取數組前5個元素:");
Arrays.stream(arr).limit(5).forEach(n -> System.out.print(n + " ")); // 輸出結果爲:1 2 3 4 5


System.out.print("跳過前3個元素,取剩餘數組元素:");
Arrays.stream(arr).skip(3).forEach(n -> System.out.print(n + " ")); // 輸出結果爲:4 5 6 7 8 9 10

二、Stream終止操作

​ Stream的終止操作是指執行Stream流鏈中最後一個步驟,到這一步就會結束整個流處理。在Java8中,Stream終止操作包括forEach、toArray、reduce、collect、min、max、count、anyMatch、allMatch、noneMatch、findFirst和findAny等。這些終止操作都有返回值。需要注意一點是,如果沒有執行終止操作的話,Stream流是不會觸發執行的,例如,一個沒有終止操作的peek()方法代碼是不會執行進而打印——

list.stream().peek(t -> System.out.println("ddd"))

​ 當加上終止操作話,例如加上collect,就會打印出“ddd”——

list.stream().peek(t -> System.out.println("ddd")).collect(Collectors.toList());

下面按類別分別講解各個終止操作的使用。


2.1、forEach:遍歷流中的每個元素。

​ 該forEach前面已經提到,這裏不做過多介紹。


2.2、count:統計流中元素的數量。

​ count可以統計流中元素的數量並返回結果。

​ 假設有一個包含多個手機號字符串的列表,需要統計去重後的手機號數量,就可以使用count方法——

List<String> numbers = Arrays.asList("13378520000", "15138510000","13178520000", "15138510000");
long count = numbers.stream()
        .distinct()//去重
        .count();//統計去重後的手機號
System.out.println(count);


打印結果:3

2.3、reduce:將流中的所有元素歸約成一個結果。

​ reduce()可以將流中的所有元素根據指定規則歸約成一個結果,並將該結果返回。

​ 常用語法格式如下:

Optional<T> result = stream.reduce(BinaryOperator<T> accumulator);

​ 可見,reduce方法會返回一個Optional類型的值,表示歸約後的結果,需要通過get()方法獲取Optional裏的值。

假設有一個包含多個手機號字符串的List列表,需要在去重之後,再將列表所有字符串拼按照逗號間隔接成一個字符串返回,那麼就可以通過reduce來實現——

List<String> numbers = Arrays.asList("13378520000", "15138510000","13178520000", "15138510000");
Optional result = numbers.stream()
        .distinct() //去重
        .reduce((a ,b) -> a+","+b);//指定規則爲,相臨兩個字符通過逗號“,”間隔
System.out.println(result.get());

打印結果:13378520000,15138510000,13178520000

2.4、collect:將流中的元素收集到一個容器中,並返回該容器。

​ collect的作用是將流中的元素收集到一個新的容器中,返回該容器。打個比喻,它就像一個採摘水果的工人,負責將水果一個個採摘下來,然後放進一個籃子裏,最後將籃子交給你。我在前面的案例當中,基本都有用到collect,例如前面2.1的filter過濾用法中的List filterdNumbers = numbers.stream().filter(s -> s.startsWith("133")).collect(Collectors.toList()),就是將過濾出前綴爲“133”的字符串,將這些過濾處理後的元素交給collect這個終止操作。這時collect就像採摘水果的員工,把採摘爲前綴“133”的“水果”通過toList()方法收集到一個新的List容器當中,然後交給你。最後你就可以得到一個只裝着前綴爲“133”的元素集合。

​ 在Java8的collect方法中,除裏toList()之外,還提供了例如toSet,toMap等方法滿足不同的場景,根據名字就可以知道,toSet()返回的是一個Set集合,toMap()返回的是一個Map集合。


2.5、min 和 max:找出流中的最小值和最大值。

​ min和max用來查找流中的最小值和最大值。

​ 假設需要在查找出用戶列表中年齡最小的用戶,可以按照以下代碼實現——

List<People> peopleList = Arrays.asList(
        new People("王二",20),
        new People("李二",30),
        new People("張四",31)
);
//查找年齡最小的用戶,若沒有則返回一個null
People people = peopleList.stream().min(Comparator.comparing(People::getAge)).orElse(null);
System.out.println(people);

打印結果:People{name='王二', age=20}

​ max的用法類似,這裏不做額外說明。

2.6、anyMatch、allMatch 和 noneMatch:判斷流中是否存在滿足指定條件的元素。


2.6.1、anyMatch

​ anyMatch用於判斷,如果流中至少有一個元素滿足給定條件,那麼返回true,反之返回false,即 true||false爲true這類的判斷。

​ 假設在一個手機號字符串的List列表當中,判斷是否包含前綴爲“153”的手機號,就可以使用anyMatch——

List<String> numbers = Arrays.asList("13378520000", "15138510000","13178520000", "15338510000");
boolean hasNum = numbers.stream().anyMatch(n -> n.startsWith("153"));
System.out.println(hasNum);

打印結果:true

2.6.2、allMatch

​ allMatch用於判斷,流中的所有元素是否都滿足給定條件,滿足返回true,反之false,即true&&false爲false這類判斷。

​ 假設在一個手機號字符串的List列表當中,判斷手機號是否都滿足前綴爲“153”的手機號,就可以用allMatch——

List<String> numbers = Arrays.asList("13378520000", "15138510000","13178520000", "15338510000");
boolean hasNum = numbers.stream().allMatch(n -> n.startsWith("153"));
System.out.println(hasNum);

打印結果:false

2.6.2、noneMatch

​ noneMatch用於判斷,如果流中沒有任何元素滿足給定的條件,返回true,如果流中有任意一個條件滿足給定條件,返回false,類似!true爲false的判斷。

​ 假設在一個手機號字符串的List列表當中,判斷手機號是否都不滿足前綴爲“153”的手機號,就可以用noneMatch——

List<String> numbers = Arrays.asList("13378520000", "15138510000","13178520000", "1238510000");
//numbers裏沒有前綴爲“153”的手機號
boolean hasNum = numbers.stream().noneMatch(n -> n.startsWith("153"));
System.out.println(hasNum);


打印結果:true

​ 這三個方法其實存在一定互相替代性,例如在3.6.1中,滿足!anyMatch表示所有手機號都不爲“153”前綴,纔得到true,這不就是noneMatch,主要看在項目當中如何靈活應用。


2.7、findFirst 和 findAny:返回流中第一個或任意一個元素。


2.7.1、findFirst

​ findFirst用於返回流中第一個元素,如果流爲空話,則返回一個空的Optional對象——

​ 假設需要對一批同手機號的黑名單用戶按照時間戳降序排序,然後取出第一個即時間戳爲最早的用戶,就可以使用findFirst——

List<People> peopleList = Arrays.asList(
        new People("王二","13178520000","20210409"),
        new People("李二","13178520000","20230401"),
        new People("張四","13178520000","20220509"),
        new People("趙六","13178520000","20220109")
);
/**
 * 先按照時間升序排序,排序後的結果如下:
 *   People{name='王二', tel='13178520000', time='20210409'}
 *   People{name='趙六', tel='13178520000', time='20220109'}
 *   People{name='張四', tel='13178520000', time='20220509'}
 *   People{name='李二', tel='13178520000', time='20230401'}
 *
 *排序後,People{name='王二', tel='13178520000', time='20210409'}成了流中的第一個元素
 */
People people = peopleList.stream().sorted(Comparator.comparing(People::getTime)).findFirst().orElse(null);
System.out.println(people);

打印結果:People{name='王二', tel='13178520000', time='20210409'} 


2.7.2、findAny

​ findAny返回流中的任意一個元素,如果流爲空,則通過Optional對象返回一個null。

​ 假設有一個已經存在的黑名單手機號列表blackList,現在有一批新的手機號列表phoneNumber,需要基於blackList列表過濾出phoneNumber存在的黑名單手機號,最後從過濾出來的黑名單手機號當中挑選出來出來任意一個,即可以通過findAny實現——

//blackList是已經存在的黑名單列表
List<String> blackList = Arrays.asList("13378520000", "15138510000");
//新來的手機號列表
List<String> phoneNumber = Arrays.asList("13378520000", "13178520000", "1238510000","15138510000","13299920000");
String blackPhone = phoneNumber.stream()
        //過濾出phoneNumber有包含在blackList的手機號,這類手機號即爲黑名單手機號。
        .filter(phone -> blackList.contains(phone))
        //獲取過濾確定爲黑名單手機號的任意一個
        .findAny()
        //如果沒有則返回一個null
        .orElse(null);
System.out.println(blackPhone);

打印結果:13378520000

三、並行流

​ 前面的案例主要都是以順序流來講解,接下來,就是講解Stream的並行流。在大數據量處理場景下,使用並行流可以提高某些操作效率,但同樣存在一些需要考慮的問題,並非所有情況下都可以使用。

3.1、什麼是並行流:並行流的概念和原理。

​ 並行流是指通過將數據按照一定的方式劃分成多個片段分別在多個處理器上並行執行,這就意味着,可能處理完成的數據順序與原先排序好的數據情況是不一致的。主要是用在比較大的數據量處理情況,若數據量太少,效率並不比順序流要高,因爲底層其實就使用到了多線程的技術。

​ 並行流的流程原理如下:

1、輸入數據:並行流的初始數據一般是集合或者數組,例如Arrays.asList("13378520000", "13178520000", "1238510000","15138510000","13299920000");

2、劃分數據:將初始數據平均分成若干個子集,每個子集可以在不同的線程中獨立進行處理,這個過程通常叫“分支”(Forking),默認情況下,Java8並行流使用到了ForkJoinPool框架,會將Arrays.asList("13378520000", "13178520000", "1238510000","15138510000","13299920000")劃分成更小的顆粒進行處理,可能會將該數組劃分成以下三個子集:

[13378520000, 13178520000]    [1238510000, 13338510000]    [13299920000]

3、處理數據:針對劃分好的子集並行進行相同的操作,例如包括過濾(filter)、映射(map)、去重(distinct)等,這個過程通常叫“計算”(Computing),例如需要過濾爲前綴包括“133”的字符集合,那麼,各個子集,就會處理得到以下結果:

[13378520000]    [13338510000]    []

4、合併結果:將所有子集處理完成的結果進行彙總,得到最終結果。這個過程通常叫“合併”(Merging),結果就會合並如下:

[13378520000,13338510000]  

5、返回結果:返回最終結果。

通俗而言,就是順序流中,只有一個工人在摘水果,並行流中,是多個工人同時在摘水果。


3.2、創建並行流:通過 parallel() 方法將串行流轉換爲並行流。

​ 可以通過parallel()方法將順序流轉換爲並行流,操作很簡單,只需要在順序流上調用parallel()即可。

List<String> numbers = Arrays.asList("13378360000","13278240000","13178590000","13558120000");
//通過stream().parallel()方法創建一個並行流,使用map()方法將每個字符串轉換爲截取前7位的字符,最後使用collect()方法將結果收集到一個新列表中
List<String> filNums = numbers.stream().parallel().map(s -> s.substring(0,7)).collect(Collectors.toList());
System.out.println(filNums);


打印結果:[1337836, 1327824, 1317859, 1355812]

3.3、並行流的注意事項:並行流可能引發的線程安全,以及如何避免這些問題。

​ 在使用併發流的過程中,可能會引發以下線程安全問題:並行流中的每個子集都在不同線程運行,可能會導致對共享狀態的競爭和衝突。

​ 避免線程問題的方法如下:避免修改共享狀態,即在處理集合過程當中,避免被其他線程修改集合數據,可以使用鎖來保證線程安全。

​ 使用無狀態操作:在並行流處理過程儘量使用無狀態操作,例如filter、map之類的,可以儘量避免線程安全和同步問題。


四、Optional

4.1、什麼是 Optional:Optional 類型的作用和使用場景。

在實際開發當中,Optional類型通常用於返回可能爲空的方法、避免null值的傳遞和簡化複雜的判斷邏輯等場景。調用Optional對象的方法,需要通過isPresent()方法判斷值是否存在,如果存在則可以通過get()方法獲取其值,如果不存在則可以通過orElse()方法提供默認值,或者拋出自定義異常處理。


4.2、如何使用 Optional:如何使用 Optional 類型。

使用Optional類型主要目的是在數據可能爲空的情況下,提供一種更安全、更優雅的處理方式。

以下是使用Optional類型的常用方法:


4.2.1、ofNullable()和isPresent()方法

​ 將一個可能爲null的對象包裝成Optional類型的對象,然後根據isPresent方法判斷對象是否包含空值——

String str = null;
Optional<String> optStr = Optional.ofNullable(str);
if (optStr.isPresent()){
    System.out.println("Optional對象不爲空");
}else {
    System.out.println("Optional對象爲空");
}

打印結果:Optional對象爲空

4.2.2、get()方法

​ 獲取Optional對象中的值,如果對象爲空則拋出NoSuchElementException異常——

String str = null;
Optional<String> optStr = Optional.ofNullable(str);
if (optStr.isPresent()){
    System.out.println("Optional對象不爲空");
}else {
    System.out.println("Optional對象爲空");
    optStr.get();
}


控制檯打印結果:
Exception in thread "main" java.util.NoSuchElementException: No value present
	at java.util.Optional.get(Optional.java:135)
	at com.zhu.fte.biz.test.StreamTest.main(StreamTest.java:144)
Optional對象爲空

4.2.4、orElse()方法

​ 獲取Optional對象中的值,如果對象爲空則返回指定的默認值——

String str = null;
Optional<String> optStr = Optional.ofNullable(str);
if (optStr.isPresent()){
    System.out.println("Optional對象不爲空");
}else {
    System.out.println("Optional對象爲空,返回默認值:" + optStr.orElse("null"));
}


打印結果:Optional對象爲空,返回默認值:null

​ 當然,如果不爲空的話,則能正常獲取對象中的值——

String str = "測試";
Optional<String> optStr = Optional.ofNullable(str);
if (optStr.isPresent()){
    System.out.println("Optional對象不爲空,返回值:" + optStr.orElse("null"));
}else {
    System.out.println("Optional對象爲空,返回默認值:" + optStr.orElse("null"));
}

打印結果:Optional對象不爲空,返回值:測試

那麼,問題來了,它是否能判斷“ ”這類空格的字符串呢,我實驗了一下,

String str = "     ";
Optional<String> optStr = Optional.ofNullable(str);
if (optStr.isPresent()){
    System.out.println("Optional對象不爲空,返回值:" + optStr.orElse("null"));
}else {
    System.out.println("Optional對象爲空,返回默認值:" + optStr.orElse("null"));
}


打印結果:Optional對象不爲空,返回值:

可見,這類空字符串,在orElse判斷當中,跟StringUtils.isEmpty()類似,都是把它當成非空字符串,但是StringUtils.isBlank()則判斷爲空字符串。

4.2.5、orElseGet()方法

orElseGet()和orElse()類似,都可以提供一個默認值。兩者區別在於,orElse方法在每次調用時都會創建默認值,而orElseGet只在需要時纔會創建默認值。

4.3、Optional 和 null 的區別: Optional 類型與 null 值的異同。

兩者都可以表示缺失值的情況,兩者主要區別爲:Optional類型是一種包裝器對象,可以將一個可能爲空的對象包裝成一個Optional對象。這個對象可以通過調用ofNullable()of()或其他方法來創建。而null值則只是一個空引用,沒有任何實際的值。

Optional類型還可以避免出現NullPointerException異常,具體代碼案例如下:

String str = null;
//錯誤示範:直接調用str.length()方法會觸發NullPointerException
//int length = str.length()

//通過Optional類型避免NullPointerException
Optional<String> optionalStr = Optional.ofNullable(str);
if (optionalStr.isPresent()){//判斷Optional對象是否都包含非空值
    int length = optionalStr.get().length();
    System.out.println("字符串長度爲:" + length);
}else {
    System.out.println("字符串爲空!");
}

//使用map()方法對Optional對象進行轉換時,確保返回對結果不爲null
Optional<Integer> optionalLength = optionalStr.map(s -> s.length());
System.out.println("字符串長度爲:" + optionalLength.orElse(-1)); // 使用orElse()方法提供默認值

五、擴展流處理

除裏以上常用的流處理之外,Java8還新增了一些專門用來處理基本類型的流,例如IntStream、LongStream、DoubleStream等,其對應的Api接口基本與前面案例相似,讀者可以自行研究。

最後,需要注意一點是,在流處理過程當中,儘量使用原始類型數據,避免裝箱操作,因爲裝箱過程會有性能開銷、內存佔用等問題,例如,當原始數據int類型被裝箱成Integer包裝類型時,這個過程會涉及到對象的創建、初始化、垃圾回收等過程,需要額外的性能開銷。

以上,就是關於Java8流處理相關知識的總結,筆者水平有限,若存在有誤的地方,還需幫忙指正。

最後,碼字不易,歡迎關注、點贊、收藏,謝謝!

發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章