〇、總結
Stream流的方法：forEach、filter、map、count、limit、skip、concat（結合之前的Collectors接口）
方法引用：Lambda的其他類方法體相同，如System.out:println
一、Stream流
java.util.stream.Stream<T>
1、概述及傳統方式
- 與IO流不同，用于簡化集合和數組的操作，解決現有類庫的弊端
- 傳統方式周遊集合（逐一處理）：for循環、for-each、Iterator疊代器
package com.liujinhui.Day1208Stream;
import java.util.ArrayList;
import java.util.List;
/*
使用傳統方式周遊集合，對集合中的資料進行過濾
* */
public class Demo01List {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("張無忌");
list.add("周芷若");
list.add("趙敏");
list.add("張強");
list.add("張三豐");
//對list集合中的元素進行過濾，隻要以張開頭的元素，存儲到一個新的集合中
List<String> listA=new ArrayList<>();
for (String s : list) {
if (s.startsWith("張")){
listA.add(s);
}
}
//對listA集合進行過濾，隻要姓名長度為3的人
List<String> listB=new ArrayList<>();
for (String s : listA) {
if (s.length()==3){
listB.add(s);
}
}
//周遊listB集合
for (String s : listB) {
System.out.println(s);
}
}
} 需要過濾三遍
2、stream流的方式周遊+過濾
package com.liujinhui.Day1208Stream;
import java.util.ArrayList;
import java.util.List;
/*
使用stream流的方式，對集合中的資料進行過濾
Stream流失JDK1.8之後出現的
關注的是做什麼，而不是怎麼做
* */
public class Demo02ListStream {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("張無忌");
list.add("周芷若");
list.add("趙敏");
list.add("張強");
list.add("張三豐");
//對list集合中的元素進行過濾，隻要以張開頭的元素，存儲到一個新的集合中
//對listA集合進行過濾，隻要姓名長度為3的人
//周遊listB集合
list.stream()
.filter(name->name.startsWith("張"))
.filter(name->name.length()==3)
.forEach(name-> System.out.println(name));
}
} 3、流式思想
- 類似流水線，是對集合元素的處理方案
- 對模型操作，元素并未真正處理，之後最終count執行，才會執行操作
- 使用了Lambda的延遲執行特性
- Stream流是一個來自資料源的元素隊列，不存儲，而是按需計算
- Stream操作的特征：
- Pipelining：每個操作傳回流本身，多個操作串聯成管道
- 内部疊代：直接通過流調用周遊過程
- 之前都是顯式地在集合外部疊代周遊
4、兩種擷取流的方式
- 單列集合可以通過stream預設方法擷取流
- Stream接口的靜态方法可以擷取數組對應的流
package com.liujinhui.Day1208Stream;
import java.util.*;
import java.util.stream.Stream;
/*
兩種擷取Stream流的方式
所有的 Collection 集合都可以通過 stream 預設方法擷取流；
-default Stream<E> stream()傳回一個序列Stream與此集合作為其來源。
Stream 接口的靜态方法 of 可以擷取數組對應的流。
-static <T> Stream<T> of(T... values) 傳回其元素是指定值的順序排序流。
參數是一個可變參數，就可以傳遞一個數組
java.util.stream.Stream<T> 是Java 8新加入的最常用的流接口。（這并不是一個函數式接口。）
* */
public class Demo03GetStream {
public static void main(String[] args) {
//把集合轉換為Stream流
List<String> list=new ArrayList<>();
Stream<String> stream1=list.stream();
Set<String> set = new HashSet<>();
Stream<String> stream2 = set.stream();
Map<String,String> map=new HashMap<>();
//間接把map類型轉換為stream流
//擷取鍵，存儲到一個set集合中
Set<String> keySet = map.keySet();
Stream<String> stream3 = keySet.stream();
//擷取值，存儲到一個collection集合中
Collection<String> values = map.values();
Stream<String> stream4 = values.stream();
//擷取鍵值對（鍵與值的映射關系）
Set<Map.Entry<String, String>> entries = map.entrySet();
Stream<Map.Entry<String, String>> stream5 = entries.stream();
//把數組轉換為stream流
Stream<Integer> stream6 = Stream.of(1, 2, 3, 4, 5);
//可變參數可以傳遞數組
Integer[] arr={1,2,3,4,5};
Stream<Integer> stream7 = Stream.of(arr);
//字元串類型數組
String[] arr2={"a","bb","ccc"};
Stream<String> stream8 = Stream.of(arr2);
}
} 二、Stream流中的常用方法
0、概述
- 方法的分類
- 延遲方法：傳回值類型是Stream自身類型，支援鍊式調用（類似StringBuilder）
- 終結方法：不再傳回流自身類型，不支援鍊式調用。包括count和forEach方法
1、forEach()
package com.liujinhui.Day1208Stream;
import java.util.stream.Stream;
/*
Stream流中的常用方法_forEach
void forEach(Consumer<? super T> action);接收一個 Consumer 接口函數，會将每一個流元素交給該函數進行處理
java.util.function.Consumer<T>接口是一個消費型接口。 Consumer接口中包含抽象方法void accept(T t)，意為消費一個指定泛型的資料。
可以傳遞lambda表達式
簡單記：
forEach方法，用來周遊流中的資料
是一個終結方法，周遊之後就不能繼續調用stream流中的其他方法了
* */
public class Demo04ForEach {
public static void main(String[] args) {
//擷取一個stream流
Stream<String> stream = Stream.of("張三", "李四", "王五", "趙六", "田七");
//使用stream流中的forEach方法對stream流中的資料進行周遊
/*stream.forEach((String name)->{
System.out.println(name);
});*/
//lambda的優化
stream.forEach(name->System.out.println(name));
}
} 2、filter
- 将一個流轉換為另一個子集流
package com.liujinhui.Day1208Stream;
import java.util.stream.Stream;
/*
Stream流中的常用方法_filter
可以通過 filter 方法将一個流轉換成另一個子集流。方法簽名：
Stream<T> filter(Predicate<? super T> predicate);//判斷的接口test
Predicate接口中的抽象方法：
boolean test(T t);
* */
public class Demo05Stream_Filter {
public static void main(String[] args) {
//擷取一個stream流
Stream<String> stream = Stream.of("張三豐", "張翠山", "趙敏", "周芷若", "張無忌");
//使用stream流中的filter方法對stream流中的方法進行過濾
/*stream.filter((name)->{return name.startsWith("張");})
.filter(name->{return name.length()==3;})
.forEach((name)-> System.out.println(name));*/
Stream<String> stream2 = stream.filter((name) -> {
return name.startsWith("張");
});
stream2.forEach((name)->{
System.out.println(name);
});
}
} - 注意：Stream流隻能使用
3、map
- 将流中的元素映射到另一個流中
- <R> Stream<R> map(Function<? super T, ? extends R> mapper);
- java.util.stream.Function 函數式接口，唯一抽象方法apply
package com.liujinhui.Day1208Stream;
import java.util.stream.Stream;
/*
如果需要将流中的元素映射到另一個流中，可以使用 map 方法。
<R> Stream<R> map(Function<? super T, ? extends R> mapper);
java.util.stream.Function 函數式接口，其中唯一的抽象方法為：
R apply(T t);
* */
public class Demo06Stream_map {
public static void main(String[] args) {
//擷取一個String類型的stream流
Stream<String> stream = Stream.of("1", "2", "3", "4");
//使用map方法，将字元串類型的整數，轉換/映射為Integer類型的整數
Stream<Integer> stream2 = stream.map((String s) -> {
return Integer.parseInt(s);
});
stream2.forEach((i)-> System.out.println(i));
}
} 4、count
- 統計元素個數，傳回long值
package com.liujinhui.Day1208Stream;
import java.util.ArrayList;
import java.util.stream.Stream;
/*
Stream流中的常用方法_count 提供 count 方法來數一數其中的元素個數：
long count();傳回一個long值代表元素個數（不再像舊集合那樣是int值）。
【終結方法：使用之後不能再使用stream的其他方法】
* */
public class Demo07StreamCount {
public static void main(String[] args) {
//擷取一個Stream流
ArrayList<Integer> list=new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
Stream<Integer> stream = list.stream();
long count=stream.count();
System.out.println(count);//5
}
} 5、limit()
- 對流截取，隻取前n個
- 傳回截取後的流
package com.liujinhui.Day1208Stream;
import java.util.stream.Stream;
/*
limit 方法可以對流進行截取，隻取用前n個。
Stream<T> limit(long maxSize);
參數是一個long型，如果集合目前長度大于參數則進行截取；否則不進行操作
是延遲方法，傳回的是新的流，可以繼續調用流中的其他方法
* */
public class Demo08StreamLimit {
public static void main(String[] args) {
//擷取一個stream流
String[] arr={"美羊羊","喜洋洋","懶洋洋","灰太狼","紅太狼"};
Stream<String> stream = Stream.of(arr);
//使用limit方法對stream流中的元素進行截取，隻要前三個元素
Stream<String> stream1 = stream.limit(3);
//周遊stream2流
stream1.forEach((name)-> System.out.println(name));
}
} 6、skip
- 跳過前幾個元素，可以使用 skip 方法擷取一個截取之後的新流
- 流的目前長度大于n，則跳過前n個；否則将會得到一個長度為0的空流。
package com.liujinhui.Day1208Stream;
import java.util.stream.Stream;
/*
希望跳過前幾個元素，可以使用 skip 方法擷取一個截取之後的新流：
Stream<T> skip(long n);
如果流的目前長度大于n，則跳過前n個；否則将會得到一個長度為0的空流。基本使用：
* */
public class Demo09Skip {
public static void main(String[] args) {
//擷取一個stream流
String[] arr={"美羊羊","喜洋洋","懶洋洋","灰太狼","紅太狼"};
Stream<String> stream = Stream.of(arr);
//使用skip方法跳過前3個元素
Stream<String> stream1 = stream.skip(3);
stream1.forEach((name)-> System.out.println(name));
}
} 7、concat
- 合并兩個流，屬于Stream的靜态方法
- static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)
package com.liujinhui.Day1208Stream;
import java.util.stream.Stream;
/*
有兩個流，希望合并成為一個流，那麼可以使用 Stream 接口的靜态方法 concat ：
static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)
* */
public class Demo10Concate {
public static void main(String[] args) {
Stream<String> stream = Stream.of("張三豐", "張翠山", "趙敏", "周芷若", "張無忌");
String[] arr={"美羊羊","喜洋洋","懶洋洋","灰太狼","紅太狼"};
Stream<String> stream1 = Stream.of(arr);
//把以上兩個流組合為一個流
Stream<String> concat = Stream.concat(stream, stream1);
concat.forEach(name-> System.out.println(name));
}
} 8、練習：集合元素處理（傳統方式）
要求：有兩個 ArrayList 集合存儲隊伍當中的多個成員姓名，要求使用傳統的for循環（或增強for循環）依次進行以 下若幹操作步驟：
1. 第一個隊伍隻要名字為3個字的成員姓名；存儲到一個新集合中。
2. 第一個隊伍篩選之後隻要前3個人；存儲到一個新集合中。
3. 第二個隊伍隻要姓張的成員姓名；存儲到一個新集合中。
4. 第二個隊伍篩選之後不要前2個人；存儲到一個新集合中。
5. 将兩個隊伍合并為一個隊伍；存儲到一個新集合中。
6. 根據姓名建立 Person 對象；存儲到一個新集合中。
7. 列印整個隊伍的Person對象資訊。
package com.liujinhui.Day1208Stream;
import java.util.ArrayList;
/*
有兩個 ArrayList 集合存儲隊伍當中的多個成員姓名，要求使用傳統的for循環（或增強for循環）依次進行以 下若幹操作步驟：
1. 第一個隊伍隻要名字為3個字的成員姓名；存儲到一個新集合中。
2. 第一個隊伍篩選之後隻要前3個人；存儲到一個新集合中。
3. 第二個隊伍隻要姓張的成員姓名；存儲到一個新集合中。
4. 第二個隊伍篩選之後不要前2個人；存儲到一個新集合中。
5. 将兩個隊伍合并為一個隊伍；存儲到一個新集合中。
6. 根據姓名建立 Person 對象；存儲到一個新集合中。
7. 列印整個隊伍的Person對象資訊。
* */
public class DemoTestStream {
public static void main(String[] args) {
//第一支隊伍
ArrayList<String> one=new ArrayList<>();
one.add("張三");
one.add("李四");
one.add("王五六");
one.add("劉德華");
one.add("蘇有朋");
//1. 第一個隊伍隻要名字為3個字的成員姓名；存儲到一個新集合中。
ArrayList<String> one1=new ArrayList<>();
for (String name : one) {
if(name.length()==3){
one1.add(name);
}
}
//2. 第一個隊伍篩選之後隻要前3個人；存儲到一個新集合中。
ArrayList<String> one2=new ArrayList<>();
for(int i=0;i<3;i++){
one2.add(one1.get(i));//i=0,1,2
}
ArrayList<String> two=new ArrayList<>();
two.add("筷子兄弟");
two.add("玖月奇迹");
two.add("五月天");
two.add("鳳凰傳奇");
two.add("張靓穎");
two.add("張碧晨");
//3. 第二個隊伍隻要姓張的成員姓名；存儲到一個新集合中。
ArrayList<String> two1=new ArrayList<>();
for (String name : two) {
if (name.startsWith("張")){
two1.add(name);
}
}
//4. 第二個隊伍篩選之後不要前2個人；存儲到一個新集合中。
ArrayList<String> two2=new ArrayList<>();
for (int i=2;i<two1.size();i++){
two2.add(two1.get(i));//i不包含0和1
}
//5. 将兩個隊伍合并為一個隊伍；存儲到一個新集合中。
ArrayList<String> all=new ArrayList<>();
all.addAll(one2);
all.addAll(two2);
//6. 根據姓名建立 Person 對象；存儲到一個新集合中。
ArrayList<Person> list=new ArrayList<>();
for (String s : all) {
list.add(new Person(s));
}
for (Person person : list) {
System.out.println(person);
}
}
} 9、練習：集合元素處理（Stream方式）
package com.liujinhui.Day1208Stream;
import java.util.ArrayList;
import java.util.stream.Stream;
/*
有兩個 ArrayList 集合存儲隊伍當中的多個成員姓名，要求使用傳統的for循環（或增強for循環）依次進行以 下若幹操作步驟：
1. 第一個隊伍隻要名字為3個字的成員姓名；存儲到一個新集合中。
2. 第一個隊伍篩選之後隻要前3個人；存儲到一個新集合中。
3. 第二個隊伍隻要姓張的成員姓名；存儲到一個新集合中。
4. 第二個隊伍篩選之後不要前2個人；存儲到一個新集合中。
5. 将兩個隊伍合并為一個隊伍；存儲到一個新集合中。
6. 根據姓名建立 Person 對象；存儲到一個新集合中。
7. 列印整個隊伍的Person對象資訊。
* */
public class DemoTestStream {
public static void main(String[] args) {
//第一支隊伍
ArrayList<String> one=new ArrayList<>();
one.add("張三");
one.add("李四");
one.add("王五六");
one.add("劉德華");
one.add("蘇有朋");
/*
1. 第一個隊伍隻要名字為3個字的成員姓名；存儲到一個新集合中。
2. 第一個隊伍篩選之後隻要前3個人；存儲到一個新集合中。
* */
Stream<String> oneStream = one.stream().filter(name -> name.length() == 3).limit(3);
ArrayList<String> two=new ArrayList<>();
two.add("筷子兄弟");
two.add("玖月奇迹");
two.add("五月天");
two.add("鳳凰傳奇");
two.add("張靓穎");
two.add("張碧晨");
/*
3. 第二個隊伍隻要姓張的成員姓名；存儲到一個新集合中。
4. 第二個隊伍篩選之後不要前2個人；存儲到一個新集合中。
* */
Stream<String> twoStream = two.stream().filter(name -> name.startsWith("張")).skip(2);
/*
5. 将兩個隊伍合并為一個隊伍；存儲到一個新集合中。
6. 根據姓名建立 Person 對象；存儲到一個新集合中。
7. 列印整個隊伍的Person對象資訊。
* */
Stream.concat(oneStream, twoStream).map(name->new Person(name)).forEach(p-> System.out.println(p));
}
} 三、方法引用
1、基本使用
- Lambda所指定的操作方案，在其他地方存在相同方案，無需重寫邏輯
- 是Lambda的簡化 （引用其他類的方法體）
- 先自定義一個函數式接口
package com.liujinhui.Day1208Stream.MethodPreference;
/*
定義一個列印的函數式接口
* */
@FunctionalInterface
public interface Printable {
//列印字元串的抽象方法
public abstract void print(String s);
} - 定義成員方法，将字元串 按大寫輸出
package com.liujinhui.Day1208Stream.MethodPreference;
public class MethodReferenceObject {
//定義一個成員方法，傳遞字元串，把字元串按大寫輸出
public void printUpperCaseString(String str){
System.out.println(str.toUpperCase());
}
} - 定義方法，對字元串列印，在main方法中調用
package com.liujinhui.Day1208Stream.MethodPreference;
public class Demo01Printable {
//定義 一個方法，參數傳遞Printable接口，對字元串進行列印
public static void printString(Printable p){
p.print("helloworld");
}
public static void main(String[] args) {
//調用printString方法，方法的參數是一個函數式接口，可以傳遞lambda表達式
printString((String s)->{
System.out.println(s);
});
/*
分析：
Lambda表達式的目的，列印表達式傳遞的字元串
把參數s傳遞給了System.out對象，調用out對象中的方法Println對字元串進行輸出
注意：
1.System.out對象是已經存在的
2.println方法也是已經存在的
是以可以使用方法引用來優化lambda表達式
可以使用System.out方法直接調用println方法
* */
printString(System.out::println);
//雙冒号 :: 寫法，這被稱為“方法引用”，而雙冒号是一種新的文法。
}
} Lambda表達式寫法： s -> System.out.println(s);
方法引用寫法： System.out::println
第一種語義是指：拿到參數之後經Lambda之手，繼而傳遞給 System.out.println 方法去處理。
第二種等效寫法的語義是指：直接讓 System.out 中的 println 方法來取代Lambda。
兩種寫法的執行效果完全一 樣，而第二種方法引用的寫法複用了已有方案，更加簡潔。
Lambda 中傳遞的參數 一定是方法引用中的那個方法可以接收的類型,否則會抛出異常
2、通過對象名引用成員方法
package com.liujinhui.Day1208Stream.MethodPreference;
/*
通過對象名引用成員方法
使用前提是：對象名已經存在，成員方法也已經存在
就可以呀使用對象名引用成員方法
* */
public class Demo02ObjectMethodReference {
//定義一個方法，方法的參數傳遞Printable接口
public static void printString(Printable p){
p.print("hello");
}
public static void main(String[] args) {
//調用printString方法，方法的參數printable是一個函數式接口，是以可以傳遞lambda表達式
printString((s)->{
//建立MethodReferenceObject對象
MethodReferenceObject obj=new MethodReferenceObject();
//調用MethodReferenceObject中的成員方法printUpperCaseString，把字元串按照大寫輸出
obj.printUpperCaseString(s);
});
//使用方法引用優化Lambda
//MethodReferenceObject對象是已經存在的，成員方法也是已經存在的
//是以，可以使用對象名引用成員方法
MethodReferenceObject obj=new MethodReferenceObject();
printString(obj::printUpperCaseString);
}
} 3、通過類名引用靜态成員方法
package com.liujinhui.Day1208Stream.MethodPreference;
@FunctionalInterface
public interface Calcable {
//定義一個抽象方法，傳遞一個整數，對整數進行絕對值計算，并傳回
int calAbs(int num);
} 使用
package com.liujinhui.Day1208Stream.MethodPreference;
/*
通過類名引用靜态成員方法
類已經存在，靜态成員方法也已經存在
就可以通過類名直接引用靜态成員方法
* */
public class Demo03StaticMethodRef {
//定義一個方法，方法的參數傳遞要計算絕對值的整數和函數式接口Calcable
public static int method(int number,Calcable c){
return c.calSbs(number);
}
public static void main(String[] args) {
//調用method方法，傳遞計算絕對值的整數和lambda表達式
int number = method(-10, (n) -> {
//對參數進行絕對值的計算并傳回結果
return Math.abs(n);
});
System.out.println(number);
/*
使用方法引用優化lambda表達式
math類是存在的
abs計算絕對值的靜态方法也是已經存在的
是以，我們可以直接通過類名引用靜态方法
* */
int number2 = method(-10, Math::abs);
System.out.println(number2);
}
} 4、通過super引用父類的成員方法
如果存在繼承關系，當Lambda中需要出現super調用時，也可以使用方法引用進行替代。
Lambda表達式： () -> super.sayHello() 方法引用： super::sayHello
package com.liujinhui.Day1208Stream.SuperMethod;
/*
定義見面的函數式接口
* */
@FunctionalInterface
public interface Greetable {
//定義一個見面的方法
void greet();
} 定義成員方法
package com.liujinhui.Day1208Stream.SuperMethod;
/*
定義父類
* */
public class Human {
//定義一個sayHello的方法
public void sayHello(){
System.out.println("Hello,我是Human");
}
} 使用
package com.liujinhui.Day1208Stream.SuperMethod;
//定義子類
public class Man extends Human{
//子類重寫父類sayHello的方法
public void sayHello(){
System.out.println("Hello,我是Man");
}
//定義一個方法，參數傳遞Greetable接口
public void method(Greetable g){
g.greet();
}
public void show(){
//調用method方法，方法的參數胡Greetable是一個函數式接口，是以可以傳遞lambda
method(()->{
//建立父類Human對象
Human h=new Human();
//調用父類的sayHello方法
h.sayHello();
});
//因為存在子父類關系，是以存在一個關鍵字super代表父類
//可以直接使用super調用父類的成員方法
method(()->{
super.sayHello();
});
/*
使用super引用父類的成員方法
super是已經存在的
父類的成員方法sayHello也是已經存在的
是以，可以直接使用super引用父類的成員方法
* */
method(super::sayHello);
}
public static void main(String[] args) {
//匿名對象
new Man().show();
}
} 5、通過this引用本類成員方法
package com.liujinhui.Day1208Stream.ThisMethod;
/*
定義一個富有的函數式接口
* */
@FunctionalInterface
public interface Richable {
//定義一個想買什麼就買什麼的方法
void buy();
} 測試
package com.liujinhui.Day1208Stream.ThisMethod;
/*
通過this引用本類的成員方法
* */
public class Husband {
//定義一個買房子的方法
public void buyHouse(){
System.out.println("北京二環内買一套四合院");
}
//定義一個結婚的方法，參數傳遞Richable接口
public void marry(Richable r){
r.buy();
}
//定義一個非常高興的方法
public void soHappy(){
//調用結婚的方法，方法的參數Richable是一個函數式接口，可以傳遞lambda表達式
marry(()->{
//重寫buy，使用this.成員方法調用本類買房子的方法
this.buyHouse();
});
/*
使用方法引用優化lambda表達式
this是已經存在的
本類的成員方法buyHouse也是已經存在的
是以我們可以直接使用this引用本類的成員方法buyHouse
* */
marry(this::buyHouse);
}
public static void main(String[] args) {
new Husband().soHappy();
}
} 6、構造方法的引用
package com.liujinhui.Day1208Stream.ConstructorMethod;
/*
類的構造器（構造方法）引用
* */
public class Demo {
//定義一個方法，參數傳遞姓名和PersonBuilder接口，方法中通過姓名建立Person對象
public static void printName(String name,PersonBuilder pb){
Person person=pb.builderPerson(name);
System.out.println(person.getName());
}
public static void main(String[] args) {
//調用printName方法，方法的參數Personbuilder是一個函數式接口，可以傳遞lambda表達式
printName("迪麗熱巴",(String name)->{
return new Person(name);
});
/*
使用方法引用lambda表達式
構造方法new Person(String name)已知
建立對象已知 new
就可以使用Person引用new建立對象
* */
printName("古力娜紮",Person::new);//使用Person類的帶參構造方法，通過傳遞的姓名建立對象
}
} 7、數組的構造器引用
package com.liujinhui.Day1208Stream.ArrayMethodReference;
import java.util.Arrays;
/*
數組的構造器引用
* */
public class Demo {
/*
定義一個方法，方法的參數傳遞數組的長度和ArrayBuilder接口
方法内部根據傳遞的長度使用ArrayBuilder中的方法建立數組并傳回
* */
public static int[] createArray(int length,ArrayBuilder ab){
return ab.builderArray(length);
}
public static void main(String[] args) {
//調用createArray方法，傳遞數組的長度和lambda表達式
int[] array1 = createArray(10, (len) -> {
//根據數組的長度建立數組并傳回
return new int[len];
});
System.out.println(array1.length);//10
/*
使用方法引用優化lambda表達式
已知建立的就是int類型的數組
數組的長度也是已知的
就可以使用方法引用
int[]引用new，根據參數傳遞的長度建立數組
* */
int[] array2 = createArray(10, int[]::new);//傳回new的對象 類型::new
System.out.println(array2.length);
System.out.println(Arrays.toString(array2));
}
}