Java.net語言中類似的函數結構有哪些

這篇文章將為大家詳細講解有關Java.net語言中類似的函數結構有哪些，小編覺得挺實用的，因此分享給大家做個參考，希望大家閱讀完這篇文章后可以有所收獲。

過濾

在過濾 函數中，您可指定一個布爾值條件（通常為一個高階函數的形式），將它應用到一個集合。該函數返回集合的子集，其中的元素與該條件匹配。過濾與查找 函數緊密相關，后者返回集合中第一個匹配的元素。

Scala

Scala 擁有多個過濾函數變體。最簡單的情形基于傳遞的條件來過濾某個列表。在第一個示例中，我創建一個數字列表。然后使用了 filter() 函數，并傳遞了一個代碼塊，指定了所有元素都可以被 3 整除的條件：

val numbers = List.range(1, 11)
numbers filter (x => x % 3 == 0)
// List(3, 6, 9)

我可依靠隱式的參數來創建該代碼快的更加簡潔的版本：

numbers filter (_ % 3 == 0)
// List(3, 6, 9)

第二個版本不那么冗長，因為在 Scala 中，您可以將參數替換為下劃線。兩個版本都可以得到相同的結果。

過濾操作的許多示例都使用了數字，但 filter() 適用于任何集合。此示例將 filter() 應用到一個單詞列表來確定 3 字母單詞：

val words = List("the", "quick", "brown", "fox", "jumped", "over", "the", "lazy", "dog")
words filter (_.length == 3)
// List(the, fox, the, dog)

Scala 中的另一個過濾函數變體是 partition() 函數，它將一個集合拆分為多個部分。這種拆分基于您傳遞的高階函數來確定分離條件。在這里，partition() 函數將返回兩個列表，它們依據哪些列表成員可被 3 整除來進行拆分：

numbers partition (_ % 3 == 0)
// (List(3, 6, 9),List(1, 2, 4, 5, 7, 8, 10))

filter() 函數返回一個匹配元素集合，而 find() 僅返回第一個匹配元素：

numbers find (_ % 3 == 0)
// Some(3)

但是，find() 的返回值不是匹配的值本身，而是一個包裝在 Option 類中的值。Option 有兩個可能的值：Some 或 None。像其他一些函數式語言一樣，Scala 使用 Option 作為一種約定來避免在缺少某個值時返回 null。Some() 實例包裝實際的返回值，在 numbers find (_ % 3 == 0) 的情況下，該值為 3。如果我嘗試查找某個不存在的值，那么返回值將為 None：

numbers find (_ < 0)
// None

Scala 還包含多個函數，它們基于一個判定函數來處理一個集合并返回值或丟棄它們。takeWhile() 函數返回集合中滿足判定函數的最大的值集：

List(1, 2, 3, -4, 5, 6, 7, 8, 9, 10) takeWhile (_ > 0)
// List(1, 2, 3)

dropWhile() 函數跳過滿足判定條件的最大元素數量：

words dropWhile (_ startsWith "t")
// List(quick, brown, fox, jumped, over, the, lazy, dog)

Groovy

Groovy 不是一個函數式語言，但它包含許多函數范例，一些范例的名稱源自腳本語言。例如，在函數式語言中，該函數在傳統上被稱為 filter() 的函數，就是 Groovy 中的 findAll() 方法：

(1..10).findAll {it % 3 == 0}
// [3, 6, 9]

像 Scala 的過濾函數一樣，Groovy 可處理所有類型，包括字符串：

def words = ["the", "quick", "brown", "fox", "jumped", "over", "the", "lazy", "dog"]
words.findAll {it.length() == 3}
// [The, fox, the, dog]

Groovy 還有一個類似 partition() 的函數，稱為 split()：

(1..10).split {it % 3}
// [[1, 2, 4, 5, 7, 8, 10], [3, 6, 9]]

split() 方法的返回值是一個嵌套數組，就像 Scala 中從 partition() 返回的嵌套列表。

Groovy 的 find() 方法返回集合中第一個匹配的元素：

(1..10).find {it % 3 == 0}
// 3

不同于 Scala，Groovy 遵循 Java 約定，在 find() 未能找到元素時返回 null：

(1..10).find {it < 0}
// null

Groovy 還擁有 takeWhile() 和 dropWhile() 方法，它們具有與 Scala 的版本類似的語義：

[1, 2, 3, -4, 5, 6, 7, 8, 9, 10].takeWhile {it > 0}
// [1, 2, 3]
words.dropWhile {it.startsWith("t")}
// [quick, brown, fox, jumped, over, the, lazy, dog]

