BaseStream (abacus API Documentation)

Type Parameters:

T - the type of the stream elements

A - the type of array

P - the type of predicate

C - the type of consumer

PL - the type of PrimitiveList/List

OT - the type of Optional

IT - the type of Indexed

ITER - the type of Iterator

S - the type of of the stream implementing BaseStream

All Superinterfaces:

java.lang.AutoCloseable

All Known Implementing Classes:

ByteStream, CharStream, DoubleStream, DoubleStream.DoubleStreamEx, FloatStream, IntStream, IntStream.IntStreamEx, LongStream, LongStream.LongStreamEx, ShortStream, Stream, Stream.StreamEx
```
public interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends BaseStream<T,A,P,C,PL,OT,IT,ITER,S>>
extends java.lang.AutoCloseable
```
The Stream will be automatically closed after execution(A terminal method is executed/triggered).

See Also:

Stream, IntStream, LongStream, DoubleStream

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static class BaseStream.Splitor

Nested Classes
Modifier and Type	Interface and Description
`static class`	`BaseStream.Splitor`

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`<R> R`	`__(Function<? super S,R> transfer)`
`S`	`append(S s)`
`S`	`appendIfEmpty(Supplier<S> suppliers)`
`S`	`carry(C action)` Same as `peek`
`void`	`close()`
`long`	`count()`
`S`	`difference(java.util.Collection<?> c)` This method only run sequentially, even in parallel stream.
`S`	`distinct()` Returns a stream consisting of the distinct elements of this stream.
`S`	`dropWhile(P predicate)` Remove the elements until the given predicate returns false.
`S`	`dropWhile(P predicate, C consumer)` Remove the elements until the given predicate returns false.
`S`	`filter(P predicate)` Returns a stream consisting of the elements of this stream that match the given predicate.
`OT`	`first()`
`Stream<IT>`	`indexed()` This method only run sequentially, even in parallel stream.
`S`	`intersection(java.util.Collection<?> c)` This method only run sequentially, even in parallel stream.
`boolean`	`isParallel()`
`ITER`	`iterator()` Returns an iterator for the elements of this stream.
`java.lang.String`	`join(java.lang.CharSequence delimiter)`
`java.lang.String`	`join(java.lang.CharSequence delimiter, java.lang.CharSequence prefix, java.lang.CharSequence suffix)`
`OT`	`last()`
`S`	`limit(long maxSize)`
`S`	`onClose(java.lang.Runnable closeHandler)`
`OT`	`onlyOne()`
`S`	`parallel()`
`S`	`parallel(BaseStream.Splitor splitor)`
`S`	`parallel(java.util.concurrent.Executor executor)`
`S`	`parallel(int maxThreadNum)`
`S`	`parallel(int maxThreadNum, BaseStream.Splitor splitor)` Returns an equivalent stream that is parallel.
`S`	`parallel(int maxThreadNum, java.util.concurrent.Executor executor)`
`S`	`peek(C action)`
`u.Optional<java.util.Map<com.landawn.abacus.util.Percentage,T>>`	`percentiles()` All elements will be loaded to memory and sorted if not yet.
`S`	`prepend(S stream)`
`void`	`println()`
`S`	`removeIf(P predicate)`
`S`	`removeIf(P predicate, C consumer)`
`S`	`reversed()` This method only run sequentially, even in parallel stream and all elements will be loaded to memory.
`S`	`reverseSorted()`
`S`	`rotated(int distance)` This method only run sequentially, even in parallel stream and all elements will be loaded to memory.
`S`	`sequential()`
`S`	`shuffled()` This method only run sequentially, even in parallel stream and all elements will be loaded to memory.
`S`	`shuffled(java.util.Random rnd)` This method only run sequentially, even in parallel stream and all elements will be loaded to memory.
`S`	`skip(long n)`
`S`	`skip(long n, C consumer)`
`S`	`slice(long from, long to)` Same as: `stream.skip(from).limit(to - from)`.
`Stream<S>`	`sliding(int windowSize)`
`Stream<S>`	`sliding(int windowSize, int increment)` `Stream.of(1, 2, 3, 4, 5, 6, 7, 8).sliding(3, 1).forEach(Stream::println)` output: [1, 2, 3] [2, 3, 4] [3, 4, 5] [4, 5, 6] [5, 6, 7] [6, 7, 8] ============================================================================ `Stream.of(1, 2, 3, 4, 5, 6, 7, 8).sliding(3, 3).forEach(Stream::println)` output: [1, 2, 3] [4, 5, 6] [7, 8] ============================================================================ `Stream.of(1, 2, 3, 4, 5, 6, 7, 5).sliding(3, 5).forEach(Stream::println)` output: [1, 2, 3] [6, 7, 8] This method only run sequentially, even in parallel stream.
`Stream<PL>`	`slidingToList(int windowSize)`
`Stream<PL>`	`slidingToList(int windowSize, int increment)`
`S`	`sorted()` Returns a stream consisting of the elements of this stream in sorted order.
`Stream<S>`	`split(int size)` Returns Stream of `S` with consecutive sub sequences of the elements, each of the same size (the final sequence may be smaller).
`Stream<S>`	`split(P predicate)` Split the stream by the specified predicate.
`Stream<S>`	`splitAt(int where)` Split the stream into two pieces at `where`.
`Stream<S>`	`splitBy(P where)` Split the stream into two pieces at `where` turns to `false` The first piece will be loaded into memory.
`Stream<PL>`	`splitToList(int size)` Returns Stream of `PL` with consecutive sub sequences of the elements, each of the same size (the final sequence may be smaller).
`Stream<PL>`	`splitToList(P predicate)` Split the stream by the specified predicate.
`S`	`step(long step)`
`S`	`symmetricDifference(java.util.Collection<T> c)` This method only run sequentially, even in parallel stream.
`S`	`takeWhile(P predicate)` Keep the elements until the given predicate returns false.
`A`	`toArray()`
`<CC extends java.util.Collection<T>> CC`	`toCollection(Supplier<? extends CC> supplier)`
`ImmutableList<T>`	`toImmutableList()`
`ImmutableSet<T>`	`toImmutableSet()`
`java.util.List<T>`	`toList()`
`LongMultiset<T>`	`toLongMultiset()`
`LongMultiset<T>`	`toLongMultiset(Supplier<? extends LongMultiset<T>> supplier)`
`Multiset<T>`	`toMultiset()`
`Multiset<T>`	`toMultiset(Supplier<? extends Multiset<T>> supplier)`
`java.util.Set<T>`	`toSet()`

