基礎特性
流 API 是在資料序列中迭代元素的簡潔而進階的方法。套件 java.util.stream
和 java.util.function
包含了用於流 API 和相關函數式程式設計建構的新函式庫。當然,程式碼範例勝過千言萬語。
下面的程式碼片段用大約2,000 個隨機整數值填入了一個 List
:
Random rand = new Random2();List<integer> list = new ArrayList<integer>(); // 空 listfor (int i = 0; i <p>另外用一個 <code>for</code> 迴圈可用來遍歷填充列表,以將偶數值收集到另一個列表中。 </p> <p>串流API 提供了一個更簡潔的方法來執行此操作:</p> <pre class="brush:php;toolbar:false">List <integer> evens = list .stream() // 流化 list .filter(n -> (n & 0x1) == 0) // 过滤出奇数值 .collect(Collectors.toList()); // 收集偶数值</integer>
這個範例有三個來自流API 的函數:
stream
函數可以將集合轉換為流,而流則是每次可存取一個值的傳送帶。流化是惰性的(因此也是高效的),因為值是根據需要產生的,而不是一次性產生的。-
filter
函數決定哪些流的值(如果有的話)通過了處理管道中的下一個階段,即collect
階段。filter
函數是,因為它的參數是一個函數—— 在這個例子中是一個lambda 表達式,它是一個未命名的函數,並且是Java 新的函數式程式設計結構的核心。
lambda 語法與傳統的Java 完全不同:
n -> (n & 0x1) == 0
箭頭(一個減號後面緊跟著一個大於號)將左邊的參數列表與右邊的函數體分隔開。參數 n
雖然未明確類型,但也可以明確。在任何情況下,編譯器都會發現 n
是個 Integer
。如果有多個參數,這些參數將被括在括號中,並用逗號分隔。
在本例中,函數體檢查一個整數的最低位元(最右)是否為零,這用來表示偶數。過濾器應傳回一個布林值。雖然可以,但該函數的主體中沒有明確的 return
。如果主體沒有明確的 return
,則主體的最後一個表達式就是回傳值。在這個例子中,主體按照 lambda 程式設計的想法編寫,由一個簡單的布林表達式 (n & 0x1) == 0
組成。
collect
函數將偶數值收集到引用為evens
的清單中。如下例所示,collect
函數是執行緒安全的,因此,即使在多個執行緒之間共享了過濾操作,該函數也可以正常運作。
方便的功能和輕鬆實作多執行緒
在生產環境中,資料流的來源可能是檔案或網路連線。為了學習流 API, Java 提供了諸如 IntStream
這樣的類型,它可以用各種類型的元素產生流。這裡有一個 IntStream
的範例:
IntStream // 整型流 .range(1, 2048) // 生成此范围内的整型流 .parallel() // 为多个线程分区数据 .filter(i -> ((i & 0x1) > 0)) // 奇偶校验 - 只允许奇数通过 .forEach(System.out::println); // 打印每个值
IntStream
型別包含一個 range
函數,該函數在指定的範圍內產生一個整數值流,在本例中,以1 為增量,從1 遞增到2048。 parallel
函數會自動分割該工作到多個執行緒中,在各個執行緒中進行過濾和列印。 (執行緒數通常與主機系統上的CPU 數量相符。)函數 forEach
參數是一個方法參考,在本例中是對封裝在 #System.out
中的 println
方法的引用,方法輸出型別為 PrintStream
。方法和構造器引用的語法將在稍後討論。
由於具有多線程,因此整數值整體上以任意順序列印,但在給定線程中是按順序列印的。例如,如果線程 T1 打印 409 和 411,那麼 T1 將按照順序 409-411 打印,但是其它某個線程可能會預先打印 2045。 parallel
呼叫後面的執行緒是並發執行的,因此它們的輸出順序是不確定的。
map/reduce 模式
map/reduce 模式在處理大型資料集方面變得很流行。一個 map/reduce 宏操作由兩個微操作所構成。首先,將資料分散()到各個工作程序中,然後將單獨的結果收集在一起 —— 也可能收集統計起來成為一個值,即。歸約可以採用不同的形式,如下例所示。
下面 Number
類別的實例用 EVEN
或 ODD
表示有奇偶校驗的整數值:
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
函数对随机整数值列表进行流化处理。与前面介绍的 parallel
函数一样,parallelStream
变体也可以自动执行多线程。
final int howMany = 200;Random r = new Random();Number[] nums = new Number[howMany];for (int i = 0; i listOfNums = Arrays.asList(nums); // 将数组转化为 list Integer sum4All = listOfNums .parallelStream() // 自动执行多线程 .mapToInt(Number::getValue) // 使用方法引用,而不是 lambda .sum(); // 将流值计算出和值System.out.println("The sum of the randomly generated values is: " + sum4All);
高阶的 mapToInt
函数可以接受一个 lambda 作为参数,但在本例中,它接受一个方法引用,即 Number::getValue
。getValue
方法不需要参数,它返回给定的 Number
实例的 int
值。语法并不复杂:类名 Number
后跟一个双冒号和方法名。回想一下先前的例子 System.out::println
,它在 System
类中的 static
属性 out
后面有一个双冒号。
方法引用 Number::getValue
可以用下面的 lambda 表达式替换。参数 n
是流中的 Number
实例中的之一:
mapToInt(n -> n.getValue())
通常,lambda 表达式和方法引用是可互换的:如果像 mapToInt
这样的高阶函数可以采用一种形式作为参数,那么这个函数也可以采用另一种形式。这两个函数式编程结构具有相同的目的 —— 对作为参数传入的数据执行一些自定义操作。在两者之间进行选择通常是为了方便。例如,lambda 可以在没有封装类的情况下编写,而方法则不能。我的习惯是使用 lambda,除非已经有了适当的封装方法。
当前示例末尾的 sum
函数通过结合来自 parallelStream
线程的部分和,以线程安全的方式进行归约。但是,程序员有责任确保在 parallelStream
调用引发的多线程过程中,程序员自己的函数调用(在本例中为 getValue
)是线程安全的。
最后一点值得强调。lambda 语法鼓励编写,即函数的返回值仅取决于传入的参数(如果有);纯函数没有副作用,例如更新一个类中的 static
字段。因此,纯函数是线程安全的,并且如果传递给高阶函数的函数参数(例如 filter
和 map
)是纯函数,则流 API 效果最佳。
对于更细粒度的控制,有另一个流 API 函数,名为 reduce
,可用于对 Number
流中的值求和:
Integer sum4AllHarder = listOfNums .parallelStream() // 多线程 .map(Number::getValue) // 每个 Number 的值 .reduce(0, (sofar, next) -> sofar + next); // 求和
此版本的 reduce
函数带有两个参数,第二个参数是一个函数:
第一个参数(在这种情况下为零)是特征值,该值用作求和操作的初始值,并且在求和过程中流结束时用作默认值。
第二个参数是累加器,在本例中,这个 lambda 表达式有两个参数:第一个参数(
sofar
)是正在运行的和,第二个参数(next
)是来自流的下一个值。运行的和以及下一个值相加,然后更新累加器。请记住,由于开始时调用了parallelStream
,因此map
和reduce
函数现在都在多线程上下文中执行。
在到目前为止的示例中,流值被收集,然后被规约,但是,通常情况下,流 API 中的 Collectors
可以累积值,而不需要将它们规约到单个值。正如下一个代码段所示,收集活动可以生成任意丰富的数据结构。该示例使用与前面示例相同的 listOfNums
:
Map<number.parity>> numMap = listOfNums .parallelStream() .collect(Collectors.groupingBy(Number::getParity)); List<number> evens = numMap.get(Number.Parity.EVEN);List<number> odds = numMap.get(Number.Parity.ODD);</number></number></number.parity>
第一行中的 numMap
指的是一个 Map
,它的键是一个 Number
奇偶校验位(ODD
或 EVEN
),其值是一个具有指定奇偶校验位值的 Number
实例的 List
。同样,通过 parallelStream
调用进行多线程处理,然后 collect
调用(以线程安全的方式)将部分结果组装到 numMap
引用的 Map
中。然后,在 numMap
上调用 get
方法两次,一次获取 evens
,第二次获取 odds
。
实用函数 dumpList
再次使用来自流 API 的高阶 forEach
函数:
private void dumpList(String msg, List<number> list) { System.out.println("\n" + msg); list.stream().forEach(n -> n.dump()); // 或者使用 forEach(Number::dump)}</number>
这是示例运行中程序输出的一部分:
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)
用于代码简化的函数式结构
函数式结构(如方法引用和 lambda 表达式)非常适合在流 API 中使用。这些构造代表了 Java 中对高阶函数的主要简化。即使在糟糕的过去,Java 也通过 Method
和 Constructor
类型在技术上支持高阶函数,这些类型的实例可以作为参数传递给其它函数。由于其复杂性,这些类型在生产级 Java 中很少使用。例如,调用 Method
需要对象引用(如果方法是非静态的)或至少一个类标识符(如果方法是静态的)。然后,被调用的 Method
的参数作为对象实例传递给它,如果没有发生多态(那会出现另一种复杂性!),则可能需要显式向下转换。相比之下,lambda 和方法引用很容易作为参数传递给其它函数。
但是,新的函数式结构在流 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
的参数开始如下:
new ActionListener() {
这似乎是错误的,因为 ActionListener
是一个抽象接口,而抽象类型不能通过调用 new
实例化。但是,事实证明,还有其它一些实例被实例化了:一个实现此接口的未命名内部类。如果上面的代码封装在名为 OldJava
的类中,则该未命名的内部类将被编译为 OldJava$1.class
。actionPerformed
方法在这个未命名的内部类中被重写。
现在考虑使用新的函数式结构进行这个令人耳目一新的更改:
updateCurrentTime.addActionListener(e -> currentTime.setText(new Date().toString()));
lambda 表达式中的参数 e
是一个 ActionEvent
实例,而 lambda 的主体是对按钮上的 setText
的简单调用。
函数式接口和函数组合
到目前为止,使用的 lambda 已经写好了。但是,为了方便起见,我们可以像引用封装方法一样引用 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
提供各种函数式接口。以下是一些示例。
下面的代码段介绍了参数化的 Predicate
函数式接口。在此示例中,带有参数 String
的 Predicate<string></string>
类型可以引用具有 String
参数的 lambda 表达式或诸如 isEmpty
之类的 String
方法。通常情况下,Predicate 是一个返回布尔值的函数。
Predicate<string> pred = String::isEmpty; // String 方法的 predicate 声明String[] strings = {"one", "two", "", "three", "four"};Arrays.asList(strings) .stream() .filter(pred) // 过滤掉非空字符串 .forEach(System.out::println); // 只打印空字符串</string>
在字符串长度为零的情况下,isEmpty
Predicate 判定结果为 true
。 因此,只有空字符串才能进入管道的 forEach
阶段。
下一段代码将演示如何将简单的 lambda 或方法引用组合成更丰富的 lambda 或方法引用。考虑这一系列对 IntUnaryOperator
类型的引用的赋值,它接受一个整型参数并返回一个整型值:
IntUnaryOperator doubled = n -> n * 2;IntUnaryOperator tripled = n -> n * 3;IntUnaryOperator squared = n -> n * n;
IntUnaryOperator
是一个 FunctionalInterface
,其唯一声明的方法为 applyAsInt
。现在可以单独使用或以各种组合形式使用这三个引用 doubled
、tripled
和 squared
:
int arg = 5;doubled.applyAsInt(arg); // 10tripled.applyAsInt(arg); // 15squared.applyAsInt(arg); // 25
以下是一些函数组合的样例:
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
函数组合可以直接使用 lambda 表达式实现,但是引用使代码更简洁。
构造器引用
构造器引用是另一种函数式编程构造,而这些引用在比 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()); }}
该类只有一个构造函数,它需要一个 String
参数。给定一个名字数组,目标是生成一个 BedRocker
元素数组,每个名字代表一个元素。下面是使用了函数式结构的代码段:
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);</bedrocker>
在较高的层次上,这个代码段将名字转换为 BedRocker
数组元素。具体来说,代码如下所示。Stream
接口(在包 java.util.stream
中)可以被参数化,而在本例中,生成了一个名为 bedrockers
的 BedRocker
流。
Arrays.asList
实用程序再次用于流化一个数组 names
,然后将流的每一项传递给 map
函数,该函数的参数现在是构造器引用 BedRocker::new
。这个构造器引用通过在每次调用时生成和初始化一个 BedRocker
实例来充当一个对象工厂。在第二行执行之后,名为 bedrockers
的流由五项 BedRocker
组成。
这个例子可以通过关注高阶 map
函数来进一步阐明。在通常情况下,一个映射将一个类型的值(例如,一个 int
)转换为另一个相同类型的值(例如,一个整数的后继):
map(n -> n + 1) // 将 n 映射到其后继
然而,在 BedRocker
这个例子中,转换更加戏剧化,因为一个类型的值(代表一个名字的 String
)被映射到一个不同类型的值,在这个例子中,就是一个 BedRocker
实例,这个字符串就是它的名字。转换是通过一个构造器调用来完成的,它是由构造器引用来实现的:
map(BedRocker::new) // 将 String 映射到 BedRocker
传递给构造器的值是 names
数组中的其中一项。
此代码示例的第二行还演示了一个你目前已经非常熟悉的转换:先将数组先转换成 List
,然后再转换成 Stream
:
Stream<bedrocker> bedrockers = Arrays.asList(names).stream().map(BedRocker::new);</bedrocker>
第三行则是另一种方式 —— 流 bedrockers
通过使用数组构造器引用 BedRocker[]::new
调用 toArray
方法:
BedRocker[ ] arrayBR = bedrockers.toArray(BedRocker[]::new);
该构造器引用不会创建单个 BedRocker
实例,而是创建这些实例的整个数组:该构造器引用现在为 BedRocker[]:new
,而不是 BedRocker::new
。为了进行确认,将 arrayBR
转换为 List
,再次对其进行流式处理,以便可以使用 forEach
来打印 BedRocker
的名字。
FredWilmaPeeblesDinoBaby Puss
该示例对数据结构的微妙转换仅用几行代码即可完成,从而突出了可以将 lambda,方法引用或构造器引用作为参数的各种高阶函数的功能。
柯里化函数是指减少函数执行任何工作所需的显式参数的数量(通常减少到一个)。(该术语是为了纪念逻辑学家 Haskell Curry。)一般来说,函数的参数越少,调用起来就越容易,也更健壮。(回想一下一些需要半打左右参数的噩梦般的函数!)因此,应将柯里化视为简化函数调用的一种尝试。java.util.function
包中的接口类型适合于柯里化,如以下示例所示。
引用的 IntBinaryOperator
接口类型是为函数接受两个整型参数,并返回一个整型值:
IntBinaryOperator mult2 = (n1, n2) -> n1 * n2;mult2.applyAsInt(10, 20); // 200mult2.applyAsInt(10, 30); // 300
引用 mult2
强调了需要两个显式参数,在本例中是 10 和 20。
前面介绍的 IntUnaryOperator
比 IntBinaryOperator
简单,因为前者只需要一个参数,而后者则需要两个参数。两者均返回整数值。因此,目标是将名为 mult2
的两个参数 IntBinraryOperator
柯里化成一个单一的 IntUnaryOperator
版本 curriedMult2
。
考虑 IntFunction<r></r>
类型。此类型的函数采用整型参数,并返回类型为 R
的结果,该结果可以是另一个函数 —— 更准确地说,是 IntBinaryOperator
。让一个 lambda 返回另一个 lambda 很简单:
arg1 -> (arg2 -> arg1 * arg2) // 括号可以省略
完整的 lambda 以 arg1
开头,而该 lambda 的主体以及返回的值是另一个以 arg2
开头的 lambda。返回的 lambda 仅接受一个参数(arg2
),但返回了两个数字的乘积(arg1
和 arg2
)。下面的概述,再加上代码,应该可以更好地进行说明。
以下是如何柯里化 mult2
的概述:
类型为
IntFunction<intunaryoperator></intunaryoperator>
的 lambda 被写入并调用,其整型值为 10。返回的IntUnaryOperator
缓存了值 10,因此变成了已柯里化版本的mult2
,在本例中为curriedMult2
。然后使用单个显式参数(例如,20)调用
curriedMult2
函数,该参数与缓存的参数(在本例中为 10)相乘以生成返回的乘积。。
这是代码的详细信息:
// 创建一个接受一个参数 n1 并返回一个单参数 n2 -> n1 * n2 的函数,该函数返回一个(n1 * n2 乘积的)整型数。IntFunction<intunaryoperator> curriedMult2Maker = n1 -> (n2 -> n1 * n2);</intunaryoperator>
调用 curriedMult2Maker
生成所需的 IntUnaryOperator
函数:
// 使用 curriedMult2Maker 获取已柯里化版本的 mult2。// 参数 10 是上面的 lambda 的 n1。IntUnaryOperator curriedMult2 = curriedMult2Maker2.apply(10);
值 10
现在缓存在 curriedMult2
函数中,以便 curriedMult2
调用中的显式整型参数乘以 10:
curriedMult2.applyAsInt(20); // 200 = 10 * 20curriedMult2.applyAsInt(80); // 800 = 10 * 80
缓存的值可以随意更改:
curriedMult2 = curriedMult2Maker.apply(50); // 缓存 50curriedMult2.applyAsInt(101); // 5050 = 101 * 50
当然,可以通过这种方式创建多个已柯里化版本的 mult2
,每个版本都有一个 IntUnaryOperator
。
柯里化充分利用了 lambda 的强大功能:可以很容易地编写 lambda 表达式来返回需要的任何类型的值,包括另一个 lambda。
以上是Java資料流和函數式程式設計如何實現的詳細內容。更多資訊請關注PHP中文網其他相關文章!

