當前位置：首頁 > 编程语言 > java >内容正文

java

过滤序列,惰性序列_Java 8的惰性序列实现

發布時間：2023/12/3 java 45 豆豆

生活随笔收集整理的這篇文章主要介紹了过滤序列,惰性序列_Java 8的惰性序列实现小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

過濾序列,惰性序列

我剛剛在GitHub上發布了LazySeq庫-這是我最近進行的Java 8實驗的結果。我希望你會喜歡它。即使您覺得它不是很有用，它仍然是Java 8（以及一般而言）中的函數式編程的一課。而且它可能是第一個針對Java 8的社區庫！

介紹

惰性序列是僅在實際需要其元素時才計算的數據結構。對延遲序列的所有操作map()例如map()和filter()也都是延遲的，從而將調用推遲到真正必要的時候。總是從一開始就使用非常便宜的first / rest遍歷惰性序列

分解（ head()和tail() ）。惰性序列的一個重要屬性是它們可以表示無限的數據流，例如隨時間推移的所有自然數或溫度測量值。

惰性序列會記住已經計算的值，因此，如果您訪問第N個元素，則也會計算并緩存從1到N-1所有元素。盡管如此， LazySeq （處于許多功能語言和算法的核心）是不可變的且線程安全的。

基本原理

該庫在很大程度上受scala.collection.immutable.Stream啟發，旨在提供不可變的，線程安全的和易于使用的惰性序列實現（可能是無限的）。有關某些用例，請參見Scala和Clojure中的惰性序列。

Stream類名稱是用Java 8已被使用，因此LazySeq被選擇，類似于lazy-seq Clojure中。說到Stream ，一開始它看起來像是一個開箱即用的惰性序列實現。但是，引用Javadoc：

流不是數據結構

和：

一旦對流執行了某個操作，該操作將被視為已消耗并且不再可用于其他操作。

換句話說， java.util.stream.Stream只是現有集合的一個瘦包裝，適合一次使用。更類似于Iterator ，而不是Stream于斯卡拉。該庫試圖填補這一空白。

當然，在Java 8之前可以實現惰性序列數據結構，但是缺少lambda使得使用這種數據結構既乏味又過于冗長。

入門

在10分鐘內構建并處理惰性序列。

所有自然數的無限序列

為了創建一個惰性序列，您可以使用LazySeq.cons()工廠方法，該方法接受第一個元素（ head ）和一個以后可能用于計算rest（ tail ）的函數。例如，為了產生具有給定起始元素的自然數的惰性序列，您只需說：

private LazySeq<Integer> naturals(int from) {return LazySeq.cons(from, () -> naturals(from + 1)); }

這里真的沒有遞歸。如果存在的話，調用naturals()會很快導致StackOverflowError因為它在沒有停止條件的情況下調用自身。但是() -> naturals(from + 1)表達式定義了一個函數，該函數返回此數據結構將調用的LazySeq<Integer> （準確地說是Supplier ），但僅在需要時才調用。查看下面的代碼，您認為幾次調用了naturals()函數（第一行除外）？

final LazySeq<Integer> ints = naturals(2);final LazySeq<String> strings = ints.map(n -> n + 10).filter(n -> n % 2 == 0).take(10).flatMap(n -> Arrays.asList(0x10000 + n, n)).distinct().map(Integer::toHexString);

的第一次調用naturals(2)返回來自起始懶惰序列2但休息（ 3 ， 4 ， 5 ，...）還沒有被計算。稍后，我們對該序列進行map() ，對其進行filter() ， take()前10個元素take() ，刪除重復項，等等。所有這些操作都不評估序列，并且盡可能地懶惰。例如take(10)不會急切地求出前10個元素以返回它們。而是返回新的惰性序列，該序列記住它應該在第10個元素處截斷原始序列。

同樣適用于distinct() 。它不會評估提取所有唯一值的整個序列（否則上面的代碼將Swift爆炸，遍歷無數個自然數）。而是返回僅包含第一個元素的新序列。如果您要求第二個唯一元素，它將懶惰地評估尾巴，但只會盡可能多。退房
toString()輸出：

