這篇文章主要介紹“Java數(shù)據(jù)流和函數(shù)式編程如何實現(xiàn)”,在日常操作中,相信很多人在Java數(shù)據(jù)流和函數(shù)式編程如何實現(xiàn)問題上存在疑惑,小編查閱了各式資料,整理出簡單好用的操作方法,希望對大家解答”Java數(shù)據(jù)流和函數(shù)式編程如何實現(xiàn)”的疑惑有所幫助!接下來,請跟著小編一起來學習吧!
創(chuàng)新互聯(lián)公司-專業(yè)網(wǎng)站定制、快速模板網(wǎng)站建設、高性價比余姚網(wǎng)站開發(fā)、企業(yè)建站全套包干低至880元,成熟完善的模板庫,直接使用。一站式余姚網(wǎng)站制作公司更省心,省錢,快速模板網(wǎng)站建設找我們,業(yè)務覆蓋余姚地區(qū)。費用合理售后完善,十多年實體公司更值得信賴。
流 API 是在數(shù)據(jù)序列中迭代元素的簡潔而高級的方法。包 java.util.stream
和 java.util.function
包含了用于流 API 和相關函數(shù)式編程構(gòu)造的新庫。當然,代碼示例勝過千言萬語。
下面的代碼段用大約 2,000 個隨機整數(shù)值填充了一個 List
:
Random rand = new Random2();List<Integer> list = new ArrayList<Integer>(); // 空 listfor (int i = 0; i < 2048; i++) list.add(rand.nextInt()); // 填充它
另外用一個 for
循環(huán)可用于遍歷填充列表,以將偶數(shù)值收集到另一個列表中。
流 API 提供了一種更簡潔的方法來執(zhí)行此操作:
List <Integer> evens = list .stream() // 流化 list .filter(n -> (n & 0x1) == 0) // 過濾出奇數(shù)值 .collect(Collectors.toList()); // 收集偶數(shù)值
這個例子有三個來自流 API 的函數(shù):
stream
函數(shù)可以將集合轉(zhuǎn)換為流,而流是一個每次可訪問一個值的傳送帶。流化是惰性的(因此也是高效的),因為值是根據(jù)需要產(chǎn)生的,而不是一次性產(chǎn)生的。
filter
函數(shù)確定哪些流的值(如果有的話)通過了處理管道中的下一個階段,即 collect
階段。filter
函數(shù)是
,因為它的參數(shù)是一個函數(shù) —— 在這個例子中是一個 lambda 表達式,它是一個未命名的函數(shù),并且是 Java 新的函數(shù)式編程結(jié)構(gòu)的核心。
lambda 語法與傳統(tǒng)的 Java 完全不同:
n -> (n & 0x1) == 0
箭頭(一個減號后面緊跟著一個大于號)將左邊的參數(shù)列表與右邊的函數(shù)體分隔開。參數(shù) n
雖未明確類型,但也可以明確。在任何情況下,編譯器都會發(fā)現(xiàn) n
是個 Integer
。如果有多個參數(shù),這些參數(shù)將被括在括號中,并用逗號分隔。
在本例中,函數(shù)體檢查一個整數(shù)的最低位(最右)是否為零,這用來表示偶數(shù)。過濾器應返回一個布爾值。盡管可以,但該函數(shù)的主體中沒有顯式的 return
。如果主體沒有顯式的 return
,則主體的最后一個表達式即是返回值。在這個例子中,主體按照 lambda 編程的思想編寫,由一個簡單的布爾表達式 (n & 0x1) == 0
組成。
collect
函數(shù)將偶數(shù)值收集到引用為 evens
的列表中。如下例所示,collect
函數(shù)是線程安全的,因此,即使在多個線程之間共享了過濾操作,該函數(shù)也可以正常工作。
在生產(chǎn)環(huán)境中,數(shù)據(jù)流的源可能是文件或網(wǎng)絡連接。為了學習流 API, Java 提供了諸如 IntStream
這樣的類型,它可以用各種類型的元素生成流。這里有一個 IntStream
的例子:
IntStream // 整型流 .range(1, 2048) // 生成此范圍內(nèi)的整型流 .parallel() // 為多個線程分區(qū)數(shù)據(jù) .filter(i -> ((i & 0x1) > 0)) // 奇偶校驗 - 只允許奇數(shù)通過 .forEach(System.out::println); // 打印每個值
IntStream
類型包括一個 range
函數(shù),該函數(shù)在指定的范圍內(nèi)生成一個整數(shù)值流,在本例中,以 1 為增量,從 1 遞增到 2048。parallel
函數(shù)自動劃分該工作到多個線程中,在各個線程中進行過濾和打印。(線程數(shù)通常與主機系統(tǒng)上的 CPU 數(shù)量匹配。)函數(shù) forEach
參數(shù)是一個方法引用,在本例中是對封裝在 System.out
中的 println
方法的引用,方法輸出類型為 PrintStream
。方法和構(gòu)造器引用的語法將在稍后討論。
由于具有多線程,因此整數(shù)值整體上以任意順序打印,但在給定線程中是按順序打印的。例如,如果線程 T1 打印 409 和 411,那么 T1 將按照順序 409-411 打印,但是其它某個線程可能會預先打印 2045。parallel
調(diào)用后面的線程是并發(fā)執(zhí)行的,因此它們的輸出順序是不確定的。
map/reduce 模式在處理大型數(shù)據(jù)集方面變得很流行。一個 map/reduce 宏操作由兩個微操作構(gòu)成。首先,將數(shù)據(jù)分散()到各個工作程序中,然后將單獨的結(jié)果收集在一起 —— 也可能收集統(tǒng)計起來成為一個值,即。歸約可以采用不同的形式,如以下示例所示。
下面 Number
類的實例用 EVEN
或 ODD
表示有奇偶校驗的整數(shù)值:
public class Number { enum Parity { EVEN, ODD } private int value; public Number(int n) { setValue(n); } public void setValue(int value) { this.value = value; } public int getValue() { return this.value; } public Parity getParity() { return ((value & 0x1) == 0) ? Parity.EVEN : Parity.ODD; } public void dump() { System.out.format("Value: %2d (parity: %s)\n", getValue(), (getParity() == Parity.ODD ? "odd" : "even")); }}
下面的代碼演示了用 Number
流進行 map/reduce 的情形,從而表明流 API 不僅可以處理 int
和 float
等基本類型,還可以處理程序員自定義的類類型。
在下面的代碼段中,使用了 parallelStream
而不是 stream
函數(shù)對隨機整數(shù)值列表進行流化處理。與前面介紹的 parallel
函數(shù)一樣,parallelStream
變體也可以自動執(zhí)行多線程。
final int howMany = 200;Random r = new Random();Number[] nums = new Number[howMany];for (int i = 0; i < howMany; i++) nums[i] = new Number(r.nextInt(100));List<Number> listOfNums = Arrays.asList(nums); // 將數(shù)組轉(zhuǎn)化為 list Integer sum4All = listOfNums .parallelStream() // 自動執(zhí)行多線程 .mapToInt(Number::getValue) // 使用方法引用,而不是 lambda .sum(); // 將流值計算出和值System.out.println("The sum of the randomly generated values is: " + sum4All);
高階的 mapToInt
函數(shù)可以接受一個 lambda 作為參數(shù),但在本例中,它接受一個方法引用,即 Number::getValue
。getValue
方法不需要參數(shù),它返回給定的 Number
實例的 int
值。語法并不復雜:類名 Number
后跟一個雙冒號和方法名。回想一下先前的例子 System.out::println
,它在 System
類中的 static
屬性 out
后面有一個雙冒號。
方法引用 Number::getValue
可以用下面的 lambda 表達式替換。參數(shù) n
是流中的 Number
實例中的之一:
mapToInt(n -> n.getValue())
通常,lambda 表達式和方法引用是可互換的:如果像 mapToInt
這樣的高階函數(shù)可以采用一種形式作為參數(shù),那么這個函數(shù)也可以采用另一種形式。這兩個函數(shù)式編程結(jié)構(gòu)具有相同的目的 —— 對作為參數(shù)傳入的數(shù)據(jù)執(zhí)行一些自定義操作。在兩者之間進行選擇通常是為了方便。例如,lambda 可以在沒有封裝類的情況下編寫,而方法則不能。我的習慣是使用 lambda,除非已經(jīng)有了適當?shù)姆庋b方法。
當前示例末尾的 sum
函數(shù)通過結(jié)合來自 parallelStream
線程的部分和,以線程安全的方式進行歸約。但是,程序員有責任確保在 parallelStream
調(diào)用引發(fā)的多線程過程中,程序員自己的函數(shù)調(diào)用(在本例中為 getValue
)是線程安全的。
最后一點值得強調(diào)。lambda 語法鼓勵編寫,即函數(shù)的返回值僅取決于傳入的參數(shù)(如果有);純函數(shù)沒有副作用,例如更新一個類中的 static
字段。因此,純函數(shù)是線程安全的,并且如果傳遞給高階函數(shù)的函數(shù)參數(shù)(例如 filter
和 map
)是純函數(shù),則流 API 效果最佳。
對于更細粒度的控制,有另一個流 API 函數(shù),名為 reduce
,可用于對 Number
流中的值求和:
Integer sum4AllHarder = listOfNums .parallelStream() // 多線程 .map(Number::getValue) // 每個 Number 的值 .reduce(0, (sofar, next) -> sofar + next); // 求和
此版本的 reduce
函數(shù)帶有兩個參數(shù),第二個參數(shù)是一個函數(shù):
第一個參數(shù)(在這種情況下為零)是特征值,該值用作求和操作的初始值,并且在求和過程中流結(jié)束時用作默認值。
第二個參數(shù)是累加器,在本例中,這個 lambda 表達式有兩個參數(shù):第一個參數(shù)(sofar
)是正在運行的和,第二個參數(shù)(next
)是來自流的下一個值。運行的和以及下一個值相加,然后更新累加器。請記住,由于開始時調(diào)用了 parallelStream
,因此 map
和 reduce
函數(shù)現(xiàn)在都在多線程上下文中執(zhí)行。
在到目前為止的示例中,流值被收集,然后被規(guī)約,但是,通常情況下,流 API 中的 Collectors
可以累積值,而不需要將它們規(guī)約到單個值。正如下一個代碼段所示,收集活動可以生成任意豐富的數(shù)據(jù)結(jié)構(gòu)。該示例使用與前面示例相同的 listOfNums
:
Map<Number.Parity, List<Number>> numMap = listOfNums .parallelStream() .collect(Collectors.groupingBy(Number::getParity)); List<Number> evens = numMap.get(Number.Parity.EVEN);List<Number> odds = numMap.get(Number.Parity.ODD);
第一行中的 numMap
指的是一個 Map
,它的鍵是一個 Number
奇偶校驗位(ODD
或 EVEN
),其值是一個具有指定奇偶校驗位值的 Number
實例的 List
。同樣,通過 parallelStream
調(diào)用進行多線程處理,然后 collect
調(diào)用(以線程安全的方式)將部分結(jié)果組裝到 numMap
引用的 Map
中。然后,在 numMap
上調(diào)用 get
方法兩次,一次獲取 evens
,第二次獲取 odds
。
實用函數(shù) dumpList
再次使用來自流 API 的高階 forEach
函數(shù):
private void dumpList(String msg, List<Number> list) { System.out.println("\n" + msg); list.stream().forEach(n -> n.dump()); // 或者使用 forEach(Number::dump)}
這是示例運行中程序輸出的一部分:
The sum of the randomly generated values is: 3322The sum again, using a different method: 3322 Evens: Value: 72 (parity: even)Value: 54 (parity: even)...Value: 92 (parity: even) Odds: Value: 35 (parity: odd)Value: 37 (parity: odd)...Value: 41 (parity: odd)
函數(shù)式結(jié)構(gòu)(如方法引用和 lambda 表達式)非常適合在流 API 中使用。這些構(gòu)造代表了 Java 中對高階函數(shù)的主要簡化。即使在糟糕的過去,Java 也通過 Method
和 Constructor
類型在技術上支持高階函數(shù),這些類型的實例可以作為參數(shù)傳遞給其它函數(shù)。由于其復雜性,這些類型在生產(chǎn)級 Java 中很少使用。例如,調(diào)用 Method
需要對象引用(如果方法是非靜態(tài)的)或至少一個類標識符(如果方法是靜態(tài)的)。然后,被調(diào)用的 Method
的參數(shù)作為對象實例傳遞給它,如果沒有發(fā)生多態(tài)(那會出現(xiàn)另一種復雜性!),則可能需要顯式向下轉(zhuǎn)換。相比之下,lambda 和方法引用很容易作為參數(shù)傳遞給其它函數(shù)。
但是,新的函數(shù)式結(jié)構(gòu)在流 API 之外具有其它用途??紤]一個 Java GUI 程序,該程序帶有一個供用戶按下的按鈕,例如,按下以獲取當前時間。按鈕按下的事件處理程序可能編寫如下:
JButton updateCurrentTime = new JButton("Update current time");updateCurrentTime.addActionListener(new ActionListener() { @Override public void actionPerformed(ActionEvent e) { currentTime.setText(new Date().toString()); }});
這個簡短的代碼段很難解釋。關注第二行,其中方法 addActionListener
的參數(shù)開始如下:
new ActionListener() {
這似乎是錯誤的,因為 ActionListener
是一個抽象接口,而抽象類型不能通過調(diào)用 new
實例化。但是,事實證明,還有其它一些實例被實例化了:一個實現(xiàn)此接口的未命名內(nèi)部類。如果上面的代碼封裝在名為 OldJava
的類中,則該未命名的內(nèi)部類將被編譯為 OldJava$1.class
。actionPerformed
方法在這個未命名的內(nèi)部類中被重寫。
現(xiàn)在考慮使用新的函數(shù)式結(jié)構(gòu)進行這個令人耳目一新的更改:
updateCurrentTime.addActionListener(e -> currentTime.setText(new Date().toString()));
lambda 表達式中的參數(shù) e
是一個 ActionEvent
實例,而 lambda 的主體是對按鈕上的 setText
的簡單調(diào)用。
到目前為止,使用的 lambda 已經(jīng)寫好了。但是,為了方便起見,我們可以像引用封裝方法一樣引用 lambda 表達式。以下一系列簡短示例說明了這一點。
考慮以下接口定義:
@FunctionalInterface // 可選,通常省略interface BinaryIntOp { abstract int compute(int arg1, int arg2); // abstract 聲明可以被刪除}
注釋 @FunctionalInterface
適用于聲明唯一抽象方法的任何接口;在本例中,這個抽象接口是 compute
。一些標準接口,(例如具有唯一聲明方法 run
的 Runnable
接口)同樣符合這個要求。在此示例中,compute
是已聲明的方法。該接口可用作引用聲明中的目標類型:
BinaryIntOp div = (arg1, arg2) -> arg1 / arg2;div.compute(12, 3); // 4
包 java.util.function
提供各種函數(shù)式接口。以下是一些示例。
下面的代碼段介紹了參數(shù)化的 Predicate
函數(shù)式接口。在此示例中,帶有參數(shù) String
的 Predicate<String>
類型可以引用具有 String
參數(shù)的 lambda 表達式或諸如 isEmpty
之類的 String
方法。通常情況下,Predicate 是一個返回布爾值的函數(shù)。
Predicate<String> pred = String::isEmpty; // String 方法的 predicate 聲明String[] strings = {"one", "two", "", "three", "four"};Arrays.asList(strings) .stream() .filter(pred) // 過濾掉非空字符串 .forEach(System.out::println); // 只打印空字符串
在字符串長度為零的情況下,isEmpty
Predicate 判定結(jié)果為 true
。 因此,只有空字符串才能進入管道的 forEach
階段。
下一段代碼將演示如何將簡單的 lambda 或方法引用組合成更豐富的 lambda 或方法引用。考慮這一系列對 IntUnaryOperator
類型的引用的賦值,它接受一個整型參數(shù)并返回一個整型值:
IntUnaryOperator doubled = n -> n * 2;IntUnaryOperator tripled = n -> n * 3;IntUnaryOperator squared = n -> n * n;
IntUnaryOperator
是一個 FunctionalInterface
,其唯一聲明的方法為 applyAsInt
?,F(xiàn)在可以單獨使用或以各種組合形式使用這三個引用 doubled
、tripled
和 squared
:
int arg = 5;doubled.applyAsInt(arg); // 10tripled.applyAsInt(arg); // 15squared.applyAsInt(arg); // 25
以下是一些函數(shù)組合的樣例:
int arg = 5;doubled.compose(squared).applyAsInt(arg); // 5 求 2 次方后乘 2:50tripled.compose(doubled).applyAsInt(arg); // 5 乘 2 后再乘 3:30doubled.andThen(squared).applyAsInt(arg); // 5 乘 2 后求 2 次方:100squared.andThen(tripled).applyAsInt(arg); // 5 求 2 次方后乘 3:75
函數(shù)組合可以直接使用 lambda 表達式實現(xiàn),但是引用使代碼更簡潔。
構(gòu)造器引用是另一種函數(shù)式編程構(gòu)造,而這些引用在比 lambda 和方法引用更微妙的上下文中非常有用。再一次重申,代碼示例似乎是最好的解釋方式。
考慮這個 POJO 類:
public class BedRocker { // 基巖的居民 private String name; public BedRocker(String name) { this.name = name; } public String getName() { return this.name; } public void dump() { System.out.println(getName()); }}
該類只有一個構(gòu)造函數(shù),它需要一個 String
參數(shù)。給定一個名字數(shù)組,目標是生成一個 BedRocker
元素數(shù)組,每個名字代表一個元素。下面是使用了函數(shù)式結(jié)構(gòu)的代碼段:
String[] names = {"Fred", "Wilma", "Peebles", "Dino", "Baby Puss"}; Stream<BedRocker> bedrockers = Arrays.asList(names).stream().map(BedRocker::new);BedRocker[] arrayBR = bedrockers.toArray(BedRocker[]::new); Arrays.asList(arrayBR).stream().forEach(BedRocker::dump);
在較高的層次上,這個代碼段將名字轉(zhuǎn)換為 BedRocker
數(shù)組元素。具體來說,代碼如下所示。Stream
接口(在包 java.util.stream
中)可以被參數(shù)化,而在本例中,生成了一個名為 bedrockers
的 BedRocker
流。
Arrays.asList
實用程序再次用于流化一個數(shù)組 names
,然后將流的每一項傳遞給 map
函數(shù),該函數(shù)的參數(shù)現(xiàn)在是構(gòu)造器引用 BedRocker::new
。這個構(gòu)造器引用通過在每次調(diào)用時生成和初始化一個 BedRocker
實例來充當一個對象工廠。在第二行執(zhí)行之后,名為 bedrockers
的流由五項 BedRocker
組成。
這個例子可以通過關注高階 map
函數(shù)來進一步闡明。在通常情況下,一個映射將一個類型的值(例如,一個 int
)轉(zhuǎn)換為另一個相同類型的值(例如,一個整數(shù)的后繼):
map(n -> n + 1) // 將 n 映射到其后繼
然而,在 BedRocker
這個例子中,轉(zhuǎn)換更加戲劇化,因為一個類型的值(代表一個名字的 String
)被映射到一個不同類型的值,在這個例子中,就是一個 BedRocker
實例,這個字符串就是它的名字。轉(zhuǎn)換是通過一個構(gòu)造器調(diào)用來完成的,它是由構(gòu)造器引用來實現(xiàn)的:
map(BedRocker::new) // 將 String 映射到 BedRocker
傳遞給構(gòu)造器的值是 names
數(shù)組中的其中一項。
此代碼示例的第二行還演示了一個你目前已經(jīng)非常熟悉的轉(zhuǎn)換:先將數(shù)組先轉(zhuǎn)換成 List
,然后再轉(zhuǎn)換成 Stream
:
Stream<BedRocker> bedrockers = Arrays.asList(names).stream().map(BedRocker::new);
第三行則是另一種方式 —— 流 bedrockers
通過使用數(shù)組構(gòu)造器引用 BedRocker[]::new
調(diào)用 toArray
方法:
BedRocker[ ] arrayBR = bedrockers.toArray(BedRocker[]::new);
該構(gòu)造器引用不會創(chuàng)建單個 BedRocker
實例,而是創(chuàng)建這些實例的整個數(shù)組:該構(gòu)造器引用現(xiàn)在為 BedRocker[]:new
,而不是 BedRocker::new
。為了進行確認,將 arrayBR
轉(zhuǎn)換為 List
,再次對其進行流式處理,以便可以使用 forEach
來打印 BedRocker
的名字。
FredWilmaPeeblesDinoBaby Puss
該示例對數(shù)據(jù)結(jié)構(gòu)的微妙轉(zhuǎn)換僅用幾行代碼即可完成,從而突出了可以將 lambda,方法引用或構(gòu)造器引用作為參數(shù)的各種高階函數(shù)的功能。
柯里化函數(shù)是指減少函數(shù)執(zhí)行任何工作所需的顯式參數(shù)的數(shù)量(通常減少到一個)。(該術語是為了紀念邏輯學家 Haskell Curry。)一般來說,函數(shù)的參數(shù)越少,調(diào)用起來就越容易,也更健壯。(回想一下一些需要半打左右參數(shù)的噩夢般的函數(shù)?。┮虼?,應將柯里化視為簡化函數(shù)調(diào)用的一種嘗試。java.util.function
包中的接口類型適合于柯里化,如以下示例所示。
引用的 IntBinaryOperator
接口類型是為函數(shù)接受兩個整型參數(shù),并返回一個整型值:
IntBinaryOperator mult2 = (n1, n2) -> n1 * n2;mult2.applyAsInt(10, 20); // 200mult2.applyAsInt(10, 30); // 300
引用 mult2
強調(diào)了需要兩個顯式參數(shù),在本例中是 10 和 20。
前面介紹的 IntUnaryOperator
比 IntBinaryOperator
簡單,因為前者只需要一個參數(shù),而后者則需要兩個參數(shù)。兩者均返回整數(shù)值。因此,目標是將名為 mult2
的兩個參數(shù) IntBinraryOperator
柯里化成一個單一的 IntUnaryOperator
版本 curriedMult2
。
考慮 IntFunction<R>
類型。此類型的函數(shù)采用整型參數(shù),并返回類型為 R
的結(jié)果,該結(jié)果可以是另一個函數(shù) —— 更準確地說,是 IntBinaryOperator
。讓一個 lambda 返回另一個 lambda 很簡單:
arg1 -> (arg2 -> arg1 * arg2) // 括號可以省略
完整的 lambda 以 arg1
開頭,而該 lambda 的主體以及返回的值是另一個以 arg2
開頭的 lambda。返回的 lambda 僅接受一個參數(shù)(arg2
),但返回了兩個數(shù)字的乘積(arg1
和 arg2
)。下面的概述,再加上代碼,應該可以更好地進行說明。
以下是如何柯里化 mult2
的概述:
類型為 IntFunction<IntUnaryOperator>
的 lambda 被寫入并調(diào)用,其整型值為 10。返回的 IntUnaryOperator
緩存了值 10,因此變成了已柯里化版本的 mult2
,在本例中為 curriedMult2
。
然后使用單個顯式參數(shù)(例如,20)調(diào)用 curriedMult2
函數(shù),該參數(shù)與緩存的參數(shù)(在本例中為 10)相乘以生成返回的乘積。。
這是代碼的詳細信息:
// 創(chuàng)建一個接受一個參數(shù) n1 并返回一個單參數(shù) n2 -> n1 * n2 的函數(shù),該函數(shù)返回一個(n1 * n2 乘積的)整型數(shù)。IntFunction<IntUnaryOperator> curriedMult2Maker = n1 -> (n2 -> n1 * n2);
調(diào)用 curriedMult2Maker
生成所需的 IntUnaryOperator
函數(shù):
// 使用 curriedMult2Maker 獲取已柯里化版本的 mult2。// 參數(shù) 10 是上面的 lambda 的 n1。IntUnaryOperator curriedMult2 = curriedMult2Maker2.apply(10);
值 10
現(xiàn)在緩存在 curriedMult2
函數(shù)中,以便 curriedMult2
調(diào)用中的顯式整型參數(shù)乘以 10:
curriedMult2.applyAsInt(20); // 200 = 10 * 20curriedMult2.applyAsInt(80); // 800 = 10 * 80
緩存的值可以隨意更改:
curriedMult2 = curriedMult2Maker.apply(50); // 緩存 50curriedMult2.applyAsInt(101); // 5050 = 101 * 50
當然,可以通過這種方式創(chuàng)建多個已柯里化版本的 mult2
,每個版本都有一個 IntUnaryOperator
。
柯里化充分利用了 lambda 的強大功能:可以很容易地編寫 lambda 表達式來返回需要的任何類型的值,包括另一個 lambda。
到此,關于“Java數(shù)據(jù)流和函數(shù)式編程如何實現(xiàn)”的學習就結(jié)束了,希望能夠解決大家的疑惑。理論與實踐的搭配能更好的幫助大家學習,快去試試吧!若想繼續(xù)學習更多相關知識,請繼續(xù)關注創(chuàng)新互聯(lián)網(wǎng)站,小編會繼續(xù)努力為大家?guī)砀鄬嵱玫奈恼拢?/p>
本文題目:Java數(shù)據(jù)流和函數(shù)式編程如何實現(xiàn)
當前地址:http://www.muchs.cn/article12/gehsgc.html
成都網(wǎng)站建設公司_創(chuàng)新互聯(lián),為您提供企業(yè)網(wǎng)站制作、移動網(wǎng)站建設、品牌網(wǎng)站制作、電子商務、微信小程序、動態(tài)網(wǎng)站
聲明:本網(wǎng)站發(fā)布的內(nèi)容(圖片、視頻和文字)以用戶投稿、用戶轉(zhuǎn)載內(nèi)容為主,如果涉及侵權(quán)請盡快告知,我們將會在第一時間刪除。文章觀點不代表本網(wǎng)站立場,如需處理請聯(lián)系客服。電話:028-86922220;郵箱:631063699@qq.com。內(nèi)容未經(jīng)允許不得轉(zhuǎn)載,或轉(zhuǎn)載時需注明來源: 創(chuàng)新互聯(lián)