與 Scala 示例中一樣，dropWhile 被用作一個專門的過濾器：它丟棄與判定條件匹配的最大前綴，僅過濾列表的第一部分：

def moreWords = ["the", "two", "ton"] + words
moreWords.dropWhile {it.startsWith("t")}
// [quick, brown, fox, jumped, over, the, lazy, dog]

Clojure

Clojure 擁有令人震驚的集合操作例程數量。由于 Clojure 的動態類型，其中許多例程都是通用的。許多開發人員傾向于使用 Clojure，因為它的集合庫非常豐富和靈活。Clojure 使用傳統的函數式編程名稱，如 (filter ) 函數所示：

(def numbers (range 1 11))
(filter (fn [x] (= 0 (rem x 3))) numbers)
; (3 6 9)

像其他語言一樣，Clojure 為簡單的匿名函數提供了簡潔的語法：

(filter #(zero? (rem % 3)) numbers)
; (3 6 9)

而且與其他語言中一樣，Clojure 的函數適用于任何適用的類型，比如字符串：

(def words ["the" "quick" "brown" "fox" "jumped" "over" "the" "lazy" "dog"])
(filter #(= 3 (count %)) words)
; (the fox the dog)

Clojure 的 (filter ) 返回類型為 Seq，它通過圓括號來描述。Seq 是 Clojure 中的順序集合的核心抽象。

映射

所有 Java 下一代語言中常見的第二個主要的函數變形是映射。映射函數接受一個高階函數和一個集合，然后向每個元素應用傳遞的函數并返回一個集合。返回的集合（不同于過濾）的大小與原始集合相同，但更新了值。

Scala

Scala 的 map() 函數接受一個代碼塊并返回轉換的集合：

List(1, 2, 3, 4, 5) map (_ + 1)
// List(2, 3, 4, 5, 6)

map() 函數適用于所有適用的類型，但它不一定返回集合元素的已轉換集合。在此示例中，我在一個字符串中返回所有元素的大小列表：

words map (_.length)
// List(3, 5, 5, 3, 6, 4, 3, 4, 3)

在函數式編程語言中常常會產生嵌套列表，以至于嵌套列表對解除嵌套（通常稱為扁平化）的庫支持很常見。以下是扁平化一個嵌套列表的示例：

List(List(1, 2, 3), List(4, 5, 6), List(7, 8, 9)) flatMap (_.toList)
// List(1, 2, 3, 4, 5, 6, 7, 8, 9)

獲得的 List 中僅包含元素，刪除了額外的基礎架構。flatMap 函數也適用于可能未以傳統方式嵌套的數據結構。例如，您可將一個字符串視為一個嵌套字符系列：

words flatMap (_.toList)
// List(t, h, e, q, u, i, c, k, b, r, o, w, n, f, o, x, ...

Groovy

Groovy 還包含多個稱為 collect() 的映射變體。默認的變體接受一個代碼塊，以便將該變體應用到集合的每個元素：

(1..5).collect {it += 1}
// [2, 3, 4, 5, 6]

像其他語言一樣，Groovy 允許對簡單的匿名高階函數使用簡寫；it 保留字用于替代單獨的參數。

collect() 方法適用于您可向其提供合理的判定條件的任何集合，比如一個字符串列表：

def words = ["the", "quick", "brown", "fox", "jumped", "over", "the", "lazy", "dog"]
words.collect {it.length()}
// [3, 5, 5, 3, 6, 4, 3, 4, 3]

Groovy 還有一個類似于 flatMap() 的折疊內部結構的方法，稱為 flatten()：

[[1, 2, 3], [4, 5, 6], [7, 8, 9]].flatten()
// [1, 2, 3, 4, 5, 6, 7, 8, 9]

flatten() 方法也適用于不太明顯的集合，比如字符串：

(words.collect {it.toList()}).flatten()
// [t, h, e, q, u, i, c, k, b, r, o, w, n, f, o, x, j, ...

Clojure

Clojure 包含一個 (map ) 函數，它接受一個高階函數（其中包含運算符）和一個集合：

(map inc numbers)
; (2 3 4 5 6 7 8 9 10 11)

(map ) 的第一個參數可以是任何接受單個參數的函數：命名函數、匿名函數或已存在的函數，比如遞增其參數的 inc。此示例中演示了更典型的匿名語法，它生成一個字符串中的單詞長度的集合：

(map #(count %) words)
; (3 5 5 3 6 4 3 4 3)

Clojure 的 (flatten ) 函數類似于 Groovy 的：

(flatten [[1 2 3] [4 5 6] [7 8 9]])
; (1 2 3 4 5 6 7 8 9)

折疊/縮減

在 3 種 Java 下一代語言中，第三個常見函數在名稱上擁有最多變體和許多細微的區別。foldLeft 和 reduce 是一個名為 catamorphism 的列表操作概念上的特定變體，該概念是列表折疊的一種泛化。在此示例中，“折疊左側” 表示：

使用一個二進制函數或運算符將列表的第一個元素與第二個元素相結合，創建一個新的第一個元素。
重復第一步，直到列表用完且您得到一個單一元素。

請注意，這是您在對一組數字求和時所做的操作：從 0 開始，加第一個元素，將結果與第二個元素相加，一直執行此操作，直到列表元素被用完為止。

Scala

Scala 擁有最豐富的折疊運算集合，這是因為它在一定程度上簡化了動態類型的 Groovy 和 Clojure 中沒有的多種類型場景。縮減函數常用于執行求和：

List.range(1, 10) reduceLeft((a, b) => a + b)
// 45

提供給 reduce() 的函數通常是一個接受兩個參數，并返回單個結果的函數或運算符，以便可以使用一個列表。您可以使用 Scala 的語法糖來縮短函數定義：

List.range(1, 10).reduceLeft(0)(_ + _)
// 45

reduceLeft() 函數假設第一個元素是運算的左側。對于相加等運算符，操作數的位置無關緊要，但放置順序對相除等運算至關重要。如果希望反轉運算符應用的順序，可以使用 reduceRight()：

List.range(1, 10) reduceRight(_ - _)
// 5

了解何時可使用縮減等高級抽象是掌握函數編程的一個關鍵。此示例使用 reduceLeft() 來確定集合中最常的單詞：

words.reduceLeft((a, b) => if (a.length > b.length) a else b)
// jumped

縮減和折疊運算擁有重疊的功能，它們具有細微的差別，但這不屬于本文的討論范圍。但是，通常可以看到它們的一個明顯區別。在 Scala 中，簽名 reduceLeft[B >:A](op:(B, A) => B):B 表明惟一想要的參數就是組合元素的函數。初始值應該是集合中的第一個值。相對而言，簽名 foldLeft[B](z:B)(op:(B, A) => B):B 表示結果的一個初始種子值，所以您可以返回與列表元素類型不同的類型。

以下是一個使用 foldLeft 對集合求和的示例：

List.range(1, 10).foldLeft(0)(_ + _)
// 45

Scala 支持運算符重疊，所以兩個常見的折疊操作 foldLeft 和 foldRight 分別擁有相應的運算符：/: 和 :\。因此，您可以使用 foldLeft 創建 sum 的簡潔版本：

(0 /: List.range(1, 10)) (_ + _)
// 45

類似地，要找到一個列表中每個元素的級聯區別（求和運算的反向操作，無可否認這種需求很少見），您可以使用 foldRight() 函數或 :\ 運算符：

(List.range(1, 10) :\ 0) (_ - _)
// 5

Groovy

Groovy 通過使用重疊來支持與 Scala 的 reduce() 和 foldLeft() 選項相同的功能，從而進入縮減類別。該函數的一個版本接受一個初始值。此示例使用 inject() 方法生成一個集合的總和：

(1..10).inject {a, b -> a + b}
// 55

替代形式接受一個初始值：

(1..10).inject(0, {a, b -> a + b})
// 55

Groovy 擁有一個比 Scala 或 Clojure 小得多的函數庫 — Groovy 是一種不強調函數式編程的多范例編程，看到這種情況毫不奇怪。

Clojure

Clojure 主要是一種函數式編程語言，所以它支持 (reduce )。(reduce ) 函數接受一個可選的初始值，以便同時涵蓋 Scala 所處理的 reduce() 和 foldLeft() 情形。(reduce ) 函數沒有給用戶帶來任何驚喜。它接受一個需要兩個參數的函數和一個集合：

(reduce + (range 1 11))
; 55

Clojure 將對類似 reduce 的功能的高級支持包含在一個名為 reducers 的庫中，后面的一期文章將會介紹這個庫。

關于“Java.net語言中類似的函數結構有哪些”這篇文章就分享到這里了，希望以上內容可以對大家有一定的幫助，使各位可以學到更多知識，如果覺得文章不錯，請把它分享出去讓更多的人看到。