System.out.println(strings); //[1000c, ?]

問號（ ? ）說： “該集合中可能還有其他內容，但我還不知道” 。您了解1000c來自何處嗎？仔細地看：

從2開始的無限自然數流開始

向每個元素添加10 （因此第一個元素變為12或十六進制的C ）

filter()輸出奇數（ 12為偶數，因此保持不變）

take()到目前為止序列中的前10元素

每個元素都被兩個元素替換：該元素加0x1000和元素本身（ flatMap() ）。這不會產生成對的序列，但是會產生兩倍長的整數序列

我們確保只返回distinct()元素

最后，我們將整數轉換為十六進制字符串。

如您所見，這些操作都不是真正需要評估整個流的。唯一的頭正在轉變，這就是我們最終看到的。那么，何時實際評估此數據結構？在絕對必要時（例如在副作用遍歷期間）：

strings.force();//or strings.forEach(System.out::println);//or final List<String> list = strings.toList();//or for (String s : strings) {System.out.println(s); }

僅上述所有語句將強制評估整個惰性序列。如果我們的序列是無限的，那不是很聰明，但是
strings僅限于前10個元素，因此它不會無限運行。如果只想強制執行序列的一部分，只需調用strings.take(5).force() 。順便說一句，您是否注意到我們可以使用標準Java 5 for-each語法遍歷LazySeq strings ？這是因為LazySeq實現了List接口，因此可以與Java Collections Framework生態系統很好地配合使用：

import java.util.AbstractList;public abstract class LazySeq<E> extends AbstractList<E>

請記住，一旦對惰性序列進行了評估（計算），它將對它們進行緩存（記住）以備后用。這使得惰性序列非常適合表示無限或很長的數據流，這些數據流計算成本很高。

迭代（）

建立無限的惰性序列通常可以歸結為提供一個初始元素和一個功能，該功能可以根據前一個元素生成下一個元素。換句話說，第二個元素是第一個元素的函數，第三個元素是第二個元素的函數，依此類推。為這種情況提供了便利的LazySeq.iterate()函數。現在， ints定義可以如下所示：

final LazySeq<Integer> ints = LazySeq.iterate(2, n -> n + 1);

我們從2開始，每個后續元素表示為前一個元素+ 1。

更多示例：斐波那契數列和Collat??z猜想

沒有斐波那契數字，就不會留下關于懶惰數據結構的文章，例如：

private static LazySeq<Integer> lastTwoFib(int first, int second) {return LazySeq.cons(first,() -> lastTwoFib(second, first + second)); }

斐波那契數列也是無限的，但我們可以通過多種方式自由變換它：

System.out.println(fib.drop(5).take(10).toList() ); //[5, 8, 13, 21, 34, 55, 89, 144, 233, 377]final int firstAbove1000 = fib.filter(n -> (n > 1000)).head();fib.get(45);

看到無限的數字流是多么容易和自然嗎？ drop(5).take(10)跳過前5個元素，并顯示下一個10。在這一點上，已經計算了前15個數字，以后再也不會計算。

查找高于1000（可能是1597 ）的第一個斐波那契數非常簡單。 head()始終由filter()預先計算，因此無需進一步評估。最后但并非最不重要的一點是，我們只需索取第45個斐波那契數（從0開始）并獲得
1134903170 。如果您嘗試訪問該編號之前的任何斐波那契數，它們將被預先計算并可以快速檢索。

有限序列（Collat??z猜想）

Collat??z猜想也是一個很有趣的問題。對于每個正整數n我們使用以下算法計算下一個整數：

如果n為偶數則為n n/2
如果n為奇數，則為3n + 1

例如，從10序列開始的外觀如下：10、5、16、8、4、2、1。該序列在達到1時結束。數學家認為，從任何整數開始，我們最終都將達到1，但尚未證明。

讓我們創建一個惰性序列，該序列為給定的n生成Collat??z級數，但只根據需要生成。如上所述，這次我們的序列將是有限的：

private LazySeq<Long> collatz(long from) {if (from > 1) {final long next = from % 2 == 0 ? from / 2 : from * 3 + 1;return LazySeq.cons(from, () -> collatz(next));} else {return LazySeq.of(1L);} }