javaispopularforcross-platformdesktopapplicationsduetoits“ writeonce,runany where”哲學。 1)itusesbytiesebyTecodeThatrunsonAnyJvm-備用Platform.2)librarieslikeslikeslikeswingingandjavafxhelpcreatenative-lookingenative-lookinguisis.3)

在Java中編寫平台特定代碼的原因包括訪問特定操作系統功能、與特定硬件交互和優化性能。 1)使用JNA或JNI訪問Windows註冊表;2)通過JNI與Linux特定硬件驅動程序交互;3)通過JNI使用Metal優化macOS上的遊戲性能。儘管如此,編寫平台特定代碼會影響代碼的可移植性、增加複雜性、可能帶來性能開銷和安全風險。

Java將通過雲原生應用、多平台部署和跨語言互操作進一步提昇平台獨立性。 1)雲原生應用將使用GraalVM和Quarkus提升啟動速度。 2)Java將擴展到嵌入式設備、移動設備和量子計算機。 3)通過GraalVM,Java將與Python、JavaScript等語言無縫集成,增強跨語言互操作性。

Java的強類型系統通過類型安全、統一的類型轉換和多態性確保了平台獨立性。 1)類型安全在編譯時進行類型檢查,避免運行時錯誤;2)統一的類型轉換規則在所有平台上一致;3)多態性和接口機制使代碼在不同平台上行為一致。