Method Detail

filter
```
@ParallelSupported
S filter(P predicate)
```
Returns a stream consisting of the elements of this stream that match the given predicate.

Parameters:

predicate -

Returns:

takeWhile
```
@ParallelSupported
S takeWhile(P predicate)
```
Keep the elements until the given predicate returns false. The stream should be sorted, which means if x is the first element: predicate.text(x) returns false, any element y behind x: predicate.text(y) should returns false. In parallel Streams, the elements after the first element which predicate returns false may be tested by predicate too.

Parameters:

predicate -

Returns:

dropWhile
```
@ParallelSupported
S dropWhile(P predicate)
```
Remove the elements until the given predicate returns false. The stream should be sorted, which means if x is the first element: predicate.text(x) returns true, any element y behind x: predicate.text(y) should returns true. In parallel Streams, the elements after the first element which predicate returns false may be tested by predicate too.

Parameters:

predicate -

Returns:

dropWhile
```
@ParallelSupported
S dropWhile(P predicate,
                                C consumer)
```
Remove the elements until the given predicate returns false. The stream should be sorted, which means if x is the first element: predicate.text(x) returns true, any element y behind x: predicate.text(y) should returns true. In parallel Streams, the elements after the first element which predicate returns false may be tested by predicate too.

Parameters:

predicate -

consumer -

Returns:

removeIf

@ParallelSupported
S removeIf(P predicate)

removeIf

@ParallelSupported
S removeIf(P predicate,
                               C consumer)

split
```
@SequentialOnly
Stream<S> split(int size)
```
Returns Stream of S with consecutive sub sequences of the elements, each of the same size (the final sequence may be smaller).

Parameters:

size -

Returns:

splitToList
```
@SequentialOnly
Stream<PL> splitToList(int size)
```
Returns Stream of PL with consecutive sub sequences of the elements, each of the same size (the final sequence may be smaller).
This method only run sequentially, even in parallel stream.

Parameters:

size -

Returns:

split
```
@SequentialOnly
Stream<S> split(P predicate)
```
Split the stream by the specified predicate. This stream should be sorted by value which is used to verify the border.
This method only run sequentially, even in parallel stream.