該實現由定義直接驅動。對于每個大于1數字，返回該數字+惰性計算的流的其余部分（ () -> collatz(next) ）。如您所見，如果給定1 ，我們將使用特殊的of()工廠方法返回單元素惰性序列。讓我們用上述10測試它：

final LazySeq<Long> collatz = collatz(10);collatz.filter(n -> (n > 10)).head(); collatz.size();

filter()允許我們找到大于10的序列中的第一個數字。請記住，惰性序列將必須遍歷內容（自行評估），但只能遍歷找到第一個匹配元素的位置。然后停止，確保其計算量盡可能少。

但是，為了計算元素總數， size()必須遍歷整個序列。當然，這僅適用于有限的惰性序列，在無限序列上調用size()最終效果會很差。

如果您對此序列稍作練習，您將很快意識到，不同數字的序列共享相同的后綴（總是以相同的數字序列結尾）。這請求進行一些緩存/結構共享。有關詳細信息，請參見CollatzConjectureTest 。

現實生活？

無限的數字序列很棒，但在現實生活中卻不太實用。也許還有更多腳踏實地的例子？假設您有一個收藏，您需要從該收藏中隨機挑選一些物品。代替集合，我將使用一個返回隨機拉丁字符的函數：

private char randomChar() {return (char) ('A' + (int) (Math.random() * ('Z' - 'A' + 1))); }

但是有一個轉折。您需要N個（N <26，拉丁字符個數）唯一值。僅僅幾次調用randomChar()并不能保證唯一性。解決這個問題的方法很少，使用LazySeq非常簡單：

LazySeq<Character> charStream = LazySeq.<Character>continually(this::randomChar); LazySeq<Character> uniqueCharStream = charStream.distinct();

當需要時， continually()只需為每個元素調用給定的函數。因此， charStream將是無限的隨機字符流。當然，它們不能唯一。但是uniqueCharStream保證其輸出是唯一的。它通過檢查底層charStream下一個元素并拒絕已出現的項目來實現。現在我們可以說uniqueCharStream.take(4)并確保不會出現重復項。

再次注意， continually(this::randomChar).distinct().take(4)實際上只調用randomChar()一次！只要您不消耗此序列，它就會保持延遲并盡可能推遲評估。

另一個示例涉及從數據庫加載數據的批次（頁面）。使用ResultSet或Iterator很麻煩，但是將整個數據集加載到內存中通常不可行。另一種選擇是急于加載第一批數據，然后提供加載下一批數據的功能。僅當確實需要數據時才加載數據，而我們不會遇到性能或可伸縮性問題。

首先，讓我們定義抽象API，以從數據庫中加載批量數據：

