Collections - Infinite Lists
How is it done in Haskell?
If you don’t specify the upper limit, it will be an infinite list.
e.g. How will you get the first 24 multiples of 13? other than doing [13,26..24*13]
take 24 [13, 26..]
[13,26,39,52,65,78,91,104,117,130,143,156,169,182,195,208,221,234,247,260,273,286,299,312]
Here are a handful of collections that produce infinite lists..
cycle takes a list and cycles it into an infinite list.
If you just try to display the result, it will go on forever so you have to slice it off somewhere.
take 10 (cycle [1,2,3])
take 12 (cycle "LOL ")
[1,2,3,1,2,3,1,2,3,1]
LOL LOL LOL
repeat takes an element and produces an infinite list of just that element. It’s like cycling a list with only one element.
take 10 (repeat 5)
[5,5,5,5,5,5,5,5,5,5]
Use the replicate function if you want a finite list with the same element in the list.
replicate 3 10
[10,10,10]
Infinite lists in Java
How to generate an infinite list and java take n elements out of that infinite list?
Java doesn’t have a built-in “infinite list” data structure in the way some functional languages might. Instead, you represent an “infinite” sequence by having a way to generate the next element on demand.
The most common ways to do this in Java are:
- Using java.util.function.Supplier<T>: A supplier can provide an endless stream of values.
- Using java.util.stream.Stream.generate() or Stream.iterate(): These methods from the Stream API are designed for creating potentially infinite streams.
- Using a custom Iterator<T>: An iterator where hasNext() always returns true and next() generates the subsequent element.
Then, to “take n elements,” you simply generate and collect the first n elements.
Key Takeaways
- No True Infinite Data Structure
- You don’t store infinite elements; you generate them.
- On-Demand Generation
- Elements are created only when requested.
- Supplier<T>
- A simple functional interface for providing values.
- Java Streams
- The Stream.generate() and Stream.iterate() methods are powerful tools for creating sequences, which can then be limited using limit(n). This is generally the preferred modern approach.
- Iterator<T>
- A more traditional way, but requires ensuring hasNext() behaves as expected for an “infinite” source.
- limit(n)
- The crucial operation that turns an infinite generation process into a finite result.
Choose the method that best fits your needs and coding style. For new code, the Stream API (Method 2) is often the most expressive and concise.
Here are examples for each approach:
Method 1: Using Supplier<T> and a loop
Method 2: Using Java Streams (Stream.generate() or Stream.iterate())
This is often the most idiomatic and concise way in modern Java (Java 8+).