public class FutureStreamImpl<U> extends java.lang.Object implements FutureStream<U>
ReactiveSeq.Instances| Constructor and Description |
|---|
FutureStreamImpl(LazyReact lazyReact,
java.util.stream.Stream<U> stream) |
FutureStreamImpl(LazyReact lazyReact,
java.util.function.Supplier<java.util.stream.Stream<U>> stream) |
| Modifier and Type | Method and Description |
|---|---|
boolean |
allMatch(java.util.function.Predicate<? super U> c)
True if predicate matches all elements when Monad converted to a Stream
|
boolean |
anyMatch(java.util.function.Predicate<? super U> c)
True if a singleUnsafe element matches when Monad converted to a Stream
|
FutureStream<U> |
append(U value) |
void |
cancel()
Cancel the CompletableFutures in this stage of the reactiveStream
|
void |
close() |
<R,A> R |
collect(java.util.stream.Collector<? super U,A,R> collector)
Performs a mutable
reduction operation on the elements of this reactiveStream using a
Collector. |
org.jooq.lambda.Collectable<U> |
collectors()
Narrow this class to a Collectable
|
long |
count()
Returns the count of elements in this reactiveStream.
|
U |
foldRight(Monoid<U> reducer)
ReactiveSeq.of("a","b","c").foldRight(Reducers.toString(""));
// "cab"
|
U |
foldRight(U identity,
java.util.function.BinaryOperator<U> accumulator)
Immutable reduction from right to left
|
<T> T |
foldRightMapToType(Reducer<T> reducer)
Attempt to map this Monad to the same type as the supplied Monoid (using
mapToType on the monoid interface) Then use Monoid to reduce values
|
java.lang.String |
format() |
void |
forwardErrors(java.util.function.Consumer<java.lang.Throwable> c) |
LazyReact |
getPopulator() |
java.util.concurrent.Executor |
getTaskExecutor() |
HeadAndTail<U> |
headAndTail()
extract head and tail together, where head is expected to be present
Example :
|
HotStream<U> |
hotStream(java.util.concurrent.Executor e)
Turns this ReactiveSeq into a HotStream, a connectable Stream, being executed on a thread on the
supplied executor, that is producing data.
|
boolean |
isAsync() |
java.lang.String |
join()
assertEquals("123".length(),ReactiveSeq.of(1, 2, 3).join().length());
|
java.lang.String |
join(java.lang.String sep)
assertEquals("1, 2, 3".length(), ReactiveSeq.of(1, 2, 3).join(", ").length());
|
java.lang.String |
join(java.lang.String sep,
java.lang.String start,
java.lang.String end)
assertEquals("^1|2|3$".length(), of(1, 2, 3).join("|", "^", "$").length());
|
<R> R |
mapReduce(java.util.function.Function<? super U,? extends R> mapper,
Monoid<R> reducer)
Attempt to map this Monad to the same type as the supplied Monoid, using
supplied function Then use Monoid to reduce values
|
<R> R |
mapReduce(Reducer<R> reducer)
Attempt to map this Sequence to the same type as the supplied Monoid
(Reducer) Then use Monoid to reduce values
|
java.util.Optional<U> |
max(java.util.Comparator<? super U> comparator)
Get the maximum value by a function.
|
FutureStream<U> |
maxActive(int max)
Configure the max active concurrent tasks.
|
java.util.Optional<U> |
min(java.util.Comparator<? super U> comparator)
Get the minimum value by a function.
|
boolean |
noneMatch(java.util.function.Predicate<? super U> c) |
PausableHotStream<U> |
pausableHotStream(java.util.concurrent.Executor e)
Turns this ReactiveSeq into a HotStream, a connectable & pausable Stream, being executed on a thread on the
supplied executor, that is producing data.
|
FutureStream<U> |
prepend(U value) |
HotStream<U> |
primedHotStream(java.util.concurrent.Executor e)
Return a HotStream that will skip emitting data when the first connecting Stream connects.
|
PausableHotStream<U> |
primedPausableHotStream(java.util.concurrent.Executor e)
Return a pausable HotStream that will skip emitting data when the first connecting Stream connects.
|
ListX<U> |
reduce(java.lang.Iterable<? extends Monoid<U>> reducers)
Reduce with multiple reducers in parallel NB if this Monad is an Optional
[Arrays.asList(1,2,3)] reduce will operate on the Optional as if the list
was one value To reduce over the values on the list, called
streamedMonad() first.
|
U |
reduce(Monoid<U> reducer)
ReactiveSeq.of("hello","2","world","4").reduce(Reducers.toString(","));
//hello,2,world,4
|
ListX<U> |
reduce(java.util.stream.Stream<? extends Monoid<U>> reducers)
Reduce with multiple reducers in parallel NB if this Monad is an Optional
[Arrays.asList(1,2,3)] reduce will operate on the Optional as if the list
was one value To reduce over the values on the list, called
streamedMonad() first.
|
void |
returnPopulator(LazyReact service) |
HotStream<U> |
schedule(java.lang.String cron,
java.util.concurrent.ScheduledExecutorService ex)
Execute this Stream on a schedule
|
HotStream<U> |
scheduleFixedDelay(long delay,
java.util.concurrent.ScheduledExecutorService ex)
Execute this Stream on a schedule
|
HotStream<U> |
scheduleFixedRate(long rate,
java.util.concurrent.ScheduledExecutorService ex)
Execute this Stream on a schedule
|
<T> FutureStream<T> |
unit(T unit) |
<T> FutureStream<T> |
unitIterator(java.util.Iterator<T> it)
Create an IterableFunctor instance of the same type from an Iterator
|
<R> R |
visit(java.util.function.Function<? super ReactiveSeq<U>,? extends R> sync,
java.util.function.Function<? super ReactiveSeq<U>,? extends R> reactiveStreams,
java.util.function.Function<? super ReactiveSeq<U>,? extends R> asyncNoBackPressure) |
FutureStream<U> |
withAsync(boolean b) |
<U> FutureStream<U> |
withLastActive(LazyStreamWrapper<U> w) |
FutureStream<U> |
withTaskExecutor(java.util.concurrent.Executor e) |
boolean |
xMatch(int num,
java.util.function.Predicate<? super U> c)
Check that there are specified number of matches of predicate in the
Stream
|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, waitactOnFutures, anyM, append, append, appendS, async, boundedWaitFree, builder, builder, capture, cast, changes, chunkLastReadIterator, chunkSinceLastRead, closeAll, coflatMap, collect, collectSeq, collectStream, combinations, combinations, combine, combine, complete, concat, concat, concat, control, convertToSimpleReact, copy, crossApply, crossJoin, cycle, cycle, cycle, cycleUntil, cycleWhile, debounce, deleteBetween, distinct, distinct, drop, dropRight, dropUntil, dropWhile, duplicate, duplicate, duplicateFutureStream, elapsed, endsWith, endsWithIterable, fanOut, fanOut, fanOut, fanOutZipIn, fanOutZipIn, fanOutZipIn, filter, filterNot, findAny, findFirst, findFirstOrError, findOne, firstValue, fixedDelay, flatMap, flatMapAnyM, flatMapCompletableFuture, flatMapI, flatMapP, flatMapP, flatMapStream, flatMapToDouble, flatMapToInt, flatMapToLong, flatten, fold, foldFuture, foldRight, forEach, forEach, forEach, forEach, forEach, forEach, forEach2, forEach2, forEach3, forEach3, forEach4, forEach4, forEachAsync, forEachOrdered, fromStream, fromStreamOfFutures, futureOperations, getSimpleReact, getSubscription, group, grouped, grouped, groupedBySizeAndTime, groupedBySizeAndTime, groupedBySizeAndTime, groupedByTime, groupedByTime, groupedByTime, groupedStatefullyUntil, groupedStatefullyUntil, groupedStatefullyWhile, groupedStatefullyWhile, groupedUntil, groupedUntil, groupedWhile, groupedWhile, hotStream, innerJoin, insertAt, insertAtS, intersperse, isParallel, iterator, jitter, jool, leftOuterJoin, limit, limit, limitLast, limitUntil, limitUntilClosed, limitWhile, limitWhileClosed, map, mapToDouble, mapToInt, mapToLong, merge, mergeLatest, mergeP, mergeP, multicast, narrow, notNull, ofType, onClose, onEmpty, onEmptyGet, onEmptySwitch, onEmptyThrow, onePer, onFail, onFail, outerApply, parallel, parallel, parallel, parallelFanOut, parallelFanOut, parallelFanOut, parallelFanOutZipIn, parallelFanOutZipIn, parallelFanOutZipIn, partition, partitionFutureStream, peek, peekSync, permutations, prepend, prepend, prependS, quadruplicate, quadruplicate, recover, recover, reduce, reduce, reduce, reduce, reduceAll, remove, removeAll, removeAllI, removeAllS, retainAll, retainAllI, retainAllS, retry, retry, reverse, rightOuterJoin, scanLeft, scanLeft, scanRight, scanRight, self, sequential, shard, shuffle, shuffle, skip, skip, skipLast, skipUntil, skipUntilClosed, skipWhile, skipWhileClosed, slice, sliding, sliding, sorted, sorted, sorted, sorted, splitAt, splitAtHead, splitBy, spliterator, startsWith, startsWithIterable, stream, subscribe, subStream, switchOnNextValue, sync, take, takeRight, takeUntil, takeWhile, then, then, thenSync, timestamp, toArray, toArray, toCompletableFuture, toList, toQueue, toSet, trampoline, triplicate, triplicate, unboundedWaitFree, unordered, withLazyCollector, withQueueFactory, withSubscription, xPer, zip, zip, zip, zip3, zip3, zip4, zip4, zipLatest, zipP, zipP, zipS, zipS, zipWith, zipWithIndex, zipWithP, zipWithSassureSimpleReactException, copySimpleReactStream, filterSync, flatMapToCompletableFuture, flatMapToCompletableFutureSync, getLastActive, handleExceptions, streamCompletableFutures, withErrorHandlergetErrorHandlerempty, freeThread, freeThread, getQueueFactory, of, of, parallel, react, react, simpleReactStream, simpleReactStream, simpleReactStream, simpleReactStream, simpleReactStreamFrom, simpleReactStreamFromIterableblock, block, getErrorHandlergetErrorHandler, getLastActive, getLazyCollector, getMaxActive, run, run, runContinuation, runOnCurrent, runThreadallTypeclasses, allTypeclasses, ambWith, ambWith, backpressureAware, broadcast, collectAll, combinationsT, combinationsT, concat, concat, concat, concat, concatDoubles, concatInts, concatLongs, coproduct, deferred, deferredI, deferredP, doubles, elementAt, empty, enqueued, enqueued, enqueued, enqueuedAll, enums, enums, enums, enumsFromTo, fill, filterInts, filterLongs, filterLongs, flatMapDoubles, flatMapInts, flatMapLongs, flatten, flattenI, flattenO, foldJool, foldParallel, foldParallel, fromCharSequence, fromDoubleStream, fromIntStream, fromIterable, fromIterator, fromList, fromLongStream, fromPublisher, fromSpliterator, fromStream, generate, generate, get, groupBy, grouped, grouped, ints, isEmpty, isReplayable, iterate, iterate, kindCokleisli, kindKleisli, liftM, limitDouble, limitInts, limitLongs, longs, mapDoubles, mapInts, mapLongs, mapM, narrowK, nested, of, of, ofDoubles, ofInts, ofLongs, ofNullable, oneShotList, oneShotStream, permutationsT, print, print, printErr, printOut, product, product, publishTo, publishTo, range, range, rangeLong, rangeLong, reactiveSeq, reversedListOf, reversedOf, seq, single, single, singleUnsafe, size, skipDoubles, skipInts, skipLongs, tailRec, takeOne, unfold, unzip, unzip3, unzip4, widenasFunction, foldFuture, foldLazy, foldTry, forEachSubscribe, forEachSubscribe, forEachSubscribe, runFuture, runLazy, toListX, toSetX, visitcommonPrefix, commonSuffix, count, countDistinct, countDistinct, countDistinctBy, countDistinctBy, maxBy, minBy, mode, sum, sumDouble, sumInt, sumLong, to, toMap, toMap, toString, toStringfoldLeft, foldLeft, foldLeft, foldLefttraversablegroupedStatefullyUntilT, groupedT, groupedUntilT, groupedWhileT, slidingT, slidingTadd, addToQueue, toQueue, toQueuegetQueueFactorygetLastActivepublic void forwardErrors(java.util.function.Consumer<java.lang.Throwable> c)
forwardErrors in interface FutureStreamSynchronousPublisher<U>public LazyReact getPopulator()
getPopulator in interface LazyToQueue<U>public void returnPopulator(LazyReact service)
returnPopulator in interface LazyToQueue<U>public <R,A> R collect(java.util.stream.Collector<? super U,A,R> collector)
ReactiveSeqCollector. A Collector
encapsulates the function used as arguments to
ReactiveSeq.collect(Supplier, BiConsumer, BiConsumer), allowing for reuse of
toX strategies and composition of collect operations such as
multiple-level grouping or partitioning.
If the reactiveStream is parallel, and the Collector
is concurrent, and
lazy the reactiveStream is unordered or the collector is
unordered,
applyHKT a concurrent reduction will be performed (see Collector for
details on concurrent reduction.)
This is a terminal operation.
When executed in parallel, multiple intermediate results may be
instantiated, populated, and merged so as to maintain isolation of
mutable data structures. Therefore, even when executed in parallel
with non-thread-safe data structures (such as ArrayList), no
additional synchronization is needed for a parallel reduction.
collect in interface CyclopsCollectable<U>collect in interface ReactiveSeq<U>collect in interface java.util.stream.Stream<U>collector - the Collector describing the reductionReactiveSeq.collect(Supplier, BiConsumer, BiConsumer),
Collectorspublic void close()
public FutureStream<U> withAsync(boolean b)
withAsync in interface ConfigurableStream<U,FastFuture<U>>withAsync in interface LazySimpleReactStream<U>withAsync in interface FutureStream<U>public java.util.concurrent.Executor getTaskExecutor()
getTaskExecutor in interface BaseSimpleReactStream<U>getTaskExecutor in interface ConfigurableStream<U,FastFuture<U>>public boolean isAsync()
isAsync in interface BaseSimpleReactStream<U>isAsync in interface ConfigurableStream<U,FastFuture<U>>public FutureStream<U> withTaskExecutor(java.util.concurrent.Executor e)
withTaskExecutor in interface ConfigurableStream<U,FastFuture<U>>withTaskExecutor in interface LazySimpleReactStream<U>withTaskExecutor in interface FutureStream<U>public <U> FutureStream<U> withLastActive(LazyStreamWrapper<U> w)
withLastActive in interface LazySimpleReactStream<U>withLastActive in interface FutureStream<U>public FutureStream<U> maxActive(int max)
FutureStream
List<String> data = new LazyReact().react(urlFile)
.maxActive(100)
.flatMap(this::loadUrls)
.map(this::callUrls)
.block();
maxActive in interface FutureStream<U>max - Maximum number of active task chainspublic void cancel()
cancel in interface FutureStreamSynchronousPublisher<U>public HotStream<U> schedule(java.lang.String cron, java.util.concurrent.ScheduledExecutorService ex)
ReactiveSeq
//run at 8PM every night
ReactiveSeq.generate(()->"next job:"+formatDate(new Date()))
.map(this::processJob)
.schedule("0 20 * * *",Executors.newScheduledThreadPool(1));
Connect to the Scheduled Stream
HotStream<Data> dataStream = ReactiveSeq.generate(() -> "next job:" + formatDate(new Date())).map(this::processJob)
.schedule("0 20 * * *", Executors.newScheduledThreadPool(1));
data.connect().forEach(this::logToDB);
public HotStream<U> scheduleFixedDelay(long delay, java.util.concurrent.ScheduledExecutorService ex)
ReactiveSeq
//run every 60 seconds after last job completes
ReactiveSeq.generate(()->"next job:"+formatDate(new Date()))
.map(this::processJob)
.scheduleFixedDelay(60_000,Executors.newScheduledThreadPool(1));
Connect to the Scheduled Stream
HotStream<Data> dataStream = ReactiveSeq.generate(() -> "next job:" + formatDate(new Date())).map(this::processJob)
.scheduleFixedDelay(60_000, Executors.newScheduledThreadPool(1));
data.connect().forEach(this::logToDB);
scheduleFixedDelay in interface Folds<U>scheduleFixedDelay in interface ReactiveSeq<U>delay - Between last element completes passing through the Stream
until the next one startsex - ScheduledExecutorServicepublic HotStream<U> scheduleFixedRate(long rate, java.util.concurrent.ScheduledExecutorService ex)
ReactiveSeq
//run every 60 seconds
ReactiveSeq.generate(()->"next job:"+formatDate(new Date()))
.map(this::processJob)
.scheduleFixedRate(60_000,Executors.newScheduledThreadPool(1));
Connect to the Scheduled Stream
HotStream<Data> dataStream = ReactiveSeq.generate(() -> "next job:" + formatDate(new Date())).map(this::processJob)
.scheduleFixedRate(60_000, Executors.newScheduledThreadPool(1));
data.connect().forEach(this::logToDB);
scheduleFixedRate in interface Folds<U>scheduleFixedRate in interface ReactiveSeq<U>rate - Time in millis between job runsex - ScheduledExecutorServicepublic <T> FutureStream<T> unitIterator(java.util.Iterator<T> it)
Traversable
ReactiveSeq<Integer> newSeq = seq.unitIterable(myIterator);
unitIterator in interface Traversable<U>it - Iterator to create new IterableFunctor frompublic FutureStream<U> append(U value)
append in interface Traversable<U>append in interface FutureStream<U>append in interface ReactiveSeq<U>public FutureStream<U> prepend(U value)
prepend in interface Traversable<U>prepend in interface ReactiveSeq<U>public <T> FutureStream<T> unit(T unit)
public HotStream<U> hotStream(java.util.concurrent.Executor e)
ReactiveSeqReactiveSeq.primedHotStream(Executor).
The generated HotStream is not pausable, for a pausable HotStream @see ReactiveSeq.pausableHotStream(Executor).
Turns this ReactiveSeq into a HotStream, a connectable Stream, being
executed on a thread on the supplied executor, that is producing data
HotStream<Integer> ints = ReactiveSeq.range(0,Integer.MAX_VALUE)
.hotStream(exec)
ints.connect().forEach(System.out::println);
//print out all the ints
//multiple consumers are possible, so other Streams can connect on different Threads
hotStream in interface ReactiveSeq<U>e - Executor to execute this ReactiveSeq onpublic HotStream<U> primedHotStream(java.util.concurrent.Executor e)
ReactiveSeqReactiveSeq.hotStream(Executor).
The generated HotStream is not pausable, for a pausable HotStream @see ReactiveSeq.primedPausableHotStream(Executor).
HotStream<Integer> ints = ReactiveSeq.range(0,Integer.MAX_VALUE) .hotStream(exec) ints.connect().forEach(System.out::println); //print out all the ints - starting when connect is called. //multiple consumers are possible, so other Streams can connect on different Threads
primedHotStream in interface ReactiveSeq<U>public PausableHotStream<U> pausableHotStream(java.util.concurrent.Executor e)
ReactiveSeqReactiveSeq.primedPausableHotStream(Executor).
The generated HotStream is pausable, for a unpausable HotStream (slightly faster execution) @see ReactiveSeq.hotStream(Executor).
HotStream<Integer> ints = ReactiveSeq.range(0,Integer.MAX_VALUE)
.hotStream(exec)
ints.connect().forEach(System.out::println);
ints.pause(); //on a separate thread pause the generating Stream
//print out all the ints
//multiple consumers are possible, so other Streams can connect on different Threads
pausableHotStream in interface ReactiveSeq<U>e - Executor to execute this ReactiveSeq onpublic PausableHotStream<U> primedPausableHotStream(java.util.concurrent.Executor e)
ReactiveSeqReactiveSeq.pausableHotStream(Executor).
The generated HotStream is pausable, for a unpausable HotStream @see ReactiveSeq.primedHotStream(Executor).
HotStream<Integer> ints = ReactiveSeq.range(0,Integer.MAX_VALUE) .hotStream(exec) ints.connect().forEach(System.out::println); //print out all the ints - starting when connect is called. //multiple consumers are possible, so other Streams can connect on different Threads
primedPausableHotStream in interface ReactiveSeq<U>public java.lang.String format()
format in interface ReactiveSeq<U>public <R> R visit(java.util.function.Function<? super ReactiveSeq<U>,? extends R> sync, java.util.function.Function<? super ReactiveSeq<U>,? extends R> reactiveStreams, java.util.function.Function<? super ReactiveSeq<U>,? extends R> asyncNoBackPressure)
visit in interface ReactiveSeq<U>public org.jooq.lambda.Collectable<U> collectors()
CyclopsCollectablecollectors in interface CyclopsCollectable<U>public U foldRight(Monoid<U> reducer)
ReactiveSeq
ReactiveSeq.of("a","b","c").foldRight(Reducers.toString(""));
// "cab"
public <T> T foldRightMapToType(Reducer<T> reducer)
ReactiveSeq
ReactiveSeq.of(1,2,3).foldRightMapToType(Reducers.toString(""));
// "321"
foldRightMapToType in interface Folds<U>foldRightMapToType in interface ReactiveSeq<U>reducer - Monoid to reduce valuespublic <R> R mapReduce(Reducer<R> reducer)
ReactiveSeq
ReactiveSeq.of("hello","2","world","4").mapReduce(Reducers.toCountInt());
//4
public <R> R mapReduce(java.util.function.Function<? super U,? extends R> mapper, Monoid<R> reducer)
ReactiveSeq
ReactiveSeq.of("one","two","three","four")
.mapReduce(this::toInt,Reducers.toTotalInt());
//10
int toInt(String s){
if("one".equals(s))
return 1;
if("two".equals(s))
return 2;
if("three".equals(s))
return 3;
if("four".equals(s))
return 4;
return -1;
}
public U reduce(Monoid<U> reducer)
ReactiveSeq
ReactiveSeq.of("hello","2","world","4").reduce(Reducers.toString(","));
//hello,2,world,4
public ListX<U> reduce(java.util.stream.Stream<? extends Monoid<U>> reducers)
ReactiveSeq
Monoid<Integer> sum = Monoid.of(0, (a, b) -> a + b);
Monoid<Integer> mult = Monoid.of(1, (a, b) -> a * b);
List<Integer> result = ReactiveSeq.of(1, 2, 3, 4).reduce(Arrays.asList(sum, mult).reactiveStream());
assertThat(result, equalTo(Arrays.asList(10, 24)));
public ListX<U> reduce(java.lang.Iterable<? extends Monoid<U>> reducers)
ReactiveSeq
Monoid<Integer> sum = Monoid.of(0,(a,b)->a+b);
Monoid<Integer> mult = Monoid.of(1,(a,b)->a*b);
List<Integer> result = ReactiveSeq.of(1,2,3,4))
.reduce(Arrays.asList(sum,mult) );
assertThat(result,equalTo(Arrays.asList(10,24)));
public U foldRight(U identity, java.util.function.BinaryOperator<U> accumulator)
ReactiveSeq
assertTrue(ReactiveSeq.of("a","b","c").foldRight("", String::concat).equals("cba"));
public java.util.Optional<U> min(java.util.Comparator<? super U> comparator)
CyclopsCollectablemin in interface CyclopsCollectable<U>min in interface ReactiveSeq<U>min in interface java.util.stream.Stream<U>public java.util.Optional<U> max(java.util.Comparator<? super U> comparator)
CyclopsCollectablemax in interface CyclopsCollectable<U>max in interface ReactiveSeq<U>max in interface java.util.stream.Stream<U>public long count()
ReactiveSeq
return mapToLong(e -> 1L).sum();
This is a terminal operation.
count in interface CyclopsCollectable<U>count in interface FutureStream<U>count in interface ReactiveSeq<U>count in interface java.util.stream.Stream<U>public boolean allMatch(java.util.function.Predicate<? super U> c)
ReactiveSeq
assertThat(ReactiveSeq.of(1,2,3,4,5).allMatch(it-> it>0 && it <6),equalTo(true));
allMatch in interface CyclopsCollectable<U>allMatch in interface ReactiveSeq<U>allMatch in interface java.util.stream.Stream<U>c - Predicate to check if all matchpublic boolean anyMatch(java.util.function.Predicate<? super U> c)
ReactiveSeq
assertThat(ReactiveSeq.of(1,2,3,4,5).anyMatch(it-> it.equals(3)),equalTo(true));
anyMatch in interface CyclopsCollectable<U>anyMatch in interface ReactiveSeq<U>anyMatch in interface java.util.stream.Stream<U>c - Predicate to check if any matchpublic boolean xMatch(int num,
java.util.function.Predicate<? super U> c)
ReactiveSeq
assertTrue(ReactiveSeq.of(1,2,3,5,6,7).xMatch(3, i-> i>4 ));
public boolean noneMatch(java.util.function.Predicate<? super U> c)
noneMatch in interface CyclopsCollectable<U>noneMatch in interface ReactiveSeq<U>noneMatch in interface java.util.stream.Stream<U>public final java.lang.String join()
ReactiveSeq
assertEquals("123".length(),ReactiveSeq.of(1, 2, 3).join().length());
public final java.lang.String join(java.lang.String sep)
ReactiveSeq
assertEquals("1, 2, 3".length(), ReactiveSeq.of(1, 2, 3).join(", ").length());
public java.lang.String join(java.lang.String sep,
java.lang.String start,
java.lang.String end)
ReactiveSeq
assertEquals("^1|2|3$".length(), of(1, 2, 3).join("|", "^", "$").length());
public HeadAndTail<U> headAndTail()
FoldableTraversable
ReactiveSeq<String> helloWorld = ReactiveSeq.Of("hello","world","last");
HeadAndTail<String> headAndTail = helloWorld.headAndTail();
String head = headAndTail.head();
//head == "hello"
ReactiveSeq<String> tail = headAndTail.tail();
//["world","last]
headAndTail in interface FoldableTraversable<U>headAndTail in interface ReactiveSeq<U>