T - component type of this Streampublic interface LazyStream<T>
extends javaslang.collection.Stream<T>, com.aol.cyclops.lambda.monads.Functor<T>
Stream is lazy sequence of elements which may be infinitely long.
Its immutability makes it suitable for concurrent programming.
A Stream is composed of a head element and a lazy evaluated tail Stream.
There are two implementations of the Stream interface:
LazyStream.Empty, which represents the empty Stream.LazyStream.LazyCons, which represents a Stream containing one or more elements.Stream:
// factory methods
Stream.empty() // = Stream.of() = Nil.instance()
Stream.of(x) // = new Cons<>(x, Nil.instance())
Stream.of(Object...) // e.g. Stream.of(1, 2, 3)
Stream.ofAll(Iterable) // e.g. Stream.ofAll(List.of(1, 2, 3)) = 1, 2, 3
Stream.ofAll(<primitive array>) // e.g. List.ofAll(new int[] {1, 2, 3}) = 1, 2, 3
// int sequences
Stream.from(0) // = 0, 1, 2, 3, ...
Stream.range(0, 3) // = 0, 1, 2
Stream.rangeClosed(0, 3) // = 0, 1, 2, 3
// generators
Stream.cons(Object, Supplier) // e.g. Stream.cons(current, () -> next(current));
Stream.gen(Supplier) // e.g. Stream.gen(Math::random);
Stream.gen(Object, Function) // e.g. Stream.gen(1, i -> i * 2);
Factory method applications:
Stream<Integer> s1 = Stream.of(1);
Stream<Integer> s2 = Stream.of(1, 2, 3);
// = Stream.of(new Integer[] {1, 2, 3});
Stream<int[]> s3 = Stream.ofAll(new int[] {1, 2, 3});
Stream<List<Integer>> s4 = Stream.ofAll(List.of(1, 2, 3));
Stream<Integer> s5 = Stream.ofAll(new int[] {1, 2, 3});
Stream<Integer> s6 = Stream.ofAll(List.of(1, 2, 3));
// cuckoo's egg
Stream<Integer[]> s7 = Stream.<Integer[]> of(new Integer[] {1, 2, 3});
Example: Generating prime numbers
// = Stream(2L, 3L, 5L, 7L, ...)
Stream.gen(2L, PrimeNumbers::nextPrimeFrom)
// helpers
static long nextPrimeFrom(long num) {
return Stream.from(num + 1).find(PrimeNumbers::isPrime).get();
}
static boolean isPrime(long num) {
return !Stream.rangeClosed(2L, (long) Math.sqrt(num)).exists(d -> num % d == 0);
}
See Okasaki, Chris: Purely Functional Data Structures (p. 34 ff.). Cambridge, 2003.| Modifier and Type | Interface and Description |
|---|---|
static class |
LazyStream.Empty<T>
The empty Stream.
|
static class |
LazyStream.LazyCons<T>
Non-empty
Stream, consisting of a head, a tail and an optional
AutoCloseable. |
javaslang.collection.Stream.Cons<T>| Modifier and Type | Field and Description |
|---|---|
static long |
serialVersionUID |
| Modifier and Type | Method and Description |
|---|---|
default com.aol.cyclops.monad.AnyM<T> |
anyM()
conversions
|
default LazyStream<T> |
append(T element) |
default LazyStream<T> |
appendAll(java.lang.Iterable<? extends T> elements) |
default LazyStream<T> |
appendSelf(java.util.function.Function<? super javaslang.collection.Stream<T>,? extends javaslang.collection.Stream<T>> mapper)
Appends itself to the end of stream with
mapper function. |
default LazyStream<T> |
clear() |
default <R,A> R |
collect(java.util.stream.Collector<? super T,A,R> collector) |
default <R> R |
collect(java.util.function.Supplier<R> supplier,
java.util.function.BiConsumer<R,? super T> accumulator,
java.util.function.BiConsumer<R,R> combiner) |
default org.jooq.lambda.Collectable<T> |
collectable()
JDK Collect
|
static <T> java.util.stream.Collector<T,java.util.ArrayList<T>,LazyStream<T>> |
collector()
Returns a
Collector which may be used in conjunction with
Stream.collect(java.util.stream.Collector) to obtain a LazyStream. |
default LazyStream<javaslang.collection.Stream<T>> |
combinations() |
default LazyStream<javaslang.collection.Stream<T>> |
combinations(int k) |
static <T> LazyStream<T> |
cons(java.util.function.Supplier<T> head,
java.util.function.Supplier<? extends LazyStream<? extends T>> tailSupplier)
Constructs a Stream of a head element and a tail supplier.
|
default LazyStream<javaslang.Tuple2<T,T>> |
crossProduct() |
default LazyStream<javaslang.collection.Stream<T>> |
crossProduct(int power) |
default <U> LazyStream<javaslang.Tuple2<T,U>> |
crossProduct(java.lang.Iterable<? extends U> that) |
default LazyStream<T> |
cycle()
Repeat the elements of this Stream infinitely.
|
default LazyStream<T> |
distinct() |
default LazyStream<T> |
distinctBy(java.util.Comparator<? super T> comparator) |
default <U> LazyStream<T> |
distinctBy(java.util.function.Function<? super T,? extends U> keyExtractor) |
default LazyStream<T> |
drop(long n) |
default LazyStream<T> |
dropRight(long n) |
default LazyStream<T> |
dropUntil(java.util.function.Predicate<? super T> predicate) |
default LazyStream<T> |
dropWhile(java.util.function.Predicate<? super T> predicate) |
static <T> LazyStream<T> |
empty()
Returns the single instance of Nil.
|
static <T> LazyStream<T> |
fill(int n,
java.util.function.Supplier<? extends T> s)
Returns a Stream containing
n values supplied by a given Supplier s. |
default LazyStream<T> |
filter(java.util.function.Predicate<? super T> predicate) |
default <U> LazyStream<U> |
flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends U>> mapper) |
static LazyStream<java.lang.Integer> |
from(int value)
Returns an infinitely long Stream of int values starting from
from. |
static LazyStream<java.lang.Long> |
from(long value)
Returns an infinitely long Stream of long values starting from
from. |
static <T> LazyStream<T> |
fromStream(javaslang.collection.Stream<T> stream) |
default com.aol.simple.react.stream.traits.SimpleReactStream<T> |
futures() |
default com.aol.simple.react.stream.traits.SimpleReactStream<T> |
futures(com.aol.simple.react.stream.simple.SimpleReact react) |
default com.aol.simple.react.stream.traits.LazyFutureStream<T> |
futureStream() |
default com.aol.simple.react.stream.traits.LazyFutureStream<T> |
futureStream(com.aol.simple.react.stream.lazy.LazyReact react) |
static <T> LazyStream<T> |
gen(java.util.function.Supplier<? extends T> supplier)
Generates an (theoretically) infinitely long Stream using a value Supplier.
|
static <T> LazyStream<T> |
gen(T seed,
java.util.function.Function<? super T,? extends T> f)
Generates a (theoretically) infinitely long Stream using a function to calculate the next value
based on the previous.
|
default T |
get(int index) |
default <C> javaslang.collection.Map<C,javaslang.collection.Stream<T>> |
groupBy(java.util.function.Function<? super T,? extends C> classifier) |
default javaslang.collection.Iterator<javaslang.collection.Stream<T>> |
grouped(long size) |
default boolean |
hasDefiniteSize() |
default javaslang.control.Option<T> |
headOption() |
default int |
indexOf(T element,
int from) |
default LazyStream<T> |
init() |
default javaslang.control.Option<javaslang.collection.Stream<T>> |
initOption() |
default LazyStream<T> |
insert(int index,
T element) |
default LazyStream<T> |
insertAll(int index,
java.lang.Iterable<? extends T> elements) |
default LazyStream<T> |
intersperse(T element) |
default boolean |
isTraversableAgain() |
default javaslang.collection.Iterator<T> |
iterator()
An iterator by means of head() and tail().
|
default int |
lastIndexOf(T element,
int end) |
java.util.function.Supplier<T> |
lazyHead() |
default int |
length() |
default <U> LazyStream<U> |
map(java.util.function.Function<? super T,? extends U> mapper) |
default javaslang.control.Match.MatchValue.Of<javaslang.collection.Stream<T>> |
match() |
static <T> LazyStream<T> |
of(T... elements)
Creates a Stream of the given elements.
|
static <T> LazyStream<T> |
of(T element)
Returns a singleton
Stream, i.e. |
static LazyStream<java.lang.Boolean> |
ofAll(boolean[] array)
Creates a Stream based on the elements of a boolean array.
|
static LazyStream<java.lang.Byte> |
ofAll(byte[] array)
Creates a Stream based on the elements of a byte array.
|
static LazyStream<java.lang.Character> |
ofAll(char[] array)
Creates a Stream based on the elements of a char array.
|
static LazyStream<java.lang.Double> |
ofAll(double[] array)
Creates a Stream based on the elements of a double array.
|
static LazyStream<java.lang.Float> |
ofAll(float[] array)
Creates a Stream based on the elements of a float array.
|
static LazyStream<java.lang.Integer> |
ofAll(int[] array)
Creates a Stream based on the elements of an int array.
|
static <T> LazyStream<T> |
ofAll(java.lang.Iterable<? extends T> elements)
Creates a Stream of the given elements.
|
static LazyStream<java.lang.Long> |
ofAll(long[] array)
Creates a Stream based on the elements of a long array.
|
static LazyStream<java.lang.Short> |
ofAll(short[] array)
Creates a Stream based on the elements of a short array.
|
default LazyStream<T> |
padTo(int length,
T element) |
default javaslang.Tuple2<javaslang.collection.Stream<T>,javaslang.collection.Stream<T>> |
partition(java.util.function.Predicate<? super T> predicate) |
default LazyStream<T> |
patch(int from,
java.lang.Iterable<? extends T> that,
int replaced) |
default LazyStream<T> |
peek(java.util.function.Consumer<? super T> action) |
default LazyStream<javaslang.collection.Stream<T>> |
permutations() |
default LazyStream<T> |
prepend(T element) |
default LazyStream<T> |
prependAll(java.lang.Iterable<? extends T> elements) |
static LazyStream<java.lang.Character> |
range(char from,
char toExclusive) |
static LazyStream<java.lang.Integer> |
range(int from,
int toExclusive)
Creates a Stream of int numbers starting from
from, extending to toExclusive - 1. |
static LazyStream<java.lang.Long> |
range(long from,
long toExclusive)
Creates a Stream of long numbers starting from
from, extending to toExclusive - 1. |
static LazyStream<java.lang.Character> |
rangeBy(char from,
char toExclusive,
int step) |
static LazyStream<java.lang.Double> |
rangeBy(double from,
double toExclusive,
double step) |
static LazyStream<java.lang.Integer> |
rangeBy(int from,
int toExclusive,
int step)
Creates a Stream of int numbers starting from
from, extending to toExclusive - 1,
with step. |
static LazyStream<java.lang.Long> |
rangeBy(long from,
long toExclusive,
long step)
Creates a Stream of long numbers starting from
from, extending to toExclusive - 1,
with step. |
static LazyStream<java.lang.Character> |
rangeClosed(char from,
char toInclusive) |
static LazyStream<java.lang.Integer> |
rangeClosed(int from,
int toInclusive)
Creates a Stream of int numbers starting from
from, extending to toInclusive. |
static LazyStream<java.lang.Long> |
rangeClosed(long from,
long toInclusive)
Creates a Stream of long numbers starting from
from, extending to toInclusive. |
static LazyStream<java.lang.Character> |
rangeClosedBy(char from,
char toInclusive,
int step) |
static LazyStream<java.lang.Double> |
rangeClosedBy(double from,
double toInclusive,
double step) |
static LazyStream<java.lang.Integer> |
rangeClosedBy(int from,
int toInclusive,
int step)
Creates a Stream of int numbers starting from
from, extending to toInclusive,
with step. |
static LazyStream<java.lang.Long> |
rangeClosedBy(long from,
long toInclusive,
long step)
Creates a Stream of long numbers starting from
from, extending to toInclusive,
with step. |
default LazyStream<T> |
remove(T element) |
default LazyStream<T> |
removeAll(java.lang.Iterable<? extends T> elements) |
default LazyStream<T> |
removeAll(T removed) |
default LazyStream<T> |
removeAt(int index) |
default LazyStream<T> |
removeFirst(java.util.function.Predicate<T> predicate) |
default LazyStream<T> |
removeLast(java.util.function.Predicate<T> predicate) |
static <T> LazyStream<T> |
repeat(T t)
Repeats an element infinitely often.
|
default LazyStream<T> |
replace(T currentElement,
T newElement) |
default LazyStream<T> |
replaceAll(T currentElement,
T newElement) |
default LazyStream<T> |
retainAll(java.lang.Iterable<? extends T> elements) |
default LazyStream<T> |
reverse() |
default LazyStream<T> |
scan(T zero,
java.util.function.BiFunction<? super T,? super T,? extends T> operation) |
default <U> LazyStream<U> |
scanLeft(U zero,
java.util.function.BiFunction<? super U,? super T,? extends U> operation) |
default <U> LazyStream<U> |
scanRight(U zero,
java.util.function.BiFunction<? super T,? super U,? extends U> operation) |
default org.jooq.lambda.Seq<T> |
seq() |
default com.aol.cyclops.sequence.SequenceM<T> |
sequenceM() |
default LazyStream<T> |
slice(long beginIndex,
long endIndex) |
default javaslang.collection.Iterator<javaslang.collection.Stream<T>> |
sliding(long size) |
default javaslang.collection.Iterator<javaslang.collection.Stream<T>> |
sliding(long size,
long step) |
default LazyStream<T> |
sort() |
default LazyStream<T> |
sort(java.util.Comparator<? super T> comparator) |
default <U> LazyStream<T> |
sortBy(java.util.Comparator<? super U> comparator,
java.util.function.Function<? super T,? extends U> mapper) |
default <U extends java.lang.Comparable<? super U>> |
sortBy(java.util.function.Function<? super T,? extends U> mapper) |
default javaslang.Tuple2<javaslang.collection.Stream<T>,javaslang.collection.Stream<T>> |
span(java.util.function.Predicate<? super T> predicate) |
default javaslang.Tuple2<javaslang.collection.Stream<T>,javaslang.collection.Stream<T>> |
splitAt(long n) |
default javaslang.Tuple2<javaslang.collection.Stream<T>,javaslang.collection.Stream<T>> |
splitAt(java.util.function.Predicate<? super T> predicate) |
default javaslang.Tuple2<javaslang.collection.Stream<T>,javaslang.collection.Stream<T>> |
splitAtInclusive(java.util.function.Predicate<? super T> predicate) |
default java.util.Spliterator<T> |
spliterator() |
default com.aol.cyclops.sequence.SequenceM<T> |
stream() |
default com.aol.cyclops.sequence.streamable.Streamable<T> |
streamable() |
default java.lang.String |
stringPrefix() |
default LazyStream<T> |
subSequence(int beginIndex) |
default LazyStream<T> |
subSequence(int beginIndex,
int endIndex) |
static <T> LazyStream<T> |
tabulate(int n,
java.util.function.Function<? super java.lang.Integer,? extends T> f)
Returns a Stream containing
n values of a given Function f
over a range of integer values from 0 to n - 1. |
LazyStream<T> |
tail() |
default javaslang.control.Option<javaslang.collection.Stream<T>> |
tailOption() |
default LazyStream<T> |
take(long n) |
default LazyStream<T> |
takeRight(long n) |
default LazyStream<T> |
takeUntil(java.util.function.Predicate<? super T> predicate) |
default LazyStream<T> |
takeWhile(java.util.function.Predicate<? super T> predicate) |
default com.aol.simple.react.async.Queue<T> |
toAsyncBlockingQueue(int boundSize)
To Transfer Queue
|
default com.aol.simple.react.async.Queue<T> |
toAsyncQueue() |
default com.aol.simple.react.async.Queue<T> |
toAsyncQueue(int boundSize) |
default <C extends java.util.Collection<T>> |
toCollection(java.util.function.Supplier<C> collectionFactory) |
default LazyStream<T> |
toStream() |
static <T extends javaslang.collection.Traversable<V>,V> |
toTraversable(javaslang.Value<V> value,
T empty,
java.util.function.Function<V,T> ofElement,
java.util.function.Function<java.lang.Iterable<V>,T> ofAll) |
default <U> LazyStream<U> |
unit(java.lang.Iterable<? extends U> iterable) |
default <T1,T2> javaslang.Tuple2<javaslang.collection.Stream<T1>,javaslang.collection.Stream<T2>> |
unzip(java.util.function.Function<? super T,javaslang.Tuple2<? extends T1,? extends T2>> unzipper) |
default <T1,T2,T3> javaslang.Tuple3<javaslang.collection.Stream<T1>,javaslang.collection.Stream<T2>,javaslang.collection.Stream<T3>> |
unzip3(java.util.function.Function<? super T,javaslang.Tuple3<? extends T1,? extends T2,? extends T3>> unzipper) |
default LazyStream<T> |
update(int index,
T element) |
default <U> LazyStream<javaslang.Tuple2<T,U>> |
zip(java.lang.Iterable<U> iterable) |
default <U> LazyStream<javaslang.Tuple2<T,U>> |
zipAll(java.lang.Iterable<U> iterable,
T thisElem,
U thatElem) |
default LazyStream<javaslang.Tuple2<T,java.lang.Long>> |
zipWithIndex() |
indexWhere, lastIndexOfSlice, lastIndexWhere, reverseIterator, segmentLengthapply, containsSlice, endsWith, foldRight, indexOf, indexOfSlice, indexOfSlice, indexWhere, iterator, lastIndexOf, lastIndexOfSlice, lastIndexWhere, prefixLength, startsWith, startsWith, transformaverage, containsAll, count, existsUnique, find, findLast, foldLeft, get, hash, head, isEmpty, isSingleValued, last, lastOption, max, maxBy, maxBy, min, minBy, minBy, mkString, mkString, mkString, product, reduceLeft, reduceLeftOption, reduceRight, reduceRightOption, size, sumcontains, corresponds, eq, equals, exists, forAll, forEach, getOption, getOrElse, getOrElse, getOrElseThrow, getOrElseTry, hashCode, isDefined, out, out, stderr, stdout, toArray, toCharSeq, toJavaArray, toJavaArray, toJavaList, toJavaMap, toJavaOptional, toJavaSet, toJavaStream, toLeft, toLeft, toList, toMap, toOption, toQueue, toRight, toRight, toSet, toStack, toString, toTree, toTry, toTry, toVectorstatic final long serialVersionUID
default com.aol.cyclops.sequence.SequenceM<T> stream()
static <T> java.util.stream.Collector<T,java.util.ArrayList<T>,LazyStream<T>> collector()
Collector which may be used in conjunction with
Stream.collect(java.util.stream.Collector) to obtain a LazyStream.collector in interface javaslang.collection.Stream<T>T - Component type of the Stream.static <T> LazyStream<T> fromStream(javaslang.collection.Stream<T> stream)
static LazyStream<java.lang.Integer> from(int value)
from.
The Stream extends to Integer.MIN_VALUE when passing Integer.MAX_VALUE.
from in interface javaslang.collection.Stream<T>value - a start int valuefromstatic LazyStream<java.lang.Long> from(long value)
from.
The Stream extends to Integer.MIN_VALUE when passing Long.MAX_VALUE.
from in interface javaslang.collection.Stream<T>value - a start long valuefromstatic <T> LazyStream<T> gen(java.util.function.Supplier<? extends T> supplier)
gen in interface javaslang.collection.Stream<T>T - value typesupplier - A Supplier of Stream valuesstatic <T> LazyStream<T> gen(T seed, java.util.function.Function<? super T,? extends T> f)
gen in interface javaslang.collection.Stream<T>T - value typeseed - The first value in the Streamf - A function to calculate the next value based on the previousstatic <T> LazyStream<T> cons(java.util.function.Supplier<T> head, java.util.function.Supplier<? extends LazyStream<? extends T>> tailSupplier)
T - value typehead - The head element of the StreamtailSupplier - A supplier of the tail values. To end the stream, return empty().static <T> LazyStream<T> empty()
Nil.instance().
Note: this method intentionally returns type Stream and not Nil. This comes handy when folding.
If you explicitly need type Nil use LazyStream.Empty.instance().
empty in interface javaslang.collection.Stream<T>T - Component type of Nil, determined by type inference in the particular context.static <T> LazyStream<T> of(T element)
Stream, i.e. a Stream of one element.@SafeVarargs static <T> LazyStream<T> of(T... elements)
Stream.of(1, 2, 3, 4)
= Nil.instance().prepend(4).prepend(3).prepend(2).prepend(1)
= new Cons(1, new Cons(2, new Cons(3, new Cons(4, Nil.instance()))))of in interface javaslang.collection.Stream<T>T - Component type of the Stream.elements - Zero or more elements.default javaslang.collection.Iterator<T> iterator()
static <T> LazyStream<T> tabulate(int n, java.util.function.Function<? super java.lang.Integer,? extends T> f)
n values of a given Function f
over a range of integer values from 0 to n - 1.tabulate in interface javaslang.collection.Stream<T>T - Component type of the Streamn - The number of elements in the Streamf - The Function computing element valuesf(0),f(1), ..., f(n - 1)java.lang.NullPointerException - if f is nullstatic <T> LazyStream<T> fill(int n, java.util.function.Supplier<? extends T> s)
n values supplied by a given Supplier s.fill in interface javaslang.collection.Stream<T>T - Component type of the Streamn - The number of elements in the Streams - The Supplier computing element valuesn, where each element contains the result supplied by s.java.lang.NullPointerException - if s is nullstatic <T> LazyStream<T> ofAll(java.lang.Iterable<? extends T> elements)
static LazyStream<java.lang.Boolean> ofAll(boolean[] array)
ofAll in interface javaslang.collection.Stream<T>array - a boolean arraystatic LazyStream<java.lang.Byte> ofAll(byte[] array)
ofAll in interface javaslang.collection.Stream<T>array - a byte arraystatic LazyStream<java.lang.Character> ofAll(char[] array)
ofAll in interface javaslang.collection.Stream<T>array - a char arraystatic LazyStream<java.lang.Double> ofAll(double[] array)
ofAll in interface javaslang.collection.Stream<T>array - a double arraystatic LazyStream<java.lang.Float> ofAll(float[] array)
ofAll in interface javaslang.collection.Stream<T>array - a float arraystatic LazyStream<java.lang.Integer> ofAll(int[] array)
ofAll in interface javaslang.collection.Stream<T>array - an int arraystatic LazyStream<java.lang.Long> ofAll(long[] array)
ofAll in interface javaslang.collection.Stream<T>array - a long arraystatic LazyStream<java.lang.Short> ofAll(short[] array)
ofAll in interface javaslang.collection.Stream<T>array - a short arraystatic LazyStream<java.lang.Character> range(char from, char toExclusive)
range in interface javaslang.collection.Stream<T>static LazyStream<java.lang.Character> rangeBy(char from, char toExclusive, int step)
rangeBy in interface javaslang.collection.Stream<T>static LazyStream<java.lang.Double> rangeBy(double from, double toExclusive, double step)
rangeBy in interface javaslang.collection.Stream<T>static LazyStream<java.lang.Integer> range(int from, int toExclusive)
from, extending to toExclusive - 1.
Examples:
Stream.range(0, 0) // = Stream()
Stream.range(2, 0) // = Stream()
Stream.range(-2, 2) // = Stream(-2, -1, 0, 1)
range in interface javaslang.collection.Stream<T>from - the first numbertoExclusive - the last number + 1Nil if from >= toExclusivestatic LazyStream<java.lang.Integer> rangeBy(int from, int toExclusive, int step)
from, extending to toExclusive - 1,
with step.
Examples:
Stream.rangeBy(1, 3, 1) // = Stream(1, 2)
Stream.rangeBy(1, 4, 2) // = Stream(1, 3)
Stream.rangeBy(4, 1, -2) // = Stream(4, 2)
Stream.rangeBy(4, 1, 2) // = Stream()
rangeBy in interface javaslang.collection.Stream<T>from - the first numbertoExclusive - the last number + 1step - the stepNil iffrom >= toInclusive and step > 0 orfrom <= toInclusive and step < 0java.lang.IllegalArgumentException - if step is zerostatic LazyStream<java.lang.Long> range(long from, long toExclusive)
from, extending to toExclusive - 1.
Examples:
Stream.range(0L, 0L) // = Stream()
Stream.range(2L, 0L) // = Stream()
Stream.range(-2L, 2L) // = Stream(-2L, -1L, 0L, 1L)
range in interface javaslang.collection.Stream<T>from - the first numbertoExclusive - the last number + 1Nil if from >= toExclusivestatic LazyStream<java.lang.Long> rangeBy(long from, long toExclusive, long step)
from, extending to toExclusive - 1,
with step.
Examples:
Stream.rangeBy(1L, 3L, 1L) // = Stream(1L, 2L)
Stream.rangeBy(1L, 4L, 2L) // = Stream(1L, 3L)
Stream.rangeBy(4L, 1L, -2L) // = Stream(4L, 2L)
Stream.rangeBy(4L, 1L, 2L) // = Stream()
rangeBy in interface javaslang.collection.Stream<T>from - the first numbertoExclusive - the last number + 1step - the stepNil iffrom >= toInclusive and step > 0 orfrom <= toInclusive and step < 0java.lang.IllegalArgumentException - if step is zerostatic LazyStream<java.lang.Character> rangeClosed(char from, char toInclusive)
rangeClosed in interface javaslang.collection.Stream<T>static LazyStream<java.lang.Character> rangeClosedBy(char from, char toInclusive, int step)
rangeClosedBy in interface javaslang.collection.Stream<T>static LazyStream<java.lang.Double> rangeClosedBy(double from, double toInclusive, double step)
rangeClosedBy in interface javaslang.collection.Stream<T>static LazyStream<java.lang.Integer> rangeClosed(int from, int toInclusive)
from, extending to toInclusive.
Examples:
Stream.rangeClosed(0, 0) // = Stream(0)
Stream.rangeClosed(2, 0) // = Stream()
Stream.rangeClosed(-2, 2) // = Stream(-2, -1, 0, 1, 2)
rangeClosed in interface javaslang.collection.Stream<T>from - the first numbertoInclusive - the last numberNil if from > toInclusivestatic LazyStream<java.lang.Integer> rangeClosedBy(int from, int toInclusive, int step)
from, extending to toInclusive,
with step.
Examples:
Stream.rangeClosedBy(1, 3, 1) // = Stream(1, 2, 3)
Stream.rangeClosedBy(1, 4, 2) // = Stream(1, 3)
Stream.rangeClosedBy(4, 1, -2) // = Stream(4, 2)
Stream.rangeClosedBy(4, 1, 2) // = Stream()
rangeClosedBy in interface javaslang.collection.Stream<T>from - the first numbertoInclusive - the last numberstep - the stepNil iffrom > toInclusive and step > 0 orfrom < toInclusive and step < 0java.lang.IllegalArgumentException - if step is zerostatic LazyStream<java.lang.Long> rangeClosed(long from, long toInclusive)
from, extending to toInclusive.
Examples:
Stream.rangeClosed(0L, 0L) // = Stream(0L)
Stream.rangeClosed(2L, 0L) // = Stream()
Stream.rangeClosed(-2L, 2L) // = Stream(-2L, -1L, 0L, 1L, 2L)
rangeClosed in interface javaslang.collection.Stream<T>from - the first numbertoInclusive - the last numberNil if from > toInclusivestatic LazyStream<java.lang.Long> rangeClosedBy(long from, long toInclusive, long step)
from, extending to toInclusive,
with step.
Examples:
Stream.rangeClosedBy(1L, 3L, 1L) // = Stream(1L, 2L, 3L)
Stream.rangeClosedBy(1L, 4L, 2L) // = Stream(1L, 3L)
Stream.rangeClosedBy(4L, 1L, -2L) // = Stream(4L, 2L)
Stream.rangeClosedBy(4L, 1L, 2L) // = Stream()
rangeClosedBy in interface javaslang.collection.Stream<T>from - the first numbertoInclusive - the last numberstep - the stepNil iffrom > toInclusive and step > 0 orfrom < toInclusive and step < 0java.lang.IllegalArgumentException - if step is zerostatic <T> LazyStream<T> repeat(T t)
repeat in interface javaslang.collection.Stream<T>T - Element typet - An elementt's.default LazyStream<T> toStream()
toStream in interface javaslang.Value<T>static <T extends javaslang.collection.Traversable<V>,V> T toTraversable(javaslang.Value<V> value,
T empty,
java.util.function.Function<V,T> ofElement,
java.util.function.Function<java.lang.Iterable<V>,T> ofAll)
java.util.function.Supplier<T> lazyHead()
default LazyStream<T> append(T element)
default LazyStream<T> appendAll(java.lang.Iterable<? extends T> elements)
default LazyStream<T> appendSelf(java.util.function.Function<? super javaslang.collection.Stream<T>,? extends javaslang.collection.Stream<T>> mapper)
mapper function.
Example:
Well known scala code for Fibonacci infinite sequence
val fibs:Stream[Int] = 0 #:: 1 #:: (fibs zip fibs.tail).map{ t => t._1 + t._2 }
can be transformed to
Stream.of(0, 1).appendSelf(self -> self.zip(self.tail()).map(t -> t._1 + t._2));
appendSelf in interface javaslang.collection.Stream<T>mapper - an mapperdefault com.aol.simple.react.async.Queue<T> toAsyncBlockingQueue(int boundSize)
default com.aol.simple.react.async.Queue<T> toAsyncQueue()
default com.aol.simple.react.async.Queue<T> toAsyncQueue(int boundSize)
default org.jooq.lambda.Collectable<T> collectable()
default <R> R collect(java.util.function.Supplier<R> supplier,
java.util.function.BiConsumer<R,? super T> accumulator,
java.util.function.BiConsumer<R,R> combiner)
default <R,A> R collect(java.util.stream.Collector<? super T,A,R> collector)
default <C extends java.util.Collection<T>> C toCollection(java.util.function.Supplier<C> collectionFactory)
default com.aol.cyclops.monad.AnyM<T> anyM()
default com.aol.cyclops.sequence.SequenceM<T> sequenceM()
default org.jooq.lambda.Seq<T> seq()
default com.aol.cyclops.sequence.streamable.Streamable<T> streamable()
default com.aol.simple.react.stream.traits.LazyFutureStream<T> futureStream()
default com.aol.simple.react.stream.traits.LazyFutureStream<T> futureStream(com.aol.simple.react.stream.lazy.LazyReact react)
default com.aol.simple.react.stream.traits.SimpleReactStream<T> futures()
default com.aol.simple.react.stream.traits.SimpleReactStream<T> futures(com.aol.simple.react.stream.simple.SimpleReact react)
default LazyStream<T> clear()
default LazyStream<javaslang.collection.Stream<T>> combinations()
default LazyStream<javaslang.collection.Stream<T>> combinations(int k)
default LazyStream<javaslang.Tuple2<T,T>> crossProduct()
default LazyStream<javaslang.collection.Stream<T>> crossProduct(int power)
default <U> LazyStream<javaslang.Tuple2<T,U>> crossProduct(java.lang.Iterable<? extends U> that)
default LazyStream<T> cycle()
Example:
// = 1, 2, 3, 1, 2, 3, 1, 2, 3, ...
Stream.of(1, 2, 3).cycle();
cycle in interface javaslang.collection.Stream<T>default LazyStream<T> distinct()
default LazyStream<T> distinctBy(java.util.Comparator<? super T> comparator)
default <U> LazyStream<T> distinctBy(java.util.function.Function<? super T,? extends U> keyExtractor)
default LazyStream<T> drop(long n)
default LazyStream<T> dropRight(long n)
default LazyStream<T> dropUntil(java.util.function.Predicate<? super T> predicate)
default LazyStream<T> dropWhile(java.util.function.Predicate<? super T> predicate)
default LazyStream<T> filter(java.util.function.Predicate<? super T> predicate)
default <U> LazyStream<U> flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends U>> mapper)
default T get(int index)
default <C> javaslang.collection.Map<C,javaslang.collection.Stream<T>> groupBy(java.util.function.Function<? super T,? extends C> classifier)
default javaslang.collection.Iterator<javaslang.collection.Stream<T>> grouped(long size)
default boolean hasDefiniteSize()
default javaslang.control.Option<T> headOption()
default int indexOf(T element, int from)
default LazyStream<T> init()
default javaslang.control.Option<javaslang.collection.Stream<T>> initOption()
default LazyStream<T> insert(int index, T element)
default LazyStream<T> insertAll(int index, java.lang.Iterable<? extends T> elements)
default LazyStream<T> intersperse(T element)
default boolean isTraversableAgain()
default int lastIndexOf(T element, int end)
default int length()
default <U> LazyStream<U> map(java.util.function.Function<? super T,? extends U> mapper)
map in interface com.aol.cyclops.lambda.monads.Functor<T>map in interface javaslang.collection.LinearSeq<T>map in interface javaslang.collection.Seq<T>map in interface javaslang.collection.Stream<T>map in interface javaslang.collection.Traversable<T>map in interface javaslang.Value<T>default javaslang.control.Match.MatchValue.Of<javaslang.collection.Stream<T>> match()
match in interface javaslang.collection.LinearSeq<T>match in interface javaslang.collection.Seq<T>match in interface javaslang.collection.Stream<T>match in interface javaslang.collection.Traversable<T>match in interface javaslang.Value<T>default LazyStream<T> padTo(int length, T element)
default LazyStream<T> patch(int from, java.lang.Iterable<? extends T> that, int replaced)
default javaslang.Tuple2<javaslang.collection.Stream<T>,javaslang.collection.Stream<T>> partition(java.util.function.Predicate<? super T> predicate)
default LazyStream<T> peek(java.util.function.Consumer<? super T> action)
peek in interface com.aol.cyclops.lambda.monads.Functor<T>peek in interface javaslang.collection.LinearSeq<T>peek in interface javaslang.collection.Seq<T>peek in interface javaslang.collection.Stream<T>peek in interface javaslang.collection.Traversable<T>peek in interface javaslang.Value<T>default LazyStream<javaslang.collection.Stream<T>> permutations()
default LazyStream<T> prepend(T element)
default LazyStream<T> prependAll(java.lang.Iterable<? extends T> elements)
default LazyStream<T> remove(T element)
default LazyStream<T> removeFirst(java.util.function.Predicate<T> predicate)
default LazyStream<T> removeLast(java.util.function.Predicate<T> predicate)
default LazyStream<T> removeAt(int index)
default LazyStream<T> removeAll(T removed)
default LazyStream<T> removeAll(java.lang.Iterable<? extends T> elements)
default LazyStream<T> replace(T currentElement, T newElement)
default LazyStream<T> replaceAll(T currentElement, T newElement)
default LazyStream<T> retainAll(java.lang.Iterable<? extends T> elements)
default LazyStream<T> reverse()
default LazyStream<T> scan(T zero, java.util.function.BiFunction<? super T,? super T,? extends T> operation)
default <U> LazyStream<U> scanLeft(U zero, java.util.function.BiFunction<? super U,? super T,? extends U> operation)
default <U> LazyStream<U> scanRight(U zero, java.util.function.BiFunction<? super T,? super U,? extends U> operation)
default LazyStream<T> slice(long beginIndex, long endIndex)
default javaslang.collection.Iterator<javaslang.collection.Stream<T>> sliding(long size)
default javaslang.collection.Iterator<javaslang.collection.Stream<T>> sliding(long size, long step)
default LazyStream<T> sort()
default LazyStream<T> sort(java.util.Comparator<? super T> comparator)
default <U extends java.lang.Comparable<? super U>> LazyStream<T> sortBy(java.util.function.Function<? super T,? extends U> mapper)
default <U> LazyStream<T> sortBy(java.util.Comparator<? super U> comparator, java.util.function.Function<? super T,? extends U> mapper)
default javaslang.Tuple2<javaslang.collection.Stream<T>,javaslang.collection.Stream<T>> span(java.util.function.Predicate<? super T> predicate)
default javaslang.Tuple2<javaslang.collection.Stream<T>,javaslang.collection.Stream<T>> splitAt(long n)
default javaslang.Tuple2<javaslang.collection.Stream<T>,javaslang.collection.Stream<T>> splitAt(java.util.function.Predicate<? super T> predicate)
default javaslang.Tuple2<javaslang.collection.Stream<T>,javaslang.collection.Stream<T>> splitAtInclusive(java.util.function.Predicate<? super T> predicate)
default java.util.Spliterator<T> spliterator()
default java.lang.String stringPrefix()
default LazyStream<T> subSequence(int beginIndex)
default LazyStream<T> subSequence(int beginIndex, int endIndex)
LazyStream<T> tail()
default javaslang.control.Option<javaslang.collection.Stream<T>> tailOption()
default LazyStream<T> take(long n)
default LazyStream<T> takeRight(long n)
default LazyStream<T> takeUntil(java.util.function.Predicate<? super T> predicate)
default LazyStream<T> takeWhile(java.util.function.Predicate<? super T> predicate)
default <U> LazyStream<U> unit(java.lang.Iterable<? extends U> iterable)
default <T1,T2> javaslang.Tuple2<javaslang.collection.Stream<T1>,javaslang.collection.Stream<T2>> unzip(java.util.function.Function<? super T,javaslang.Tuple2<? extends T1,? extends T2>> unzipper)
default <T1,T2,T3> javaslang.Tuple3<javaslang.collection.Stream<T1>,javaslang.collection.Stream<T2>,javaslang.collection.Stream<T3>> unzip3(java.util.function.Function<? super T,javaslang.Tuple3<? extends T1,? extends T2,? extends T3>> unzipper)
default LazyStream<T> update(int index, T element)
default <U> LazyStream<javaslang.Tuple2<T,U>> zip(java.lang.Iterable<U> iterable)
default <U> LazyStream<javaslang.Tuple2<T,U>> zipAll(java.lang.Iterable<U> iterable, T thisElem, U thatElem)
default LazyStream<javaslang.Tuple2<T,java.lang.Long>> zipWithIndex()