Parameters:

predicate -

Returns:

splitToList
```
@SequentialOnly
Stream<PL> splitToList(P predicate)
```
Split the stream by the specified predicate. This method only run sequentially, even in parallel stream.

Parameters:

predicate -

Returns:

splitAt
```
@SequentialOnly
Stream<S> splitAt(int where)
```
Split the stream into two pieces at where. The first piece will be loaded into memory.

Parameters:

where -

Returns:

splitBy

@ParallelSupported
Stream<S> splitBy(P where)

Split the stream into two pieces at where turns to false The first piece will be loaded into memory.

 
 Stream.of(1, 3, 2, 4, 2, 5).splitBy(i -> i <= 3).forEach(s -> s.println()); // [1, 3, 2], [4, 2, 5]

Parameters:: where -
Returns:

sliding
```
@SequentialOnly
Stream<S> sliding(int windowSize)
```
Parameters:

windowSize -

Returns:

See Also:

sliding(int, int)

slidingToList
```
@SequentialOnly
Stream<PL> slidingToList(int windowSize)
```
Parameters:

windowSize -

Returns:

See Also:

sliding(int, int)

sliding
```
@SequentialOnly
Stream<S> sliding(int windowSize,
                                   int increment)
```
Stream.of(1, 2, 3, 4, 5, 6, 7, 8).sliding(3, 1).forEach(Stream::println)
output:
[1, 2, 3]
[2, 3, 4]
[3, 4, 5]
[4, 5, 6]
[5, 6, 7]
[6, 7, 8]

============================================================================
Stream.of(1, 2, 3, 4, 5, 6, 7, 8).sliding(3, 3).forEach(Stream::println)
output:
[1, 2, 3]
[4, 5, 6]
[7, 8]

============================================================================
Stream.of(1, 2, 3, 4, 5, 6, 7, 5).sliding(3, 5).forEach(Stream::println)
output:
[1, 2, 3]
[6, 7, 8]

This method only run sequentially, even in parallel stream.

Parameters:

windowSize -

increment -

Returns:

slidingToList

@SequentialOnly
Stream<PL> slidingToList(int windowSize,
                                          int increment)

Parameters:: windowSize -; increment -
Returns:
See Also:: sliding(int, int)

intersection
```
@SequentialOnly
S intersection(java.util.Collection<?> c)
```
This method only run sequentially, even in parallel stream.

Parameters:

c -

Returns:

See Also:

IntList.intersection(IntList)

difference
```
@SequentialOnly
S difference(java.util.Collection<?> c)
```
This method only run sequentially, even in parallel stream.

Parameters:

c -

Returns:

See Also:

IntList.difference(IntList)

symmetricDifference
```
@SequentialOnly
S symmetricDifference(java.util.Collection<T> c)
```
This method only run sequentially, even in parallel stream.

Parameters:

c -

Returns:

See Also:

IntList.symmetricDifference(IntList)

percentiles

@SequentialOnly
u.Optional<java.util.Map<com.landawn.abacus.util.Percentage,T>> percentiles()

All elements will be loaded to memory and sorted if not yet.

Returns:

reversed
```
@SequentialOnly
S reversed()
```
This method only run sequentially, even in parallel stream and all elements will be loaded to memory.

Returns:

shuffled
```
@SequentialOnly
S shuffled()
```
This method only run sequentially, even in parallel stream and all elements will be loaded to memory.

Returns:

shuffled
```
@SequentialOnly
S shuffled(java.util.Random rnd)
```
This method only run sequentially, even in parallel stream and all elements will be loaded to memory.

Returns:

rotated
```
@SequentialOnly
S rotated(int distance)
```
This method only run sequentially, even in parallel stream and all elements will be loaded to memory.

Returns:

distinct
```
@SequentialOnly
S distinct()
```
Returns a stream consisting of the distinct elements of this stream.

Returns:

sorted
```
@ParallelSupported
S sorted()
```
Returns a stream consisting of the elements of this stream in sorted order.
All elements will be loaded to memory.

Returns:

the new stream

reverseSorted
```
@ParallelSupported
S reverseSorted()
```

prepend
```
@SequentialOnly
S prepend(S stream)
```

append
```
@SequentialOnly
S append(S s)
```

appendIfEmpty

@SequentialOnly
S appendIfEmpty(Supplier<S> suppliers)

