T
- component type of this Streampublic interface Stream<T> extends Kind1<Stream<?>,T>, LinearSeq<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:
Stream.Empty
, which represents the empty Stream
.Stream.Cons
, 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.continually(Supplier) // e.g. Stream.continually(Math::random);
Stream.iterate(Object, Function)// e.g. Stream.iterate(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.iterate(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 |
Stream.Cons<T>
Non-empty
Stream , consisting of a head , and tail . |
static class |
Stream.Empty<T>
The empty Stream.
|
λ.Memoized
Modifier and Type | Field and Description |
---|---|
static long |
serialVersionUID |
Modifier and Type | Method and Description |
---|---|
default Stream<T> |
append(T element)
Appends an element to this.
|
default Stream<T> |
appendAll(Iterable<? extends T> elements)
Appends all given elements to this.
|
default Stream<T> |
appendSelf(Function<? super Stream<T>,? extends Stream<T>> mapper)
Appends itself to the end of stream with
mapper function. |
static <T> Collector<T,ArrayList<T>,Stream<T>> |
collector()
Returns a
Collector which may be used in conjunction with
Stream.collect(java.util.stream.Collector) to obtain a Stream . |
default Stream<Stream<T>> |
combinations()
Returns the union of all combinations from k = 0 to length().
|
default Stream<Stream<T>> |
combinations(int k)
Returns the k-combination of this traversable, i.e.
|
static <T> Stream<T> |
cons(T head,
Supplier<? extends Stream<? extends T>> tailSupplier)
Constructs a Stream of a head element and a tail supplier.
|
static <T> Stream<T> |
continually(Supplier<? extends T> supplier)
Generates an (theoretically) infinitely long Stream using a value Supplier.
|
static <T> Stream<T> |
continually(T t)
Repeats an element infinitely often.
|
default Iterator<Stream<T>> |
crossProduct(int power)
Calculates the n-ary cartesian power (or cross product or simply product) of this.
|
default Stream<T> |
cycle()
Repeat the elements of this Stream infinitely.
|
default Stream<T> |
cycle(int count)
Repeat the elements of this Stream
count times. |
default Stream<T> |
distinct()
Returns a new version of this which contains no duplicates.
|
default Stream<T> |
distinctBy(Comparator<? super T> comparator)
Returns a new version of this which contains no duplicates.
|
default <U> Stream<T> |
distinctBy(Function<? super T,? extends U> keyExtractor)
Returns a new version of this which contains no duplicates.
|
default Stream<T> |
drop(long n)
Drops the first n elements of this or all elements, if this length < n.
|
default Stream<T> |
dropRight(long n)
Drops the last n elements of this or all elements, if this length < n.
|
default Stream<T> |
dropUntil(Predicate<? super T> predicate)
Drops elements until the predicate holds for the current element.
|
default Stream<T> |
dropWhile(Predicate<? super T> predicate)
Drops elements while the predicate holds for the current element.
|
static <T> Stream<T> |
empty()
Returns the single instance of Nil.
|
default Stream<T> |
extend(Function<? super T,? extends T> nextFunction)
Extends (continues) this
Stream with a Stream of values created by applying
consecutively provided Function to the last element of the original Stream. |
default Stream<T> |
extend(Supplier<? extends T> nextSupplier)
Extends (continues) this
Stream with values provided by a Supplier |
default Stream<T> |
extend(T next)
Extends (continues) this
Stream with a constantly repeated value. |
static <T> Stream<T> |
fill(int n,
Supplier<? extends T> s)
Returns a Stream containing
n values supplied by a given Supplier s . |
default Stream<T> |
filter(Predicate<? super T> predicate)
Returns a new traversable consisting of all elements which satisfy the given predicate.
|
default <U> Stream<U> |
flatMap(Function<? super T,? extends Iterable<? extends U>> mapper)
FlatMaps this Traversable.
|
static Stream<Integer> |
from(int value)
Returns an infinitely long Stream of
int values starting from from . |
static Stream<Integer> |
from(int value,
int step)
Returns an infinite long Stream of
int values starting from value and spaced by step . |
static Stream<Long> |
from(long value)
Returns an infinitely long Stream of
long values starting from from . |
static Stream<Long> |
from(long value,
long step)
Returns an infinite long Stream of
long values starting from value and spaced by step . |
default T |
get(int index)
Returns the element at the specified index.
|
default <C> Map<C,Stream<T>> |
groupBy(Function<? super T,? extends C> classifier)
Groups this elements by classifying the elements.
|
default Iterator<Stream<T>> |
grouped(long size)
Groups this
Traversable into fixed size blocks. |
default boolean |
hasDefiniteSize()
Checks if this Traversable is known to have a finite size.
|
default Option<T> |
headOption()
Returns the first element of a non-empty Traversable as
Option . |
default int |
indexOf(T element,
int from)
Returns the index of the first occurrence of the given element after or at some start index
or -1 if this does not contain the given element.
|
default Stream<T> |
init()
Dual of Traversable.tail(), returning all elements except the last.
|
default Option<Stream<T>> |
initOption()
Dual of Traversable.tailOption(), returning all elements except the last as
Option . |
default Stream<T> |
insert(int index,
T element)
Inserts the given element at the specified index.
|
default Stream<T> |
insertAll(int index,
Iterable<? extends T> elements)
Inserts the given elements at the specified index.
|
default Stream<T> |
intersperse(T element)
Inserts an element between all elements of this Traversable.
|
default boolean |
isTraversableAgain()
Checks if this Traversable can be repeatedly traversed.
|
static <T> Stream<T> |
iterate(T seed,
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 int |
lastIndexOf(T element,
int end)
Returns the index of the last occurrence of the given element before or at a given end index
or -1 if this does not contain the given element.
|
default int |
length()
Computes the number of elements of this Traversable.
|
default <U> Stream<U> |
map(Function<? super T,? extends U> mapper)
Maps the elements of this
Traversable to elements of a new type preserving their order, if any. |
static <T> Stream<T> |
narrow(Stream<? extends T> stream)
Narrows a widened
Stream<? extends T> to Stream<T>
by performing a type safe-cast. |
static <T> Stream<T> |
of(T... elements)
Creates a Stream of the given elements.
|
static <T> Stream<T> |
of(T element)
Returns a singleton
Stream , i.e. |
static Stream<Boolean> |
ofAll(boolean[] array)
Creates a Stream based on the elements of a boolean array.
|
static Stream<Byte> |
ofAll(byte[] array)
Creates a Stream based on the elements of a byte array.
|
static Stream<Character> |
ofAll(char[] array)
Creates a Stream based on the elements of a char array.
|
static Stream<Double> |
ofAll(double[] array)
Creates a Stream based on the elements of a double array.
|
static Stream<Float> |
ofAll(float[] array)
Creates a Stream based on the elements of a float array.
|
static Stream<Integer> |
ofAll(int[] array)
Creates a Stream based on the elements of an int array.
|
static <T> Stream<T> |
ofAll(Iterable<? extends T> elements)
Creates a Stream of the given elements.
|
static Stream<Long> |
ofAll(long[] array)
Creates a Stream based on the elements of a long array.
|
static Stream<Short> |
ofAll(short[] array)
Creates a Stream based on the elements of a short array.
|
default Stream<T> |
padTo(int length,
T element)
A copy of this sequence with an element appended until a given target length is reached.
|
default Tuple2<Stream<T>,Stream<T>> |
partition(Predicate<? super T> predicate)
Creates a partition of this
Traversable by splitting this elements in two in distinct tarversables
according to a predicate. |
default Stream<T> |
patch(int from,
Iterable<? extends T> that,
int replaced)
Produces a new list where a slice of elements in this list is replaced by another sequence.
|
default Stream<T> |
peek(Consumer<? super T> action)
Performs the given
action on the first element if this is an eager implementation. |
default Stream<Stream<T>> |
permutations()
Computes all unique permutations.
|
default Stream<T> |
prepend(T element)
Prepends an element to this.
|
default Stream<T> |
prependAll(Iterable<? extends T> elements)
Prepends all given elements to this.
|
static Stream<Character> |
range(char from,
char toExclusive) |
static Stream<Integer> |
range(int from,
int toExclusive)
Creates a Stream of int numbers starting from
from , extending to toExclusive - 1 . |
static Stream<Long> |
range(long from,
long toExclusive)
Creates a Stream of long numbers starting from
from , extending to toExclusive - 1 . |
static Stream<Character> |
rangeBy(char from,
char toExclusive,
int step) |
static Stream<Double> |
rangeBy(double from,
double toExclusive,
double step) |
static Stream<Integer> |
rangeBy(int from,
int toExclusive,
int step)
Creates a Stream of int numbers starting from
from , extending to toExclusive - 1 ,
with step . |
static Stream<Long> |
rangeBy(long from,
long toExclusive,
long step)
Creates a Stream of long numbers starting from
from , extending to toExclusive - 1 ,
with step . |
static Stream<Character> |
rangeClosed(char from,
char toInclusive) |
static Stream<Integer> |
rangeClosed(int from,
int toInclusive)
Creates a Stream of int numbers starting from
from , extending to toInclusive . |
static Stream<Long> |
rangeClosed(long from,
long toInclusive)
Creates a Stream of long numbers starting from
from , extending to toInclusive . |
static Stream<Character> |
rangeClosedBy(char from,
char toInclusive,
int step) |
static Stream<Double> |
rangeClosedBy(double from,
double toInclusive,
double step) |
static Stream<Integer> |
rangeClosedBy(int from,
int toInclusive,
int step)
Creates a Stream of int numbers starting from
from , extending to toInclusive ,
with step . |
static Stream<Long> |
rangeClosedBy(long from,
long toInclusive,
long step)
Creates a Stream of long numbers starting from
from , extending to toInclusive ,
with step . |
default Stream<T> |
remove(T element)
Removes the first occurrence of the given element.
|
default Stream<T> |
removeAll(Iterable<? extends T> elements)
Removes all occurrences of the given elements.
|
default Stream<T> |
removeAll(T removed)
Removes all occurrences of the given element.
|
default Stream<T> |
removeAt(int index)
Removes the element at the specified position in this sequence.
|
default Stream<T> |
removeFirst(Predicate<T> predicate)
Removes the first occurrence that satisfy predicate
|
default Stream<T> |
removeLast(Predicate<T> predicate)
Removes the last occurrence that satisfy predicate
|
default Stream<T> |
replace(T currentElement,
T newElement)
Replaces the first occurrence (if exists) of the given currentElement with newElement.
|
default Stream<T> |
replaceAll(T currentElement,
T newElement)
Replaces all occurrences of the given currentElement with newElement.
|
default Stream<T> |
retainAll(Iterable<? extends T> elements)
Keeps all occurrences of the given elements from this.
|
default Stream<T> |
reverse()
Reverses the order of elements.
|
default Stream<T> |
scan(T zero,
BiFunction<? super T,? super T,? extends T> operation)
Computes a prefix scan of the elements of the collection.
|
default <U> Stream<U> |
scanLeft(U zero,
BiFunction<? super U,? super T,? extends U> operation)
Produces a collection containing cumulative results of applying the
operator going left to right.
|
default <U> Stream<U> |
scanRight(U zero,
BiFunction<? super T,? super U,? extends U> operation)
Produces a collection containing cumulative results of applying the
operator going right to left.
|
default Stream<T> |
slice(long beginIndex,
long endIndex)
Returns a Seq that is a slice of this.
|
default Iterator<Stream<T>> |
sliding(long size)
Slides a window of a specific
size and step size 1 over this Traversable by calling
Traversable.sliding(long, long) . |
default Iterator<Stream<T>> |
sliding(long size,
long step)
Slides a window of a specific
size and step size over this Traversable . |
default <U> Stream<T> |
sortBy(Comparator<? super U> comparator,
Function<? super T,? extends U> mapper)
Sorts this elements by comparing the elements in a different domain, using the given
mapper . |
default <U extends Comparable<? super U>> |
sortBy(Function<? super T,? extends U> mapper)
Sorts this elements by comparing the elements in a different domain, using the given
mapper . |
default Stream<T> |
sorted()
Sorts this elements according to their natural order.
|
default Stream<T> |
sorted(Comparator<? super T> comparator)
Sorts this elements according to the provided
Comparator . |
default Tuple2<Stream<T>,Stream<T>> |
span(Predicate<? super T> predicate)
Returns a tuple where the first element is the longest prefix of elements that satisfy the given
predicate and the second element is the remainder. |
default Tuple2<Stream<T>,Stream<T>> |
splitAt(long n)
Splits a Seq at the specified index.
|
default Tuple2<Stream<T>,Stream<T>> |
splitAt(Predicate<? super T> predicate)
Splits a sequence at the first element which satisfies the
Predicate , e.g. |
default Tuple2<Stream<T>,Stream<T>> |
splitAtInclusive(Predicate<? super T> predicate)
Splits a sequence at the first element which satisfies the
Predicate , e.g. |
default Spliterator<T> |
spliterator() |
default String |
stringPrefix()
Returns the name of this Value type, which is used by toString().
|
default Stream<T> |
subSequence(int beginIndex)
Returns a Seq that is a subsequence of this.
|
default Stream<T> |
subSequence(int beginIndex,
int endIndex)
Returns a Seq that is a subsequence of this.
|
static <T> Stream<T> |
tabulate(int n,
Function<? super 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 . |
Stream<T> |
tail()
Drops the first element of a non-empty Traversable.
|
default Option<Stream<T>> |
tailOption()
Drops the first element of a non-empty Traversable and returns an
Option . |
default Stream<T> |
take(long n)
Takes the first n elements of this or all elements, if this length < n.
|
default Stream<T> |
takeRight(long n)
Takes the last n elements of this or all elements, if this length < n.
|
default Stream<T> |
takeUntil(Predicate<? super T> predicate)
Takes elements until the predicate holds for the current element.
|
default Stream<T> |
takeWhile(Predicate<? super T> predicate)
Takes elements while the predicate holds for the current element.
|
default <U> U |
transform(Function<? super Stream<T>,? extends U> f)
Transforms this
Stream . |
default <U> Stream<U> |
unit(Iterable<? extends U> iterable) |
default <T1,T2> Tuple2<Stream<T1>,Stream<T2>> |
unzip(Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
Unzips this elements by mapping this elements to pairs which are subsequently split into two distinct
sets.
|
default <T1,T2,T3> Tuple3<Stream<T1>,Stream<T2>,Stream<T3>> |
unzip3(Function<? super T,Tuple3<? extends T1,? extends T2,? extends T3>> unzipper)
Unzips this elements by mapping this elements to triples which are subsequently split into three distinct
sets.
|
default Stream<T> |
update(int index,
T element)
Updates the given element at the specified index.
|
default <U> Stream<Tuple2<T,U>> |
zip(Iterable<U> iterable)
Returns a traversable formed from this traversable and another Iterable collection by combining
corresponding elements in pairs.
|
default <U> Stream<Tuple2<T,U>> |
zipAll(Iterable<U> iterable,
T thisElem,
U thatElem)
Returns a traversable formed from this traversable and another Iterable by combining corresponding elements in
pairs.
|
default Stream<Tuple2<T,Long>> |
zipWithIndex()
Zips this traversable with its indices.
|
indexWhere, lastIndexOfSlice, lastIndexWhere, narrow, reverseIterator, search, search, segmentLength
apply, containsSlice, crossProduct, crossProduct, endsWith, foldRight, indexOf, indexOfSlice, indexOfSlice, indexWhere, iterator, lastIndexOf, lastIndexOfSlice, lastIndexWhere, narrow, prefixLength, startsWith, startsWith
average, containsAll, count, existsUnique, find, findLast, foldLeft, get, hash, head, isEmpty, isSingleValued, iterator, last, lastOption, max, maxBy, maxBy, min, minBy, minBy, mkString, mkString, mkString, narrow, nonEmpty, product, reduceLeft, reduceLeftOption, reduceRight, reduceRightOption, size, sum
fold, reduce, reduceOption
contains, corresponds, eq, equals, exists, forAll, forEach, getOption, getOrElse, getOrElse, getOrElseThrow, getOrElseTry, hashCode, narrow, out, out, stderr, stdout, toArray, toCharSeq, toJavaArray, toJavaArray, toJavaCollection, toJavaList, toJavaList, toJavaMap, toJavaMap, toJavaOptional, toJavaSet, toJavaSet, toJavaStream, toLeft, toLeft, toList, toMap, toOption, toQueue, toRight, toRight, toSet, toStack, toStream, toString, toTree, toTry, toTry, toVector
andThen, arity, compose, curried, identity, lift, memoized, reversed, tupled
isMemoized
static final long serialVersionUID
static <T> Collector<T,ArrayList<T>,Stream<T>> collector()
Collector
which may be used in conjunction with
Stream.collect(java.util.stream.Collector)
to obtain a Stream
.T
- Component type of the Stream.static Stream<Integer> from(int value)
int
values starting from from
.
The Stream
extends to Integer.MIN_VALUE
when passing Integer.MAX_VALUE
.
value
- a start int valuefrom
static Stream<Integer> from(int value, int step)
int
values starting from value
and spaced by step
.
The Stream
extends to Integer.MIN_VALUE
when passing Integer.MAX_VALUE
.
value
- a start int valuestep
- the step by which to advance on each next valueStream
of int values starting from from
static Stream<Long> from(long value)
long
values starting from from
.
The Stream
extends to Integer.MIN_VALUE
when passing Long.MAX_VALUE
.
value
- a start long valuefrom
static Stream<Long> from(long value, long step)
long
values starting from value
and spaced by step
.
The Stream
extends to Long.MIN_VALUE
when passing Long.MAX_VALUE
.
value
- a start long valuestep
- the step by which to advance on each next valueStream
of long values starting from from
static <T> Stream<T> continually(Supplier<? extends T> supplier)
T
- value typesupplier
- A Supplier of Stream valuesstatic <T> Stream<T> iterate(T seed, Function<? super T,? extends T> f)
T
- value typeseed
- The first value in the Streamf
- A function to calculate the next value based on the previousstatic <T> Stream<T> cons(T head, Supplier<? extends Stream<? 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> Stream<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 Stream.Empty.instance().
T
- Component type of Nil, determined by type inference in the particular context.static <T> Stream<T> narrow(Stream<? extends T> stream)
Stream<? extends T>
to Stream<T>
by performing a type safe-cast. This is eligible because immutable/read-only
collections are covariant.T
- Component type of the Stream
.stream
- A Stream
.stream
instance as narrowed type Stream<T>
.static <T> Stream<T> of(T element)
Stream
, i.e. a Stream
of one element.@SafeVarargs static <T> Stream<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()))))
T
- Component type of the Stream.elements
- Zero or more elements.static <T> Stream<T> tabulate(int n, Function<? super Integer,? extends T> f)
n
values of a given Function f
over a range of integer values from 0 to n - 1
.T
- Component type of the Streamn
- The number of elements in the Streamf
- The Function computing element valuesf(0),f(1), ..., f(n - 1)
NullPointerException
- if f
is nullstatic <T> Stream<T> fill(int n, Supplier<? extends T> s)
n
values supplied by a given Supplier s
.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
.NullPointerException
- if s
is nullstatic <T> Stream<T> ofAll(Iterable<? extends T> elements)
T
- Component type of the Stream.elements
- An Iterable of elements.static Stream<Boolean> ofAll(boolean[] array)
array
- a boolean arraystatic Stream<Byte> ofAll(byte[] array)
array
- a byte arraystatic Stream<Character> ofAll(char[] array)
array
- a char arraystatic Stream<Double> ofAll(double[] array)
array
- a double arraystatic Stream<Float> ofAll(float[] array)
array
- a float arraystatic Stream<Integer> ofAll(int[] array)
array
- an int arraystatic Stream<Long> ofAll(long[] array)
array
- a long arraystatic Stream<Short> ofAll(short[] array)
array
- a short arraystatic Stream<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)
from
- the first numbertoExclusive
- the last number + 1Nil
if from >= toExclusive
static Stream<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()
from
- the first numbertoExclusive
- the last number + 1step
- the stepNil
iffrom >= toInclusive
and step > 0
orfrom <= toInclusive
and step < 0
IllegalArgumentException
- if step
is zerostatic Stream<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)
from
- the first numbertoExclusive
- the last number + 1Nil
if from >= toExclusive
static Stream<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()
from
- the first numbertoExclusive
- the last number + 1step
- the stepNil
iffrom >= toInclusive
and step > 0
orfrom <= toInclusive
and step < 0
IllegalArgumentException
- if step
is zerostatic Stream<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)
from
- the first numbertoInclusive
- the last numberNil
if from > toInclusive
static Stream<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()
from
- the first numbertoInclusive
- the last numberstep
- the stepNil
iffrom > toInclusive
and step > 0
orfrom < toInclusive
and step < 0
IllegalArgumentException
- if step
is zerostatic Stream<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)
from
- the first numbertoInclusive
- the last numberNil
if from > toInclusive
static Stream<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()
from
- the first numbertoInclusive
- the last numberstep
- the stepNil
iffrom > toInclusive
and step > 0
orfrom < toInclusive
and step < 0
IllegalArgumentException
- if step
is zerostatic <T> Stream<T> continually(T t)
T
- Element typet
- An elementt
's.default Stream<T> append(T element)
Seq
default Stream<T> appendAll(Iterable<? extends T> elements)
Seq
default Stream<T> appendSelf(Function<? super Stream<T>,? extends 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));
mapper
- an mapperdefault Stream<Stream<T>> combinations()
Seq
Examples:
[].combinations() = [[]]
[1,2,3].combinations() = [
[], // k = 0
[1], [2], [3], // k = 1
[1,2], [1,3], [2,3], // k = 2
[1,2,3] // k = 3
]
combinations
in interface LinearSeq<T>
combinations
in interface Seq<T>
default Stream<Stream<T>> combinations(int k)
Seq
combinations
in interface LinearSeq<T>
combinations
in interface Seq<T>
k
- Size of subsetsdefault Iterator<Stream<T>> crossProduct(int power)
Seq
Example:
// = ((A,A), (A,B), (A,C), ..., (B,A), (B,B), ..., (Z,Y), (Z,Z))
CharSeq.rangeClosed('A', 'Z').crossProduct(2);
crossProduct
in interface LinearSeq<T>
crossProduct
in interface Seq<T>
power
- the number of cartesian multiplicationsdefault Stream<T> cycle()
Example:
// = 1, 2, 3, 1, 2, 3, 1, 2, 3, ...
Stream.of(1, 2, 3).cycle();
default Stream<T> cycle(int count)
count
times.
Example:
// = empty
Stream.of(1, 2, 3).cycle(0);
// = 1, 2, 3
Stream.of(1, 2, 3).cycle(1);
// = 1, 2, 3, 1, 2, 3, 1, 2, 3
Stream.of(1, 2, 3).cycle(3);
count
- the number of cycles to be performedcount
times.default Stream<T> distinct()
Traversable
equals
.default Stream<T> distinctBy(Comparator<? super T> comparator)
Traversable
comparator
.distinctBy
in interface LinearSeq<T>
distinctBy
in interface Seq<T>
distinctBy
in interface Traversable<T>
comparator
- A comparatorTraversable
containing this elements without duplicatesdefault <U> Stream<T> distinctBy(Function<? super T,? extends U> keyExtractor)
Traversable
equals
.
The elements of the result are determined in the order of their occurrence - first match wins.
distinctBy
in interface LinearSeq<T>
distinctBy
in interface Seq<T>
distinctBy
in interface Traversable<T>
U
- key typekeyExtractor
- A key extractorTraversable
containing this elements without duplicatesdefault Stream<T> drop(long n)
Traversable
drop
in interface LinearSeq<T>
drop
in interface Seq<T>
drop
in interface Traversable<T>
n
- The number of elements to drop.default Stream<T> dropRight(long n)
Traversable
dropRight
in interface LinearSeq<T>
dropRight
in interface Seq<T>
dropRight
in interface Traversable<T>
n
- The number of elements to drop.default Stream<T> dropUntil(Predicate<? super T> predicate)
Traversable
Note: This is essentially the same as dropWhile(predicate.negate())
. It is intended to be used with
method references, which cannot be negated directly.
dropUntil
in interface LinearSeq<T>
dropUntil
in interface Seq<T>
dropUntil
in interface Traversable<T>
predicate
- A condition tested subsequently for this elements.default Stream<T> dropWhile(Predicate<? super T> predicate)
Traversable
dropWhile
in interface LinearSeq<T>
dropWhile
in interface Seq<T>
dropWhile
in interface Traversable<T>
predicate
- A condition tested subsequently for this elements starting with the first.default Stream<T> filter(Predicate<? super T> predicate)
Traversable
default <U> Stream<U> flatMap(Function<? super T,? extends Iterable<? extends U>> mapper)
Traversable
default T get(int index)
Seq
default <C> Map<C,Stream<T>> groupBy(Function<? super T,? extends C> classifier)
Traversable
groupBy
in interface LinearSeq<T>
groupBy
in interface Seq<T>
groupBy
in interface Traversable<T>
C
- classified class typeclassifier
- A function which classifies elements into classesdefault Iterator<Stream<T>> grouped(long size)
Traversable
Traversable
into fixed size blocks.
Let length be the length of this Iterable. Then grouped is defined as follows:
this.isEmpty()
, the resulting Iterator
is empty.size <= length
, the resulting Iterator
will contain length / size
blocks of size
size
and maybe a non-empty block of size length % size
, if there are remaining elements.size > length
, the resulting Iterator
will contain one block of size length
.
[].grouped(1) = []
[].grouped(0) throws
[].grouped(-1) throws
[1,2,3,4].grouped(2) = [[1,2],[3,4]]
[1,2,3,4,5].grouped(2) = [[1,2],[3,4],[5]]
[1,2,3,4].grouped(5) = [[1,2,3,4]]
Please note that grouped(int)
is a special case of Traversable.sliding(long, long), i.e.
grouped(size)
is the same as sliding(size, size)
.default boolean hasDefiniteSize()
Traversable
This method should be implemented by classes only, i.e. not by interfaces.
hasDefiniteSize
in interface Traversable<T>
default Option<T> headOption()
Traversable
Option
.headOption
in interface Traversable<T>
Some(element)
or None
if this is empty.default int indexOf(T element, int from)
Seq
default Stream<T> init()
Traversable
default Option<Stream<T>> initOption()
Traversable
Option
.initOption
in interface LinearSeq<T>
initOption
in interface Seq<T>
initOption
in interface Traversable<T>
Some(traversable)
or None
if this is empty.default Stream<T> insert(int index, T element)
Seq
default Stream<T> insertAll(int index, Iterable<? extends T> elements)
Seq
default Stream<T> intersperse(T element)
Seq
intersperse
in interface LinearSeq<T>
intersperse
in interface Seq<T>
element
- An element.default boolean isTraversableAgain()
Traversable
This method should be implemented by classes only, i.e. not by interfaces.
isTraversableAgain
in interface Traversable<T>
default int lastIndexOf(T element, int end)
Seq
lastIndexOf
in interface Seq<T>
element
- an elementend
- the end indexdefault int length()
Traversable
Same as Traversable.size()
.
length
in interface Traversable<T>
default <U> Stream<U> map(Function<? super T,? extends U> mapper)
Traversable
Traversable
to elements of a new type preserving their order, if any.default Stream<T> padTo(int length, T element)
Seq
padTo
in interface LinearSeq<T>
padTo
in interface Seq<T>
length
- the target lengthelement
- the padding elementelement
so that the resulting sequence has a length of at least length
.default Stream<T> patch(int from, Iterable<? extends T> that, int replaced)
Seq
default Tuple2<Stream<T>,Stream<T>> partition(Predicate<? super T> predicate)
Traversable
Traversable
by splitting this elements in two in distinct tarversables
according to a predicate.partition
in interface LinearSeq<T>
partition
in interface Seq<T>
partition
in interface Traversable<T>
predicate
- A predicate which classifies an element if it is in the first or the second traversable.Traversable
contains all elements that satisfy the given predicate
, the second Traversable
contains all elements that don't. The original order of elements is preserved.default Stream<T> peek(Consumer<? super T> action)
Value
action
on the first element if this is an eager implementation.
Performs the given action
on all elements (the first immediately, successive deferred),
if this is a lazy implementation.default Stream<Stream<T>> permutations()
Seq
Example:
[].permutations() = []
[1,2,3].permutations() = [
[1,2,3],
[1,3,2],
[2,1,3],
[2,3,1],
[3,1,2],
[3,2,1]
]
permutations
in interface LinearSeq<T>
permutations
in interface Seq<T>
default Stream<T> prepend(T element)
Seq
default Stream<T> prependAll(Iterable<? extends T> elements)
Seq
prependAll
in interface LinearSeq<T>
prependAll
in interface Seq<T>
elements
- An Iterable of elementsdefault Stream<T> remove(T element)
Seq
default Stream<T> removeFirst(Predicate<T> predicate)
Seq
removeFirst
in interface LinearSeq<T>
removeFirst
in interface Seq<T>
predicate
- an predicatedefault Stream<T> removeLast(Predicate<T> predicate)
Seq
removeLast
in interface LinearSeq<T>
removeLast
in interface Seq<T>
predicate
- an predicatedefault Stream<T> removeAt(int index)
Seq
default Stream<T> removeAll(T removed)
Seq
default Stream<T> removeAll(Iterable<? extends T> elements)
Seq
default Stream<T> replace(T currentElement, T newElement)
Traversable
replace
in interface LinearSeq<T>
replace
in interface Seq<T>
replace
in interface Traversable<T>
currentElement
- An element to be substituted.newElement
- A replacement for currentElement.default Stream<T> replaceAll(T currentElement, T newElement)
Traversable
replaceAll
in interface LinearSeq<T>
replaceAll
in interface Seq<T>
replaceAll
in interface Traversable<T>
currentElement
- An element to be substituted.newElement
- A replacement for currentElement.default Stream<T> retainAll(Iterable<? extends T> elements)
Traversable
default Stream<T> reverse()
Seq
default Stream<T> scan(T zero, BiFunction<? super T,? super T,? extends T> operation)
Traversable
scan
in interface LinearSeq<T>
scan
in interface Seq<T>
scan
in interface Traversable<T>
zero
- neutral element for the operator opoperation
- the associative operator for the scandefault <U> Stream<U> scanLeft(U zero, BiFunction<? super U,? super T,? extends U> operation)
Traversable
scanLeft
in interface LinearSeq<T>
scanLeft
in interface Seq<T>
scanLeft
in interface Traversable<T>
U
- the type of the elements in the resulting collectionzero
- the initial valueoperation
- the binary operator applied to the intermediate result and the elementdefault <U> Stream<U> scanRight(U zero, BiFunction<? super T,? super U,? extends U> operation)
Traversable
scanRight
in interface LinearSeq<T>
scanRight
in interface Seq<T>
scanRight
in interface Traversable<T>
U
- the type of the elements in the resulting collectionzero
- the initial valueoperation
- the binary operator applied to the intermediate result and the elementdefault Stream<T> slice(long beginIndex, long endIndex)
Seq
beginIndex
and extends to the element at index endIndex - 1
.
Examples:
List.of(1, 2, 3, 4).slice(1, 3); // = (2, 3)
List.of(1, 2, 3, 4).slice(0, 4); // = (1, 2, 3, 4)
List.of(1, 2, 3, 4).slice(2, 2); // = ()
List.of(1, 2).slice(1, 0); // = ()
List.of(1, 2).slice(-10, 10); // = (1, 2)
See also Seq.subSequence(int, int)
which throws in some cases instead of returning a sequence.default Iterator<Stream<T>> sliding(long size)
Traversable
size
and step size 1 over this Traversable
by calling
Traversable.sliding(long, long)
.default Iterator<Stream<T>> sliding(long size, long step)
Traversable
size
and step
size over this Traversable
.
Examples:
[].sliding(1,1) = []
[1,2,3,4,5].sliding(2,3) = [[1,2],[4,5]]
[1,2,3,4,5].sliding(2,4) = [[1,2],[5]]
[1,2,3,4,5].sliding(2,5) = [[1,2]]
[1,2,3,4].sliding(5,3) = [[1,2,3,4],[4]]
default Stream<T> sorted()
Seq
Comparable
, a java.lang.ClassCastException
may be thrown.default Stream<T> sorted(Comparator<? super T> comparator)
Seq
Comparator
. If this elements are not
Comparable
, a java.lang.ClassCastException
may be thrown.default <U extends Comparable<? super U>> Stream<T> sortBy(Function<? super T,? extends U> mapper)
Seq
mapper
.default <U> Stream<T> sortBy(Comparator<? super U> comparator, Function<? super T,? extends U> mapper)
Seq
mapper
.default Tuple2<Stream<T>,Stream<T>> span(Predicate<? super T> predicate)
Traversable
predicate
and the second element is the remainder.default Tuple2<Stream<T>,Stream<T>> splitAt(long n)
Seq
splitAt(n)
is equivalent to
Tuple.of(take(n), drop(n))
.default Tuple2<Stream<T>,Stream<T>> splitAt(Predicate<? super T> predicate)
Seq
Predicate
, e.g. Tuple(init, element+tail).default Tuple2<Stream<T>,Stream<T>> splitAtInclusive(Predicate<? super T> predicate)
Seq
Predicate
, e.g. Tuple(init+element, tail).splitAtInclusive
in interface Seq<T>
predicate
- An predicateTuple
containing divided sequencesdefault Spliterator<T> spliterator()
spliterator
in interface Iterable<T>
default String stringPrefix()
Value
stringPrefix
in interface Value<T>
default Stream<T> subSequence(int beginIndex)
Seq
beginIndex
and extends to the end of this Seq.
Examples:
List.of(1, 2).subSequence(0); // = (1, 2)
List.of(1, 2).subSequence(1); // = (2)
List.of(1, 2).subSequence(2); // = ()
List.of(1, 2).subSequence(10); // throws IndexOutOfBoundsException
List.of(1, 2).subSequence(-10); // throws IndexOutOfBoundsException
See also Seq.drop(long)
which is similar but does not throw.subSequence
in interface LinearSeq<T>
subSequence
in interface Seq<T>
beginIndex
- the beginning index, inclusivedefault Stream<T> subSequence(int beginIndex, int endIndex)
Seq
beginIndex
and extends to the element at index endIndex - 1
.
Examples:
List.of(1, 2, 3, 4).subSequence(1, 3); // = (2, 3)
List.of(1, 2, 3, 4).subSequence(0, 4); // = (1, 2, 3, 4)
List.of(1, 2, 3, 4).subSequence(2, 2); // = ()
List.of(1, 2).subSequence(1, 0); // throws IndexOutOfBoundsException
List.of(1, 2).subSequence(-10, 1); // throws IndexOutOfBoundsException
List.of(1, 2).subSequence(0, 10); // throws IndexOutOfBoundsException
See also Seq.slice(long, long)
which returns an empty sequence instead of throwing.subSequence
in interface LinearSeq<T>
subSequence
in interface Seq<T>
beginIndex
- the beginning index, inclusiveendIndex
- the end index, exclusiveStream<T> tail()
Traversable
default Option<Stream<T>> tailOption()
Traversable
Option
.tailOption
in interface LinearSeq<T>
tailOption
in interface Seq<T>
tailOption
in interface Traversable<T>
Some(traversable)
or None
if this is empty.default Stream<T> take(long n)
Traversable
The result is equivalent to sublist(0, max(0, min(length(), n)))
but does not throw if n < 0
or
n > length()
.
In the case of n < 0
the empty instance is returned, in the case of n > length()
this is returned.
default Stream<T> takeRight(long n)
Traversable
The result is equivalent to sublist(max(0, min(length(), length() - n)), n)
, i.e. takeRight will not
throw if n < 0
or n > length()
.
In the case of n < 0
the empty instance is returned, in the case of n > length()
this is returned.
takeRight
in interface LinearSeq<T>
takeRight
in interface Seq<T>
takeRight
in interface Traversable<T>
n
- The number of elements to take.default Stream<T> takeUntil(Predicate<? super T> predicate)
Traversable
Note: This is essentially the same as takeWhile(predicate.negate())
. It is intended to be used with
method references, which cannot be negated directly.
takeUntil
in interface LinearSeq<T>
takeUntil
in interface Seq<T>
takeUntil
in interface Traversable<T>
predicate
- A condition tested subsequently for this elements.default Stream<T> takeWhile(Predicate<? super T> predicate)
Traversable
takeWhile
in interface LinearSeq<T>
takeWhile
in interface Seq<T>
takeWhile
in interface Traversable<T>
predicate
- A condition tested subsequently for the contained elements.default <U> U transform(Function<? super Stream<T>,? extends U> f)
Stream
.U
- Type of transformation resultf
- A transformationU
NullPointerException
- if f
is nulldefault <T1,T2> Tuple2<Stream<T1>,Stream<T2>> unzip(Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
Traversable
unzip
in interface LinearSeq<T>
unzip
in interface Seq<T>
unzip
in interface Traversable<T>
T1
- 1st element type of a pair returned by unzipperT2
- 2nd element type of a pair returned by unzipperunzipper
- a function which converts elements of this to pairsdefault <T1,T2,T3> Tuple3<Stream<T1>,Stream<T2>,Stream<T3>> unzip3(Function<? super T,Tuple3<? extends T1,? extends T2,? extends T3>> unzipper)
Traversable
unzip3
in interface Seq<T>
unzip3
in interface Traversable<T>
T1
- 1st element type of a triplet returned by unzipperT2
- 2nd element type of a triplet returned by unzipperT3
- 3rd element type of a triplet returned by unzipperunzipper
- a function which converts elements of this to pairsdefault Stream<T> update(int index, T element)
Seq
default <U> Stream<Tuple2<T,U>> zip(Iterable<U> iterable)
Traversable
The length of the returned traversable is the minimum of the lengths of this traversable and that
iterable.
zip
in interface LinearSeq<T>
zip
in interface Seq<T>
zip
in interface Traversable<T>
U
- The type of the second half of the returned pairs.iterable
- The Iterable providing the second half of each result pair.that
iterable.default <U> Stream<Tuple2<T,U>> zipAll(Iterable<U> iterable, T thisElem, U thatElem)
Traversable
The length of the returned traversable is the maximum of the lengths of this traversable and that
iterable.
Special case: if this traversable is shorter than that elements, and that elements contains duplicates, the resulting traversable may be shorter than the maximum of the lengths of this and that because a traversable contains an element at most once.
If this Traversable is shorter than that, thisElem values are used to fill the result. If that is shorter than this Traversable, thatElem values are used to fill the result.
zipAll
in interface LinearSeq<T>
zipAll
in interface Seq<T>
zipAll
in interface Traversable<T>
U
- The type of the second half of the returned pairs.iterable
- The Iterable providing the second half of each result pair.thisElem
- The element to be used to fill up the result if this traversable is shorter than that.thatElem
- The element to be used to fill up the result if that is shorter than this traversable.default Stream<Tuple2<T,Long>> zipWithIndex()
Traversable
zipWithIndex
in interface LinearSeq<T>
zipWithIndex
in interface Seq<T>
zipWithIndex
in interface Traversable<T>
default Stream<T> extend(T next)
Stream
with a constantly repeated value.next
- value with which the stream should be extendedStream
composed from this stream extended with a Stream of provided valuedefault Stream<T> extend(Supplier<? extends T> nextSupplier)
Stream
with values provided by a Supplier
nextSupplier
- a supplier which will provide values for extending a streamStream
composed from this stream extended with values provided by the supplierdefault Stream<T> extend(Function<? super T,? extends T> nextFunction)
Stream
with a Stream of values created by applying
consecutively provided Function
to the last element of the original Stream.nextFunction
- a function which calculates the next value basing on the previous valueStream
composed from this stream extended with values calculated by the provided functionCopyright © 2016. All Rights Reserved.