public List<Record> loadPage(int offset, int max) {//load records from offset to offset + max }

我完全從技術中抽象出來，但是您明白了。假設我們現在定義了LazySeq<Record> ，它從第0行開始，僅在需要時才加載下一頁：

public static final int PAGE_SIZE = 5;private LazySeq<Record> records(int from) {return LazySeq.concat(loadPage(from, PAGE_SIZE),() -> records(from + PAGE_SIZE)); }

通過調用records(0)創建新的LazySeq<Record>實例時，將加載5個元素的第一頁。這意味著已經計算出前5個序列元素。如果您嘗試訪問第6位或更高版本，序列將自動加載所有丟失的記錄并對其進行緩存。換句話說，您永遠不會兩次計算相同的元素。

使用序列時，更有用的工具是grouped()和sliding()方法。首先將輸入序列分成大小相等的組。以這個為例，還證明這些方法總是很懶惰：

final LazySeq<Character> chars = LazySeq.of('A', 'B', 'C', 'D', 'E', 'F', 'G');chars.grouped(3); //[[A, B, C], ?]chars.grouped(3).force(); //force evaluation //[[A, B, C], [D, E, F], [G]]

同樣適用于sliding() ：

chars.sliding(3); //[[A, B, C], ?]chars.sliding(3).force(); //force evaluation //[[A, B, C], [B, C, D], [C, D, E], [D, E, F], [E, F, G]]

這兩種方法非常有用。您可以通過滑動窗口查看數據（例如，計算移動平均值）或將其劃分為等長的存儲桶。

您可能會發現有用的最后一個有趣的實用程序方法是scan() ，它（當然是延遲地scan()迭代輸入流，并通過在輸入的前一個和當前元素上應用函數來構造輸出的每個元素。代碼段值一千個字：

LazySeq<Integer> list = LazySeq.numbers(1).scan(0, (a, x) -> a + x);list.take(10).force(); //[0, 1, 3, 6, 10, 15, 21, 28, 36, 45]

LazySeq.numbers(1)是自然數（1、2、3…）的序列。 scan()創建一個新的序列，從
0并為輸入的每個元素（自然數）將其添加到自身的最后一個元素。因此我們得到：[ 0 0+1 0+1+2 0+1+2+3 0+1+2+3+4 0+1+2+3+4+5 …]。如果您想要一系列增長的字符串，只需替換幾種類型：

LazySeq.continually("*").scan("", (s, c) -> s + c).map(s -> "|" + s + "\\").take(10).forEach(System.out::println);

并享受這個美麗的三角形：

|\ |*\ |**\ |***\ |****\ |*****\ |******\ |*******\ |********\ |*********\

或者（相同的輸出）：

LazySeq.iterate("", s -> s + "*").map(s -> "|" + s + "\\").take(10).forEach(System.out::println);

Java Collections框架的互操作性

LazySeq實現java.util.List接口，因此可以在許多地方使用。此外，它還對集合（即流和集合）實現了Java 8增強：

lazySeq.stream().map(n -> n + 1).flatMap(n -> asList(0, n - 1).stream()).filter(n -> n != 0).substream(4, 18).limit(10).sorted().distinct().collect(Collectors.toList());

但是，Java 8中的流是根據LazySeq （惰性評估）的基礎而LazySeq 。上面的示例將所有中間步驟推遲到調用collect()為止。使用LazySeq您可以安全地跳過.stream()并直接處理序列：

lazySeq.map(n -> n + 1).flatMap(n -> asList(0, n - 1)).filter(n -> n != 0).slice(4, 18).limit(10).sorted().distinct();

此外， LazySeq提供了特殊用途的收集器（請參閱： LazySeq.toLazySeq() ），即使與collect()一起使用也可以避免評估，這通常會強制進行完整的收集計算。

實施細節

每個懶惰序列都是圍繞急切計算的頭和懶洋洋地表示為函數的尾部的思想構建的。這與經典的單鏈列表遞歸定義非常相似：

class List<T> {private final T head;private final List<T> tail;//... }

但是，在延遲序列的情況下，尾部是函數而不是值。該函數的調用會盡可能推遲：

class Cons<E> extends LazySeq<E> {private final E head;private LazySeq<E> tailOrNull;private final Supplier<LazySeq<E>> tailFun;@Overridepublic LazySeq<E> tail() {if (tailOrNull == null) {tailOrNull = tailFun.get();}return tailOrNull;}

有關完整的實現，請參見在創建時知道tail時使用的Cons.java和FixedCons.java （例如LazySeq.of(1, 2)與LazySeq.cons(1, () -> someTailFun()相對LazySeq.of(1, 2) ，例如LazySeq.of(1, 2) ）。

陷阱和常見危險

下面介紹常見問題和誤解。

評估太多

使用無限序列的最大危險之一就是試圖對其進行完全評估，這顯然會導致無限計算。無限序列背后的思想不是全面評估它，而是在不引入人為限制和意外復雜性的情況下，盡可能多地獲取它（請參見數據庫加載示例）。

但是，評估整個序列太容易遺漏了。例如，調用LazySeq.size() 必須評估整個序列，并且將無限運行，最終填滿堆棧或堆（實現細節）。還有其他方法需要完全遍歷才能正常運行。例如allMatch()確保所有元素都匹配給定謂詞。有些方法甚至更危險，因為它們是否完成取決于序列中的數據。例如，如果head匹配謂詞–或從不匹配，則anyMatch()可能立即返回。

有時，我們可以使用更具確定性的方法來輕松避免昂貴的操作。例如：

seq.size() <= 10 //BAD

如果seq是無限的，則可能無法正常工作或非常慢。但是，我們可以通過（更多）可預測的方式實現相同的目標：

seq.drop(10).isEmpty()

請記住，惰性序列是不可變的（因此我們并沒有真正改變seq ）， drop(n)通常是O(n)而isEmpty()是O(1) 。

如有疑問，請查閱源代碼或JavaDoc以確保您的操作不會過于急切地評估您的序列。當使用LazySeq ，也要非常小心，因為需要使用java.util.Collection或java.util.List 。

持有不必要的頭參考

惰性序列應定義為記住已計算的元素。您必須意識到這一點，否則您的序列（尤其是無限序列）將Swift填滿可用內存。但是，由于LazySeq只是一個奇特的鏈接列表，因此，如果您不再保留對head的引用（而僅保留中間的某個元素），則可以進行垃圾回收。例如：

//LazySeq<Char> first = seq.take(10); seq = seq.drop(10);

前十個元素被刪除，我們假設沒有任何東西引用過seq以前的庚。這使前十個元素有資格進行垃圾回收。但是，如果我們取消注釋第一行，并保持參照老head在first ，JVM不會釋放任何內存。讓我們對此進行透視。下面的代碼最終將拋出OutOfMemoryError因為infinite引用將保持序列的開始，因此，到目前為止創建的所有元素都將：

LazySeq<Big> infinite = LazySeq.<Big>continually(Big::new); for (Big arr : infinite) {// }

但是，通過內聯對continually()調用或將其提取到方法中，此代碼可以完美運行（很好，仍然可以永遠運行，但幾乎不使用內存）：

private LazySeq<Big> getContinually() {return LazySeq.<Big>continually(Big::new); }for (Big arr : getContinually()) {// }

有什么不同？每個循環都在下面使用迭代器。 LazySeqIterator下面的LazySeqIterator不會保留對舊head()的引用，因此，如果沒有其他引用該head的對象，則可以進行垃圾回收，當使用for-each時，將看到真實的javac輸出：

for (Iterator<Big> cur = getContinually().iterator(); cur.hasNext(); ) {final Big arr = cur.next();//... }

TL; DR

您的序列在遍歷時會增加。如果在另一端成長時保持一端，則最終會炸毀。就像您在Hibernate中的一級緩存一樣，如果您在一個事務中加載過多。僅根據需要使用。

轉換為純Java集合

轉換很簡單，但是很危險。這是以上幾點的結果。您可以通過調用toList()將惰性序列轉換為java.util.List ：

LazySeq<Integer> even = LazySeq.numbers(0, 2); even.take(5).toList(); //[0, 2, 4, 6, 8]

或使用具有更豐富API的Java 8中的Collector ：

even.stream().limit(5).collect(Collectors.toSet()) //[4, 6, 0, 2, 8]

但是請記住，Java集合在定義上是有限的，因此請避免將惰性序列明確轉換為集合。注意
LazySeq已經是List ，因此是Iterable和Collection 。它還具有高效的LazySeq.iterator() 。如果可以，只需直接傳遞LazySeq實例即可。

性能，時間和空間復雜度

每個序列（空除外head()的head()總是很容易計算，因此對其進行訪問是快速O(1) 。計算tail()可能占用從O(1) （如果已經計算過）到無限時間的所有內容。以這個有效的流為例：

import static com.blogspot.nurkiewicz.lazyseq.LazySeq.cons; import static com.blogspot.nurkiewicz.lazyseq.LazySeq.continually;LazySeq<Integer> oneAndZeros = cons(1,() -> continually(0) ). filter(x -> (x > 0));

它代表1后跟無窮多個0 s。通過過濾所有正數（ x > 0 ），我們得到一個具有相同頭部的序列，但是對尾部的過濾被延遲（延遲）。但是，如果現在我們不小心調用oneAndZeros.tail() ， LazySeq將繼續計算該無限序列的越來越多，但是由于初始1之后沒有正數，該操作將永遠運行，最終拋出StackOverflowError或OutOfMemoryError （這是一個實施細節）。

但是，如果您達到此狀態，則可能是編程錯誤或庫的濫用。通常tail()將接近O(1) 。另一方面，如果您已經“堆疊”了很多操作，則調用tail()會Swift一次又一次觸發它們，因此tail()運行時間在很大程度上取決于您的數據結構。

LazySeq上的大多數操作都是O(1)因為它們是惰性的。一些操作，例如get(n)或drop(n)都是O(n) （ n表示參數，而不是序列長度）。一般而言，運行時間將類似于正常的鏈表。

因為LazySeq記住單個鏈接列表中所有已經計算出的值，所以內存消耗始終為O(n) ，其中n n是已經計算出的元素數。

故障排除

錯誤invalid target release: 1.8在Maven構建期間invalid target release: 1.8

如果在maven生成期間看到此錯誤消息：

[INFO] BUILD FAILURE ... [ERROR] Failed to execute goal org.apache.maven.plugins:maven-compiler-plugin:3.1:compile (default-compile) on project lazyseq: Fatal error compiling: invalid target release: 1.8 -> [Help 1]

這意味著您不使用Java 8進行編譯。下載具有lambda支持的JDK 8，并讓maven使用它：

$ export JAVA_HOME=/path/to/jdk8

我收到StackOverflowError或程序無限期掛起

使用LazySeq ，有時會出現StackOverflowError或OutOfMemoryError ：

java.lang.StackOverflowErrorat sun.misc.Unsafe.allocateInstance(Native Method)at java.lang.invoke.DirectMethodHandle.allocateInstance(DirectMethodHandle.java:426)at com.blogspot.nurkiewicz.lazyseq.LazySeq.iterate(LazySeq.java:118)at com.blogspot.nurkiewicz.lazyseq.LazySeq.lambda$0(LazySeq.java:118)at com.blogspot.nurkiewicz.lazyseq.LazySeq$$Lambda$2.get(Unknown Source)at com.blogspot.nurkiewicz.lazyseq.Cons.tail(Cons.java:32)at com.blogspot.nurkiewicz.lazyseq.LazySeq.size(LazySeq.java:325)at com.blogspot.nurkiewicz.lazyseq.LazySeq.size(LazySeq.java:325)at com.blogspot.nurkiewicz.lazyseq.LazySeq.size(LazySeq.java:325)at com.blogspot.nurkiewicz.lazyseq.LazySeq.size(LazySeq.java:325)at com.blogspot.nurkiewicz.lazyseq.LazySeq.size(LazySeq.java:325)at com.blogspot.nurkiewicz.lazyseq.LazySeq.size(LazySeq.java:325)at com.blogspot.nurkiewicz.lazyseq.LazySeq.size(LazySeq.java:325)

當使用可能無限的數據結構時，必須小心。避免調用必須（ size() ， allMatch() ， minBy() ， forEach() ， reduce() ，…）或可以（ filter() ， distinct() ，...）遍歷整個序列以便給出正確值的操作結果。有關更多示例和避免方法，請參見陷阱。

到期

質量

該項目是作為練習開始的，尚未經過戰斗驗證。但是，健康的300多個單元測試套件（測試代碼/生產代碼比率為3：1）可以保護質量和功能正確性。我還通過LazySeq尾部函數并驗證它們被盡可能少地調用來確保LazySeq盡可能地懶。

貢獻和錯誤報告

如果發現錯誤或缺少功能，請隨時打開新票證或開始拉取請求。我也很想看看LazySeq在野外的更多有趣用法。

可能的改進

就像在FixedCons知道尾巴的情況下使用FixedCons一樣，請考慮將IterableCons包裝在一個節點中而不是建立FixedCons層次結構的Iterable 。這可以用于所有concat方法。
并行處理支持（實現分離器？）

執照

該項目是在Apache許可的 2.0版下發布的。

參考：來自Java和社區博客的JCG合作伙伴 Tomasz Nurkiewicz 提供的Java 8的惰性序列實現。

翻譯自: https://www.javacodegeeks.com/2013/05/lazy-sequences-implementation-for-java-8.html