indexed
```
@SequentialOnly
Stream<IT> indexed()
```
This method only run sequentially, even in parallel stream.

Returns:

join

@SequentialOnly
java.lang.String join(java.lang.CharSequence delimiter)

join

@SequentialOnly
java.lang.String join(java.lang.CharSequence delimiter,
                                       java.lang.CharSequence prefix,
                                       java.lang.CharSequence suffix)

skip
```
@SequentialOnly
S skip(long n)
```
Parameters:

n -

Returns:

skip

@ParallelSupported
S skip(long n,
                           C consumer)

Parameters:: n -; consumer -
Returns:

limit
```
@SequentialOnly
S limit(long maxSize)
```
Parameters:

maxSize -

Returns:

slice
```
@SequentialOnly
S slice(long from,
                         long to)
```
Same as: stream.skip(from).limit(to - from).

Parameters:

from -

to -

Returns:

step
```
@SequentialOnly
S step(long step)
```

count
```
@SequentialOnly
long count()
```
Returns:

peek
```
@ParallelSupported
S peek(C action)
```
Parameters:

action -

Returns:

carry
```
@ParallelSupported
S carry(C action)
```
Same as peek

Parameters:

action -

Returns:

See Also:

peek(Object)

first
```
@SequentialOnly
OT first()
```

last
```
@SequentialOnly
OT last()
```

onlyOne
```
@SequentialOnly
OT onlyOne()
                     throws DuplicatedResultException
```
Returns:

Throws:

DuplicatedResultException - if there are more than one element in this stream.

toArray
```
@SequentialOnly
A toArray()
```
Returns:

toList

@SequentialOnly
java.util.List<T> toList()

toSet

@SequentialOnly
java.util.Set<T> toSet()

toImmutableList

@SequentialOnly
ImmutableList<T> toImmutableList()

toImmutableSet

@SequentialOnly
ImmutableSet<T> toImmutableSet()

toCollection

@SequentialOnly
<CC extends java.util.Collection<T>> CC toCollection(Supplier<? extends CC> supplier)

toMultiset

@SequentialOnly
Multiset<T> toMultiset()

toMultiset

@SequentialOnly
Multiset<T> toMultiset(Supplier<? extends Multiset<T>> supplier)

toLongMultiset

@SequentialOnly
LongMultiset<T> toLongMultiset()

toLongMultiset

@SequentialOnly
LongMultiset<T> toLongMultiset(Supplier<? extends LongMultiset<T>> supplier)

iterator
```
@SequentialOnly
ITER iterator()
```
Returns an iterator for the elements of this stream.
Remember to close this Stream after the iteration is done, if required.

Returns:

the element iterator for this stream

println
```
@Beta
 @SequentialOnly
void println()
```

__

@SequentialOnly
<R> R __(Function<? super S,R> transfer)

onClose

@SequentialOnly
S onClose(java.lang.Runnable closeHandler)

Parameters:: closeHandler -
Returns:

close
```
@SequentialOnly
void close()
```
Specified by:

close in interface java.lang.AutoCloseable

isParallel
```
boolean isParallel()
```
Returns:

sequential
```
S sequential()
```
Returns:

parallel
```
S parallel()
```
Returns:

parallel
```
S parallel(int maxThreadNum)
```
Parameters:

maxThreadNum -

Returns:

parallel

S parallel(BaseStream.Splitor splitor)

Parameters:: splitor -
Returns:

parallel

S parallel(int maxThreadNum,
           BaseStream.Splitor splitor)

Returns an equivalent stream that is parallel. May return itself if the stream was already parallel with the same maxThreadNum and splitor as the specified ones.

When to use parallel Streams?

First of all, do NOT and should NOT use parallel Streams if you don't have any problem with sequential Streams, because using parallel Streams has extra cost.
Consider using parallel Streams only when N(the number of elements) * Q(cost per element of F, the per-element function (usually a lambda)) is big enough(e.g. IO involved. Network: DB/web service request..., Reading/Writing file...).
It's easy to test out the differences of performance by sequential Streams and parallel Streams with Profiler:

 
 Profiler.run(1, 1, 3, "sequential", () -> Stream.of(list).operation(F)...).printResult();
 Profiler.run(1, 1, 3, "parallel", () -> Stream.of(list).parallel().operation(F)...).printResult();