JNI會破壞Java的平台獨立性。 1)JNI需要特定平台的本地庫,2)本地代碼需在目標平台編譯和鏈接,3)不同版本的操作系統或JVM可能需要不同的本地庫版本,4)本地代碼可能引入安全漏洞或導致程序崩潰。

新興技術對Java的平台獨立性既有威脅也有增強。 1)雲計算和容器化技術如Docker增強了Java的平台獨立性,但需要優化以適應不同雲環境。 2)WebAssembly通過GraalVM編譯Java代碼,擴展了其平台獨立性,但需與其他語言競爭性能。

不同JVM實現都能提供平台獨立性,但表現略有不同。 1.OracleHotSpot和OpenJDKJVM在平台獨立性上表現相似,但OpenJDK可能需額外配置。 2.IBMJ9JVM在特定操作系統上表現優化。 3.GraalVM支持多語言,需額外配置。 4.AzulZingJVM需特定平台調整。

平台獨立性通過在多種操作系統上運行同一套代碼,降低開發成本和縮短開發時間。具體表現為:1.減少開發時間,只需維護一套代碼;2.降低維護成本,統一測試流程;3.快速迭代和團隊協作,簡化部署過程。


熱AI工具

Undresser.AI Undress
人工智慧驅動的應用程序,用於創建逼真的裸體照片

AI Clothes Remover
用於從照片中去除衣服的線上人工智慧工具。

Undress AI Tool
免費脫衣圖片

Clothoff.io
AI脫衣器

Video Face Swap
使用我們完全免費的人工智慧換臉工具,輕鬆在任何影片中換臉!

熱門文章

熱工具

PhpStorm Mac 版本
最新(2018.2.1 )專業的PHP整合開發工具

Atom編輯器mac版下載
最受歡迎的的開源編輯器

WebStorm Mac版
好用的JavaScript開發工具

SecLists
SecLists是最終安全測試人員的伙伴。它是一個包含各種類型清單的集合,這些清單在安全評估過程中經常使用,而且都在一個地方。 SecLists透過方便地提供安全測試人員可能需要的所有列表,幫助提高安全測試的效率和生產力。清單類型包括使用者名稱、密碼、URL、模糊測試有效載荷、敏感資料模式、Web shell等等。測試人員只需將此儲存庫拉到新的測試機上,他就可以存取所需的每種類型的清單。

EditPlus 中文破解版
體積小,語法高亮,不支援程式碼提示功能