Here is a sample performance test with computer: CPU Intel i7-3520M 4-cores 2.9 GHz, JDK 1.8.0_101, Windows 7:

 
 public void test_perf() {
     final String[] strs = new String[10_000];
     N.fill(strs, N.uuid());
 
     final int m = 1;
     final Function mapper = str -> {
         long result = 0;
         for (int i = 0; i < m; i++) {
             result += sum(str.toCharArray()) + 1;
         }
         return result;
     };
 
     final MutableLong sum = MutableLong.of(0);
 
     for (int i = 0, len = strs.length; i < len; i++) {
         sum.add(mapper.apply(strs[i]));
     }
 
     final int threadNum = 1, loopNum = 100, roundNum = 3;
 
     Profiler.run(threadNum, loopNum, roundNum, "For Loop", () -> {
         long result = 0;
         for (int i = 0, len = strs.length; i < len; i++) {
             result += mapper.apply(strs[i]);
         }
         assertEquals(sum.longValue(), result);
     }).printResult();
 
     Profiler.run(threadNum, loopNum, roundNum, "JDK Sequential",
             () -> assertEquals(sum.longValue(), java.util.stream.Stream.of(strs).map(mapper).mapToLong(e -> e).sum())).printResult();
 
     Profiler.run(threadNum, loopNum, roundNum, "JDK Parallel",
             () -> assertEquals(sum.longValue(), java.util.stream.Stream.of(strs).parallel().map(mapper).mapToLong(e -> e).sum())).printResult();
 
     Profiler.run(threadNum, loopNum, roundNum, "Abcus Sequential",
             () -> assertEquals(sum.longValue(), Stream.of(strs).map(mapper).mapToLong(e -> e).sum().longValue())).printResult();
 
     Profiler.run(threadNum, loopNum, roundNum, "Abcus Parallel",
             () -> assertEquals(sum.longValue(), Stream.of(strs).parallel().map(mapper).mapToLong(e -> e).sum().longValue())).printResult();
 }

And test result: Unit is milliseconds. N(the number of elements) is 10_000, Q(cost per element of F, the per-element function (usually a lambda), here is mapper) is calculated by: value of 'For loop' / N(10_000).

	m = 1	m = 10	m = 50	m = 100	m = 500	m = 1000
Q	0.00002	0.0002	0.001	0.002	0.01	0.02
For Loop	0.23	2.3	11	22	110	219
JDK Sequential	0.28	2.3	11	22	114	212
JDK Parallel	0.22	1.3	6	12	66	122
Abcus Sequential	0.3	2	11	22	112	212
Abcus Parallel	11	11	11	16	77	128

Comparison:

Again, do NOT and should NOT use parallel Streams if you don't have any performance problem with sequential Streams, because using parallel Streams has extra cost.
Again, consider using parallel Streams only when N(the number of elements) * Q(cost per element of F, the per-element function (usually a lambda)) is big enough.
The implementation of parallel Streams in Abacus is more than 10 times, slower than parallel Streams in JDK when Q is tiny(here is less than 0.0002 milliseconds by the test):

The implementation of parallel Streams in JDK 8 still can beat the sequential/for loop when Q is tiny(Here is 0.00002 milliseconds by the test). That's amazing, considering the extra cost brought by parallel computation. It's well done.
The implementation of parallel Streams in Abacus is pretty simple and straight forward. The extra cost(starting threads/synchronization/queue...) brought by parallel Streams in Abacus is too bigger to tiny Q(Here is less than 0.001 milliseconds by the test). But it starts to be faster than sequential Streams when Q is big enough(Here is 0.001 milliseconds by the test) and starts to catch the parallel Streams in JDK when Q is bigger(Here is 0.01 milliseconds by the test).
Consider using the parallel Streams in Abacus when Q is big enough, specially when IO involved in F. Because one IO operation(e.g. DB/web service request..., Reading/Writing file...) usually takes 1 to 1000 milliseconds, or even longer. By the parallel Streams APIs in Abacus, it's very simple to specify max thread numbers. Sometimes, it's much faster to execute IO/Network requests with a bit more threads. It's fair to say that the parallel Streams in Abacus is high efficient, may same as or faster than the parallel Streams in JDK when Q is big enough, except F is heavy cpu-used operation. Most of the times, the Q is big enough to consider using parallel Stream is because IO/Network is involved in F.

JDK 7 is supported by the Streams in Abacus. It's perfect to work with retrolambda on Android
All primitive types are supported by Stream APIs in Abacus except boolean

A bit more about Lambdas/Stream APIs, you may heard that Lambdas/Stream APIs is 5 time slower than imperative programming. It's true when Q and F is VERY, VERY tiny, like f = (int a, int b) -> a + b;. But if we look into the samples in the article and think about it: it just takes less than 1 milliseconds to get the max value in 100k numbers. There is potential performance issue only if the "get the max value in 100K numbers" call many, many times in your API or single request. Otherwise, the difference between 0.1 milliseconds to 0.5 milliseconds can be totally ignored. Usually we meet performance issue only if Q and F is big enough. However, the performance of Lambdas/Streams APIs is closed to for loop when Q and F is big enough. No matter in which scenario, We don't need and should not concern the performance of Lambdas/Stream APIs.

Although it's is parallel Streams, it doesn't means all the methods are executed in parallel. Because the sequential way is as fast, or even faster than the parallel way for some methods, or is pretty difficult, if not possible, to implement the method by parallel approach. Here are the methods which are executed sequentially even in parallel Streams.

splitXXX/splitAt/splitBy/slidingXXX/collapse, distinct, reverse, rotate, shuffle, indexed, cached, top, kthLargest, count, toArray, toList, toList, toSet, toMultiset, toLongMultiset, intersection(Collection c), difference(Collection c), symmetricDifference(Collection c), forEach(identity, accumulator, predicate), findFirstOrLast, findFirstAndLast

Parameters:

maxThreadNum - Default value is the number of cpu-cores. Steps/operations will be executed sequentially if maxThreadNum is 1.

splitor - The target array is split by ranges for multiple threads if splitor is splitor.ARRAY and target stream composed by array. It looks like:


 for (int i = 0; i < maxThreadNum; i++) {
     final int sliceIndex = i;
 
     futureList.add(asyncExecutor.execute(new Runnable() {
         public void run() {
             int cursor = fromIndex + sliceIndex * sliceSize;
             final int to = toIndex - cursor > sliceSize ? cursor + sliceSize : toIndex;
             while (cursor < to) {
                 action.accept(elements[cursor++]);
             }
        }
    }));
 }

Otherwise, each thread will get the elements from the target array/iterator in the stream one by one with the target array/iterator synchronized. It looks like:


 for (int i = 0; i < maxThreadNum; i++) {
     futureList.add(asyncExecutor.execute(new Runnable() {
         public void run() {
             T next = null;
 
             while (true) {
                 synchronized (elements) {
                     if (cursor.intValue() < toIndex) {
                         next = elements[cursor.getAndIncrement()];
                     } else {
                         break;
                     }
                 }
 
                 action.accept(next);
             }
         }
     }));
 }

Using splitor.ARRAY only when F (the per-element function (usually a lambda)) is very tiny and the cost of synchronization on the target array/iterator is too big to it. For the F involving IO or taking 'long' to complete, choose splitor.ITERATOR. Default value is splitor.ITERATOR.

Returns:

See Also:

Nth, com.landawn.abacus.util.Profiler#run(int, int, int, String, Runnable), Understanding Parallel Stream Performance in Java SE 8, When to use parallel Streams

parallel
```
S parallel(int maxThreadNum,
           java.util.concurrent.Executor executor)
```
Parameters:

maxThreadNum -

executor - should be able to execute sum of maxThreadNum operations in parallel.

Returns:

parallel
```
S parallel(java.util.concurrent.Executor executor)
```
Parameters:

executor - should be able to execute sum of maxThreadNum operations in parallel.

Returns:

Interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends BaseStream<T,A,P,C,PL,OT,IT,ITER,S>>

Nested Class Summary

Method Summary

Method Detail

filter

takeWhile

dropWhile

dropWhile

removeIf

removeIf

split

splitToList

split

splitToList

splitAt

splitBy

sliding

slidingToList

sliding

slidingToList

intersection

difference

symmetricDifference

percentiles

reversed

shuffled

shuffled

rotated

distinct

sorted

reverseSorted

prepend

append

appendIfEmpty

indexed

join

join

skip

skip

limit

slice

step

count

peek

carry

first

last

onlyOne

toArray

toList

toSet

toImmutableList

toImmutableSet

toCollection

toMultiset

toMultiset

toLongMultiset

toLongMultiset

iterator

println

__

onClose

close

isParallel

sequential

parallel

parallel

parallel

parallel

parallel

parallel