StreamUtils (cyclops-javaslang 6.2.3 API)

java.lang.Object
- com.aol.cyclops.javaslang.streams.StreamUtils

public class StreamUtils
extends java.lang.Object

Constructor Summary

Constructors
Constructor and Description

StreamUtils()

Constructors
Constructor and Description
`StreamUtils()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static <T> <any>`	`append(<any> stream, T... values)` Append values to the end of this SequenceM
`static <T> <any>`	`appendStream(<any> stream1, <any> append)` Append Stream to this SequenceM
`static <T> <any>`	`batchBySize(<any> stream, int groupSize)` Group elements in a Monad into a Stream
`static <T,C extends java.util.Collection<T>> <any>`	`batchBySize(<any> stream, int groupSize, java.util.function.Supplier<C> factory)`
`static <T> <any>`	`batchBySizeAndTime(<any> stream, int size, long time, java.util.concurrent.TimeUnit t)`
`static <T,C extends java.util.Collection<T>> <any>`	`batchBySizeAndTime(<any> stream, int size, long time, java.util.concurrent.TimeUnit t, java.util.function.Supplier<C> factory)`
`static <T> <any>`	`batchByTime(<any> stream, long time, java.util.concurrent.TimeUnit t)`
`static <T,C extends java.util.Collection<T>> <any>`	`batchByTime(<any> stream, long time, java.util.concurrent.TimeUnit t, java.util.function.Supplier<C> factory)`
`static <T> <any>`	`batchUntil(<any> stream, java.util.function.Predicate<T> predicate)`
`static <T> <any>`	`batchWhile(<any> stream, java.util.function.Predicate<T> predicate)`
`static <T,C extends java.util.Collection<T>> <any>`	`batchWhile(<any> stream, java.util.function.Predicate<T> predicate, java.util.function.Supplier<C> factory)`
`static <T,U> <any>`	`cast(<any> stream, java.lang.Class<U> type)` Cast all elements in a stream to a given type, possibly throwing a `ClassCastException`.
`static <T,A,R> <any>`	`collect(<any> stream, <any> collectors)` Apply multiple Collectors, simultaneously to a Stream
`static <T,A,R> <any>`	`collect(<any> stream, java.lang.Iterable<java.util.stream.Collector> collectors)` Apply multiple Collectors, simultaneously to a Stream
`static <T> List`	`collect(<any> stream, com.aol.cyclops.sequence.streamable.Streamable<java.util.stream.Collector> collectors)` Apply multiple Collectors, simultaneously to a Stream
`static <T> <any>`	`completableFutureToStream(java.util.concurrent.CompletableFuture<T> future)`
`static <U> <any>`	`concat(java.lang.Object o, <any> stream)` Concat an Object and a Stream If the Object is a Stream, Streamable or Iterable will be converted (or left) in Stream form and concatonated Otherwise a new Stream.ofAll(o) is created
`static <U> <any>`	`cycle(<any> s)` Create a new Stream that infiniteable cycles the provided Stream
`static <T> <any>`	`cycle(<any> stream, com.aol.cyclops.sequence.Monoid<T> m, int times)` Convert to a Stream with the result of a reduction operation repeated specified times
`static <U> <any>`	`cycle(int times, com.aol.cyclops.sequence.streamable.Streamable<U> s)` Create a Stream that finitely cycles the provided Streamable, provided number of times
`static <U> <any>`	`cycle(com.aol.cyclops.sequence.streamable.Streamable<U> s)` Create a Stream that infiniteable cycles the provided Streamable
`static <T> <any>`	`cycleUntil(<any> stream, java.util.function.Predicate<? super T> predicate)` Repeat in a Stream until specified predicate holds
`static <T> <any>`	`cycleWhile(<any> stream, java.util.function.Predicate<? super T> predicate)` Repeat in a Stream while specified predicate holds
`static <T> <any>`	`debounce(<any> stream, long time, java.util.concurrent.TimeUnit t)`
`static <T> <any>`	`deleteBetween(<any> stream, int start, int end)` Delete elements between given indexes in a Stream
`static <T> <any>`	`duplicate(<any> stream)` Duplicate a Stream, buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream.
`static <T> boolean`	`endsWith(<any> stream, java.lang.Iterable<T> iterable)`
`static <T> T`	`firstValue(<any> stream)`
`static <T> <any>`	`fixedDelay(<any> stream, long time, java.util.concurrent.TimeUnit unit)`
`static <T,R> <any>`	`flatMapAnyM(<any> stream, java.util.function.Function<? super T,com.aol.cyclops.monad.AnyM<? extends R>> fn)`
`static <T> <any>`	`flatMapBufferedReader(<any> stream, java.util.function.Function<? super T,java.io.BufferedReader> fn)` Perform a flatMap operation where the result will be a flattened stream of Strings from the text loaded from the supplied BufferedReaders
`static <T> <any>`	`flatMapCharSequence(<any> stream, java.util.function.Function<? super T,java.lang.CharSequence> fn)` Perform a flatMap operation where the result will be a flattened stream of Characters from the CharSequence returned by the supplied function.
`static <T,R> <any>`	`flatMapCollection(<any> stream, java.util.function.Function<? super T,java.util.Collection<? extends R>> fn)` flatMap operation that allows a Collection to be returned
`static <T,R> <any>`	`flatMapCompletableFuture(<any> stream, java.util.function.Function<? super T,java.util.concurrent.CompletableFuture<? extends R>> fn)` `assertThat(StreamUtils.flatMapCompletableFuture(Stream.ofAll(1,2,3), i->CompletableFuture.completedFuture(i+2)) .collect(Collectors.toList()), equalTo(Arrays.asList(3,4,5)));`
`static <T> <any>`	`flatMapFile(<any> stream, java.util.function.Function<? super T,java.io.File> fn)` Perform a flatMap operation where the result will be a flattened stream of Strings from the text loaded from the supplied files.
`static <T,R> <any>`	`flatMapOptional(<any> stream, java.util.function.Function<? super T,java.util.Optional<? extends R>> fn)` cross type flatMap, removes null entries
`static <T,R> <any>`	`flatMapSequenceM(<any> stream, java.util.function.Function<? super T,com.aol.cyclops.sequence.SequenceM<? extends R>> fn)` flatMap operation
`static <T,R> <any>`	`flatMapStream(<any> stream, java.util.function.Function<? super T,java.util.stream.BaseStream<? extends R,?>> fn)` `assertThat(StreamUtils.flatMapStream(Stream.ofAll(1,2,3), i->Stream.ofAll(i)).collect(Collectors.toList()), equalTo(Arrays.asList(1,2,3)));`
`static <T> <any>`	`flatMapURL(<any> stream, java.util.function.Function<? super T,java.net.URL> fn)` Perform a flatMap operation where the result will be a flattened stream of Strings from the text loaded from the supplied URLs
`static <T,R> <any>`	`flatten(<any> stream)`
`static <T> T`	`foldLeft(<any> stream, com.aol.cyclops.sequence.Monoid<T> reducer)`
`static <T> T`	`foldLeftMapToType(<any> stream, com.aol.cyclops.sequence.Monoid<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
`static <T> T`	`foldRight(<any> stream, com.aol.cyclops.sequence.Monoid<T> reducer)`
`static <T> T`	`foldRightMapToType(<any> stream, com.aol.cyclops.sequence.Monoid<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
`static <T> com.aol.cyclops.sequence.future.FutureOperations<T>`	`futureOperations(<any> stream, java.util.concurrent.Executor exec)`
`static <T> com.aol.cyclops.sequence.HeadAndTail<T>`	`headAndTail(<any> stream)` extract head and tail together
`static <T> java.util.Optional<com.aol.cyclops.sequence.HeadAndTail<T>>`	`headAndTailOptional(<any> stream)` `Stream<String> helloWorld = Stream.ofAll(); Optional<HeadAndTail<String>> headAndTail = StreamUtils.headAndTailOptional(helloWorld); assertTrue(!headAndTail.isPresent());`
`static <T> JavaslangHotStream<T>`	`hotStream(<any> stream, java.util.concurrent.Executor exec)`
`static <T> <any>`	`insertAt(<any> stream, int pos, T... values)` Insert data into a stream at given position
`static <T> <any>`	`insertStreamAt(<any> stream1, int pos, <any> insert)` Insert a Stream into the middle of this stream at the specified position
`static <T> <any>`	`intersperse(<any> stream, T value)` Returns a stream with a given value interspersed between any two values of this stream.
`static <T> <any>`	`jitter(<any> stream, long jitterInNanos)`
`static <T> java.lang.String`	`join(<any> stream)`
`static <T> java.lang.String`	`join(<any> stream, java.lang.String sep)`
`static <T> java.lang.String`	`join(<any> stream, java.lang.String sep, java.lang.String start, java.lang.String end)`
`static <U> <any>`	`limit(<any> stream, long time, java.util.concurrent.TimeUnit unit)`
`static <U> <any>`	`limitLast(<any> stream, int num)`
`static <U> <any>`	`limitUntil(<any> stream, java.util.function.Predicate<? super U> predicate)` Take elements from a Stream until the predicate holds
`static <U> <any>`	`limitWhile(<any> stream, java.util.function.Predicate<? super U> predicate)` Take elements from a stream while the predicates hold
`static <T,R> R`	`mapReduce(<any> stream, java.util.function.Function<? super T,? extends R> mapper, com.aol.cyclops.sequence.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
`static <T,R> R`	`mapReduce(<any> stream, com.aol.cyclops.sequence.Monoid<R> 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
`static <T> java.util.Optional<T>`	`max(<any> stream, java.util.Comparator<? super T> comparator)`
`static <T,C extends java.lang.Comparable<? super C>> java.util.Optional<T>`	`maxBy(<any> stream, java.util.function.Function<T,C> f)`
`static <T> java.util.Optional<T>`	`min(<any> stream, java.util.Comparator<? super T> comparator)`
`static <T,C extends java.lang.Comparable<C>> java.util.Optional<T>`	`minBy(<any> stream, java.util.function.Function<T,C> f)`
`static <T> boolean`	`noneMatch(<any> stream, java.util.function.Predicate<? super T> c)` `assertThat(StreamUtils.noneMatch(of(1,2,3,4,5),it-> it==5000),equalTo(true));`
`static <T,U> <any>`	`ofType(<any> stream, java.lang.Class<U> type)` Keep only those elements in a stream that are of a given type.
`static <T> <any>`	`onePer(<any> stream, long time, java.util.concurrent.TimeUnit t)`
`static <T> <any>`	`optionalToStream(java.util.Optional<T> optional)`
`static <T> <any>`	`partition(<any> stream, java.util.function.Predicate<T> splitter)` Partition a Stream into two one a per element basis, based on predicate's boolean value
`static <T> <any>`	`prepend(<any> stream, T... values)` Prepend given values to the start of the Stream
`static <T> <any>`	`prependStream(<any> stream1, <any> prepend)` Prepend Stream to this SequenceM
`static <T> <any>`	`quadruplicate(<any> stream)` Makes four copies of a Stream Buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream.
`static <T,EX extends java.lang.Throwable> <any>`	`recover(<any> stream, java.lang.Class<EX> type, java.util.function.Function<EX,T> fn)`
`static <T> <any>`	`recover(<any> stream, java.util.function.Function<java.lang.Throwable,T> fn)`
`static <R> <any>`	`reduce(<any> stream, <any> reducers)` Simultanously reduce a stream with multiple reducers
`static <R> <any>`	`reduce(<any> stream, java.lang.Iterable<com.aol.cyclops.sequence.Monoid<R>> reducers)` Simultaneously reduce a stream with multiple reducers
`static <U> <any>`	`reverse(<any> stream)` Reverse a Stream
`static <U> <any>`	`reversedStream(<any> list)` Create a reversed Stream from a List
`static <T> <any>`	`scanLeft(<any> stream, com.aol.cyclops.sequence.Monoid<T> monoid)` Scan left using supplied Monoid
`static <U,T> <any>`	`scanRight(<any> stream, U identity, java.util.function.BiFunction<? super T,U,U> combiner)`
`static <T> com.aol.cyclops.sequence.streamable.Streamable<T>`	`shuffle(<any> stream)`
`static <U> <any>`	`skip(<any> stream, long time, java.util.concurrent.TimeUnit unit)`
`static <U> <any>`	`skipLast(<any> stream, int num)`
`static <U> <any>`	`skipUntil(<any> stream, java.util.function.Predicate<? super U> predicate)` skip elements in Stream until Predicate holds true
`static <U> <any>`	`skipWhile(<any> stream, java.util.function.Predicate<? super U> predicate)` skip elements in a Stream while Predicate holds true
`static <T> <any>`	`sliding(<any> stream, int windowSize)` Create a sliding view over this Stream
`static <T> <any>`	`sliding(<any> stream, int windowSize, int increment)` Create a sliding view over this Stream
`static <T> <any>`	`splitAt(<any> stream, int where)` Split at supplied location
`static <T> <any>`	`splitBy(<any> stream, java.util.function.Predicate<T> splitter)` Split stream at point where predicate no longer holds
`static <T> boolean`	`startsWith(<any> stream, java.lang.Iterable<T> iterable)` `assertTrue(StreamUtils.startsWith(Stream.ofAll(1,2,3,4),Arrays.asList(1,2,3)));`
`static <T> boolean`	`startsWith(<any> stream, java.util.Iterator<T> iterator)` `assertTrue(StreamUtils.startsWith(Stream.ofAll(1,2,3,4),Arrays.asList(1,2,3).iterator()))`
`static <K,V> <any>`	`stream(<any> it)` Create a stream from a map
`static <U> <any>`	`stream(java.lang.Iterable<U> it)` Create a stream from an iterable
`static <U> <any>`	`stream(java.util.Iterator<U> it)` Create a stream from an iterator
`static <K,V> <any>`	`stream(java.util.Map<K,V> it)` Create a stream from a map
`static <U> <any>`	`stream(java.util.Spliterator<U> it)`
`static <T> java.util.concurrent.CompletableFuture<<any>>`	`streamToCompletableFuture(<any> stream)`
`static <T> java.util.Optional<<any>>`	`streamToOptional(<any> stream)`
`static <A> <any>`	`toBufferingCopier(java.util.Iterator<A> iterator, int copies)`
`static <A> <any>`	`toBufferingDuplicator(java.util.Iterator<A> iterator)`
`static <A> <any>`	`toBufferingDuplicator(java.util.Iterator<A> iterator, long pos)`
`static <A> java.util.Collection<A>`	`toConcurrentLazyCollection(<any> stream)` Lazily constructs a Collection from specified Stream.
`static <T> com.aol.cyclops.sequence.streamable.Streamable<T>`	`toConcurrentLazyStreamable(<any> stream)`
`static <A> java.util.Collection<A>`	`toLazyCollection(<any> stream)` Projects an immutable collection of this stream.
`static <T> com.aol.cyclops.sequence.streamable.Streamable<T>`	`toLazyStreamable(<any> stream)`
`static <T> <any>`	`toList(<any> stream)`
`static <T> <any>`	`toSet(<any> stream)`
`static <T> com.aol.cyclops.sequence.streamable.Streamable<T>`	`toStreamable(<any> stream)`
`static <T> <any>`	`triplicate(<any> stream)` Triplicates a Stream Buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream.
`static <T> <any>`	`window(<any> stream, int windowSize, int increment)` Create a sliding view over this Stream
`static <T> <any>`	`windowBySizeAndTime(<any> stream, int size, long time, java.util.concurrent.TimeUnit t)`
`static <T> <any>`	`windowByTime(<any> stream, long time, java.util.concurrent.TimeUnit t)`
`static <T> <any>`	`windowStatefullyWhile(<any> stream, java.util.function.BiPredicate<com.aol.cyclops.sequence.streamable.Streamable<T>,T> predicate)`
`static <T> <any>`	`windowWhile(<any> stream, java.util.function.Predicate<T> predicate)`
`static <T> boolean`	`xMatch(<any> stream, int num, java.util.function.Predicate<? super T> c)` Check that there are specified number of matches of predicate in the Stream
`static <T> <any>`	`xPer(<any> stream, int x, long time, java.util.concurrent.TimeUnit t)`
`static <T,S,R> <any>`	`zipAnyM(<any> stream, com.aol.cyclops.monad.AnyM<? extends S> second, java.util.function.BiFunction<? super T,? super S,? extends R> zipper)` Generic zip function.
`static <T,S,R> <any>`	`zipSequence(<any> stream, <any> second, java.util.function.BiFunction<? super T,? super S,? extends R> zipper)` Generic zip function.
`static <T,S,R> <any>`	`zipStream(<any> stream, java.util.stream.BaseStream<? extends S,? extends java.util.stream.BaseStream<? extends S,?>> second, java.util.function.BiFunction<? super T,? super S,? extends R> zipper)` Zip this Monad with a Stream

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail
- StreamUtils
```
public StreamUtils()
```

Method Detail

streamToOptional

public static final <T> java.util.Optional<<any>> streamToOptional(<any> stream)

optionalToStream

public static final <T> <any> optionalToStream(java.util.Optional<T> optional)

streamToCompletableFuture

public static final <T> java.util.concurrent.CompletableFuture<<any>> streamToCompletableFuture(<any> stream)

completableFutureToStream

public static final <T> <any> completableFutureToStream(java.util.concurrent.CompletableFuture<T> future)

splitAt

public static final <T> <any> splitAt(<any> stream,
                                      int where)

Split at supplied location

  
 StreamUtils.splitAt(Stream.ofAll(1,2,3))
 
  //Stream[1], Stream[2,3]

splitBy

public static final <T> <any> splitBy(<any> stream,
                                      java.util.function.Predicate<T> splitter)

Split stream at point where predicate no longer holds

 
   StreamUtils.splitBy(Stream.ofAll(1, 2, 3, 4, 5, 6),i->i<4);
   
   //Stream[1,2,3] Stream[4,5,6]

partition

public static final <T> <any> partition(<any> stream,
                                        java.util.function.Predicate<T> splitter)

Partition a Stream into two one a per element basis, based on predicate's boolean value

  
  StreamUtils.partition(Stream.ofAll(1, 2, 3, 4, 5, 6),i -> i % 2 != 0) 
  
  //Stream[1,3,5], Stream[2,4,6]

duplicate

public static final <T> <any> duplicate(<any> stream)

Duplicate a Stream, buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream. Not thread-safe.

  
  Tuple2<Stream<Integer>, Stream<Integer>> copies =of(1,2,3,4,5,6).duplicate();
		 assertTrue(copies._1.anyMatch(i->i==2));
		 assertTrue(copies._2.anyMatch(i->i==2));

Returns:: duplicated stream

triplicate

public static final <T> <any> triplicate(<any> stream)

Triplicates a Stream Buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream. Not thread-safe.

  
 	Tuple3<Stream<Tuple3<T1,T2,T3>>,Stream<Tuple3<T1,T2,T3>>,Stream<Tuple3<T1,T2,T3>>> Tuple3 = sequence.triplicate();

quadruplicate

public static final <T> <any> quadruplicate(<any> stream)

Makes four copies of a Stream Buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream. Not thread-safe.

 
 
 		Tuple4<Stream<Tuple4<T1,T2,T3,T4>>,Stream<Tuple4<T1,T2,T3,T4>>,Stream<Tuple4<T1,T2,T3,T4>>,Stream<Tuple4<T1,T2,T3,T4>>> quad = sequence.quadruplicate();

Returns:

appendStream

public static final <T> <any> appendStream(<any> stream1,
                                           <any> append)

Append Stream to this SequenceM

  
 List<String> result = 	of(1,2,3).appendStream(of(100,200,300))
										.map(it ->it+"!!")
										.collect(Collectors.toList());

			assertThat(result,equalTo(Arrays.asList("1!!","2!!","3!!","100!!","200!!","300!!")));

Parameters:: stream - to append
Returns:: SequenceM with Stream appended

prependStream

public static final <T> <any> prependStream(<any> stream1,
                                            <any> prepend)

Prepend Stream to this SequenceM

  
 List<String> result = of(1,2,3).prependStream(of(100,200,300))
				.map(it ->it+"!!").collect(Collectors.toList());

			assertThat(result,equalTo(Arrays.asList("100!!","200!!","300!!","1!!","2!!","3!!")));

Parameters:: stream - to Prepend
Returns:: SequenceM with Stream prepended

append

public static final <T> <any> append(<any> stream,
                                     T... values)

Append values to the end of this SequenceM

  
 List<String> result = 	of(1,2,3).append(100,200,300)
										.map(it ->it+"!!")
										.collect(Collectors.toList());

			assertThat(result,equalTo(Arrays.asList("1!!","2!!","3!!","100!!","200!!","300!!")));

Parameters:: values - to append
Returns:: SequenceM with appended values

prepend

public static final <T> <any> prepend(<any> stream,
                                      T... values)

Prepend given values to the start of the Stream

  
 List<String> result = 	of(1,2,3).prepend(100,200,300)
				.map(it ->it+"!!").collect(Collectors.toList());

			assertThat(result,equalTo(Arrays.asList("100!!","200!!","300!!","1!!","2!!","3!!")));

Parameters:: values - to prepend
Returns:: SequenceM with values prepended

insertAt

public static final <T> <any> insertAt(<any> stream,
                                       int pos,
                                       T... values)

Insert data into a stream at given position

  
 List<String> result = 	of(1,2,3).insertAt(1,100,200,300)
				.map(it ->it+"!!").collect(Collectors.toList());

			assertThat(result,equalTo(Arrays.asList("1!!","100!!","200!!","300!!","2!!","3!!")));

Parameters:: pos - to insert data at; values - to insert
Returns:: Stream with new data inserted

deleteBetween

public static final <T> <any> deleteBetween(<any> stream,
                                            int start,
                                            int end)

Delete elements between given indexes in a Stream

  
 List<String> result = 	of(1,2,3,4,5,6).deleteBetween(2,4)
				.map(it ->it+"!!").collect(Collectors.toList());

			assertThat(result,equalTo(Arrays.asList("1!!","2!!","5!!","6!!")));

Parameters:: start - index; end - index
Returns:: Stream with elements removed

insertStreamAt

public static final <T> <any> insertStreamAt(<any> stream1,
                                             int pos,
                                             <any> insert)

Insert a Stream into the middle of this stream at the specified position

  
 List<String> result = 	of(1,2,3).insertStreamAt(1,of(100,200,300))
				.map(it ->it+"!!").collect(Collectors.toList());

			assertThat(result,equalTo(Arrays.asList("1!!","100!!","200!!","300!!","2!!","3!!")));

Parameters:: pos - to insert Stream at; stream - to insert
Returns:: newly conjoined SequenceM

cycle

public static final <T> <any> cycle(<any> stream,
                                    com.aol.cyclops.sequence.Monoid<T> m,
                                    int times)

Convert to a Stream with the result of a reduction operation repeated specified times

  
   		List<Integer> list = StreamUtils.cycle(Stream.ofAll(1,2,2),Reducers.toCountInt(),3)
 										.
 										.collect(Collectors.toList());
 	//is asList(3,3,3);

Parameters:: m - Monoid to be used in reduction; times - Number of times value should be repeated
Returns:: Stream with reduced values repeated

headAndTail

public static final <T> com.aol.cyclops.sequence.HeadAndTail<T> headAndTail(<any> stream)

extract head and tail together

  
  Stream<String> helloWorld = Stream.ofAll("hello","world","last");
		HeadAndTail<String> headAndTail = StreamUtils.headAndTail(helloWorld);
		 String head = headAndTail.head();
		 assertThat(head,equalTo("hello"));
		
		Stream<String> tail =  headAndTail.tail();
		assertThat(tail.headAndTail().head(),equalTo("world"));

Returns:

headAndTailOptional

public static final <T> java.util.Optional<com.aol.cyclops.sequence.HeadAndTail<T>> headAndTailOptional(<any> stream)

  
  Stream<String> helloWorld = Stream.ofAll();
		Optional<HeadAndTail<String>> headAndTail = StreamUtils.headAndTailOptional(helloWorld);
		assertTrue(!headAndTail.isPresent());

Parameters:: stream - to extract head and tail from
Returns:

skipUntil

public static <U> <any> skipUntil(<any> stream,
                                  java.util.function.Predicate<? super U> predicate)

skip elements in Stream until Predicate holds true

   StreamUtils.skipUntil(Stream.ofAll(4,3,6,7),i->i==6).collect(Collectors.toList())
  // [6,7]

Parameters:: stream - Stream to skip elements from; predicate - to apply
Returns:: Stream with elements skipped

skipLast

public static <U> <any> skipLast(<any> stream,
                                 int num)

limitLast

public static <U> <any> limitLast(<any> stream,
                                  int num)

recover

public static <T> <any> recover(<any> stream,
                                java.util.function.Function<java.lang.Throwable,T> fn)

recover

public static <T,EX extends java.lang.Throwable> <any> recover(<any> stream,
                                                               java.lang.Class<EX> type,
                                                               java.util.function.Function<EX,T> fn)

skipWhile

public static <U> <any> skipWhile(<any> stream,
                                  java.util.function.Predicate<? super U> predicate)

skip elements in a Stream while Predicate holds true

 
   StreamUtils.skipWhile(Stream.ofAll(4,3,6,7).sorted(),i->i<6).collect(Collectors.toList())
  // [6,7]

Parameters:: stream -; predicate -
Returns:

limit

public static <U> <any> limit(<any> stream,
                              long time,
                              java.util.concurrent.TimeUnit unit)

skip

public static <U> <any> skip(<any> stream,
                             long time,
                             java.util.concurrent.TimeUnit unit)

limitWhile

public static <U> <any> limitWhile(<any> stream,
                                   java.util.function.Predicate<? super U> predicate)

Take elements from a stream while the predicates hold

  StreamUtils.limitWhile(Stream.ofAll(4,3,6,7).sorted(),i->i<6).collect(Collectors.toList());
 //[4,3]

Parameters:: stream -; predicate -
Returns:

limitUntil

public static <U> <any> limitUntil(<any> stream,
                                   java.util.function.Predicate<? super U> predicate)

Take elements from a Stream until the predicate holds

  StreamUtils.limitUntil(Stream.ofAll(4,3,6,7),i->i==6).collect(Collectors.toList());
 //[4,3]

Parameters:: stream -; predicate -
Returns:

reverse

public static <U> <any> reverse(<any> stream)

Reverse a Stream

  
 assertThat(StreamUtils.reverse(Stream.ofAll(1,2,3)).collect(Collectors.toList())
				,equalTo(Arrays.asList(3,2,1)));

Parameters:: stream - Stream to reverse
Returns:: Reversed stream

reversedStream

public static <U> <any> reversedStream(<any> list)

Create a reversed Stream from a List

  
 StreamUtils.reversedStream(asList(1,2,3))
				.map(i->i*100)
				.forEach(System.out::println);
		
		
		assertThat(StreamUtils.reversedStream(Arrays.asList(1,2,3)).collect(Collectors.toList())
				,equalTo(Arrays.asList(3,2,1)));

Parameters:: list - List to create a reversed Stream from
Returns:: Reversed Stream

cycle

public static <U> <any> cycle(<any> s)

Create a new Stream that infiniteable cycles the provided Stream

  		
 assertThat(StreamUtils.cycle(Stream.ofAll(1,2,3))
 						.limit(6)
 						.collect(Collectors.toList()),
 								equalTo(Arrays.asList(1,2,3,1,2,3)));

Parameters:: s - Stream to cycle
Returns:: New cycling stream

cycle
```
public static <U> <any> cycle(com.aol.cyclops.sequence.streamable.Streamable<U> s)
```
Create a Stream that infiniteable cycles the provided Streamable

Parameters:

s - Streamable to cycle

Returns:

New cycling stream

cycle

public static <U> <any> cycle(int times,
                              com.aol.cyclops.sequence.streamable.Streamable<U> s)

Create a Stream that finitely cycles the provided Streamable, provided number of times

  
 assertThat(StreamUtils.cycle(3,Streamable.of(1,2,2))
								.collect(Collectors.toList()),
									equalTo(Arrays.asList(1,2,2,1,2,2,1,2,2)));

Parameters:: s - Streamable to cycle
Returns:: New cycling stream

stream

public static <U> <any> stream(java.lang.Iterable<U> it)

Create a stream from an iterable

  
 	assertThat(StreamUtils.stream(Arrays.asList(1,2,3))
 								.collect(Collectors.toList()),
 									equalTo(Arrays.asList(1,2,3)));

Parameters:: it - Iterable to convert to a Stream
Returns:: Stream from iterable

stream

public static <U> <any> stream(java.util.Spliterator<U> it)

stream

public static <U> <any> stream(java.util.Iterator<U> it)

Create a stream from an iterator

  
 	assertThat(StreamUtils.stream(Arrays.asList(1,2,3).iterator())	
 							.collect(Collectors.toList()),
 								equalTo(Arrays.asList(1,2,3)));

Parameters:: it - Iterator to convert to a Stream
Returns:: Stream from iterator

concat
```
public static <U> <any> concat(java.lang.Object o,
                               <any> stream)
```
Concat an Object and a Stream If the Object is a Stream, Streamable or Iterable will be converted (or left) in Stream form and concatonated Otherwise a new Stream.ofAll(o) is created

Parameters:

o - Object to concat

stream - Stream to concat

Returns:

Concatonated Stream

stream

public static final <K,V> <any> stream(java.util.Map<K,V> it)

Create a stream from a map

  
 	Map<String,String> map = new HashMap<>();
		map.put("hello","world");
		assertThat(StreamUtils.stream(map).collect(Collectors.toList()),equalTo(Arrays.asList(new AbstractMap.SimpleEntry("hello","world"))));

Parameters:: it - Iterator to convert to a Stream
Returns:: Stream from a map

stream

public static final <K,V> <any> stream(<any> it)

Create a stream from a map

  
 HashMap<String,String> map = HashMap.<String,String>empty().put("hello","world");
	  	
		assertThat(StreamUtils.stream(map).collect(Collectors.toList()),equalTo(Arrays.asList(new AbstractMap.SimpleEntry("hello","world"))));

Parameters:: it - Iterator to convert to a Stream
Returns:: Stream from a map

futureOperations

public static final <T> com.aol.cyclops.sequence.future.FutureOperations<T> futureOperations(<any> stream,
                                                                                             java.util.concurrent.Executor exec)

firstValue

public static final <T> T firstValue(<any> stream)

reduce

public static <R> <any> reduce(<any> stream,
                               java.lang.Iterable<com.aol.cyclops.sequence.Monoid<R>> reducers)

Simultaneously reduce a stream with multiple reducers


 
  Monoid<Integer> sum = Monoid.of(0,(a,b)->a+b);
		Monoid<Integer> mult = Monoid.of(1,(a,b)->a*b);
		val result = StreamUtils.reduce(Stream.ofAll(1,2,3,4),Arrays.asList(sum,mult));
				
		 
		assertThat(result,equalTo(Arrays.asList(10,24)));

Parameters:: stream - Stream to reduce; reducers - Reducers to reduce Stream
Returns:: Reduced Stream values as List entries

reduce

public static <R> <any> reduce(<any> stream,
                               <any> reducers)

Simultanously reduce a stream with multiple reducers

  
  Monoid<String> concat = Monoid.of("",(a,b)->a+b);
		Monoid<String> join = Monoid.of("",(a,b)->a+","+b);
		assertThat(StreamUtils.reduce(Stream.ofAll("hello", "world", "woo!"),Stream.ofAll(concat,join))
		                 ,equalTo(Arrays.asList("helloworldwoo!",",hello,world,woo!")));

Parameters:: stream - Stream to reduce; reducers - Reducers to reduce Stream
Returns:: Reduced Stream values as List entries

collect

public static <T,A,R> <any> collect(<any> stream,
                                    <any> collectors)

Apply multiple Collectors, simultaneously to a Stream

  
 List result = StreamUtils.collect(Stream.ofAll(1,2,3),
								Stream.ofAll(Collectors.toList(),
								Collectors.summingInt(Integer::intValue),
								Collectors.averagingInt(Integer::intValue)));
		
		assertThat(result.get(0),equalTo(Arrays.asList(1,2,3)));
		assertThat(result.get(1),equalTo(6));
		assertThat(result.get(2),equalTo(2.0));

Parameters:: stream - Stream to collect; collectors - Collectors to apply
Returns:: Result as a list

collect

public static <T,A,R> <any> collect(<any> stream,
                                    java.lang.Iterable<java.util.stream.Collector> collectors)

Apply multiple Collectors, simultaneously to a Stream

  
 List result = StreamUtils.collect(Stream.ofAll(1,2,3),
								Arrays.asList(Collectors.toList(),
								Collectors.summingInt(Integer::intValue),
								Collectors.averagingInt(Integer::intValue)));
		
		assertThat(result.get(0),equalTo(Arrays.asList(1,2,3)));
		assertThat(result.get(1),equalTo(6));
		assertThat(result.get(2),equalTo(2.0));

Parameters:: stream - Stream to collect; collectors - Collectors to apply
Returns:: Result as a list

collect

public static <T> List collect(<any> stream,
                               com.aol.cyclops.sequence.streamable.Streamable<java.util.stream.Collector> collectors)

Apply multiple Collectors, simultaneously to a Stream

 
 List result = StreamUtils.collect(Stream.ofAll(1,2,3),
								Streamable.<Collector>of(Collectors.toList(),
								Collectors.summingInt(Integer::intValue),
								Collectors.averagingInt(Integer::intValue)));
		
		assertThat(result.get(0),equalTo(Arrays.asList(1,2,3)));
		assertThat(result.get(1),equalTo(6));
		assertThat(result.get(2),equalTo(2.0));

Parameters:: stream - Stream to collect; collectors - Collectors to apply
Returns:: Result as a list

cycleWhile

public static final <T> <any> cycleWhile(<any> stream,
                                         java.util.function.Predicate<? super T> predicate)

Repeat in a Stream while specified predicate holds

  
  int count =0;
  
		assertThat(StreamUtils.cycleWhile(Stream.ofAll(1,2,2)
											,next -> count++<6 )
											.collect(Collectors.toList()),equalTo(Arrays.asList(1,2,2,1,2,2)));

Parameters:: predicate - repeat while true
Returns:: Repeating Stream

cycleUntil

public static final <T> <any> cycleUntil(<any> stream,
                                         java.util.function.Predicate<? super T> predicate)

Repeat in a Stream until specified predicate holds

  
 	count =0;
		assertThat(StreamUtils.cycleUntil(Stream.ofAll(1,2,2,3)
											,next -> count++>10 )
											.collect(Collectors.toList()),equalTo(Arrays.asList(1, 2, 2, 3, 1, 2, 2, 3, 1, 2, 2)));

Parameters:: predicate - repeat while true
Returns:: Repeating Stream

zipSequence

public static final <T,S,R> <any> zipSequence(<any> stream,
                                              <any> second,
                                              java.util.function.BiFunction<? super T,? super S,? extends R> zipper)

Generic zip function. E.g. Zipping a Stream and a Sequence

  
 Stream<List<Integer>> zipped = StreamUtils.zip(Stream.ofAll(1,2,3)
												,SequenceM.of(2,3,4), 
													(a,b) -> Arrays.asList(a,b));
		
		
		List<Integer> zip = zipped.collect(Collectors.toList()).get(1);
		assertThat(zip.get(0),equalTo(2));
		assertThat(zip.get(1),equalTo(3));

Parameters:: second - Monad to zip with; zipper - Zipping function
Returns:: Stream zipping two Monads

zipAnyM

public static final <T,S,R> <any> zipAnyM(<any> stream,
                                          com.aol.cyclops.monad.AnyM<? extends S> second,
                                          java.util.function.BiFunction<? super T,? super S,? extends R> zipper)

Generic zip function. E.g. Zipping a Stream and an Optional

 
 Stream<List<Integer>> zipped = StreamUtils.zip(Stream.ofAll(1,2,3)
										,anyM(Optional.of(2)), 
											(a,b) -> Arrays.asList(a,b));
		
		
		List<Integer> zip = zipped.collect(Collectors.toList()).get(0);
		assertThat(zip.get(0),equalTo(1));
		assertThat(zip.get(1),equalTo(2));

zipStream

public static final <T,S,R> <any> zipStream(<any> stream,
                                            java.util.stream.BaseStream<? extends S,? extends java.util.stream.BaseStream<? extends S,?>> second,
                                            java.util.function.BiFunction<? super T,? super S,? extends R> zipper)

Zip this Monad with a Stream

            
	   Stream<List<Integer>> zipped = StreamUtils.zipStream(Stream.ofAll(1,2,3)
												,Stream.ofAll(2,3,4), 
													(a,b) -> Arrays.asList(a,b));
		
		
		List<Integer> zip = zipped.collect(Collectors.toList()).get(1);
		assertThat(zip.get(0),equalTo(2));
		assertThat(zip.get(1),equalTo(3));

Parameters:: second - Stream to zip with; zipper - Zip funciton
Returns:: This monad zipped with a Stream

sliding

public static final <T> <any> sliding(<any> stream,
                                      int windowSize,
                                      int increment)

Create a sliding view over this Stream

  
 List<List<Integer>> list = StreamUtils.sliding(Stream.ofAll(1,2,3,4,5,6)
												,2,1)
									.collect(Collectors.toList());
		
	
		assertThat(list.get(0),hasItems(1,2));
		assertThat(list.get(1),hasItems(2,3));

Parameters:: windowSize - Size of sliding window
Returns:: Stream with sliding view over monad

window

public static final <T> <any> window(<any> stream,
                                     int windowSize,
                                     int increment)

Create a sliding view over this Stream

  
 List<List<Integer>> list = StreamUtils.sliding(Stream.ofAll(1,2,3,4,5,6)
												,2,1)
									.collect(Collectors.toList());
		
	
		assertThat(list.get(0),hasItems(1,2));
		assertThat(list.get(1),hasItems(2,3));

Parameters:: windowSize - Size of sliding window
Returns:: Stream with sliding view over monad

sliding

public static final <T> <any> sliding(<any> stream,
                                      int windowSize)

Create a sliding view over this Stream

  
 List<List<Integer>> list = StreamUtils.sliding(Stream.ofAll(1,2,3,4,5,6)
												,2)
									.collect(Collectors.toList());
		
	
		assertThat(list.get(0),hasItems(1,2));
		assertThat(list.get(1),hasItems(2,3));

Parameters:: stream - Stream to create sliding view on; windowSize - size of window
Returns:

batchBySize

public static final <T> <any> batchBySize(<any> stream,
                                          int groupSize)

Group elements in a Monad into a Stream

            
 	List<List<Integer>> list = StreamUtils.grouped(Stream.ofAll(1,2,3,4,5,6)
														,3)
													.collect(Collectors.toList());
		
		
		assertThat(list.get(0),hasItems(1,2,3));
		assertThat(list.get(1),hasItems(4,5,6));

Parameters:: groupSize - Size of each Group
Returns:: Stream with elements grouped by size

batchBySize

public static final <T,C extends java.util.Collection<T>> <any> batchBySize(<any> stream,
                                                                            int groupSize,
                                                                            java.util.function.Supplier<C> factory)

shuffle

public static final <T> com.aol.cyclops.sequence.streamable.Streamable<T> shuffle(<any> stream)

toLazyStreamable

public static final <T> com.aol.cyclops.sequence.streamable.Streamable<T> toLazyStreamable(<any> stream)

toConcurrentLazyStreamable

public static final <T> com.aol.cyclops.sequence.streamable.Streamable<T> toConcurrentLazyStreamable(<any> stream)

scanRight

public static final <U,T> <any> scanRight(<any> stream,
                                          U identity,
                                          java.util.function.BiFunction<? super T,U,U> combiner)

scanLeft

public static final <T> <any> scanLeft(<any> stream,
                                       com.aol.cyclops.sequence.Monoid<T> monoid)

Scan left using supplied Monoid

   
 
 	assertEquals(asList("", "a", "ab", "abc"),
 					StreamUtils.scanLeft(Stream.ofAll("a", "b", "c"),Reducers.toString(""))
 			.collect(Collectors.toList());

Parameters:: monoid -
Returns:

xMatch

public static <T> boolean xMatch(<any> stream,
                                 int num,
                                 java.util.function.Predicate<? super T> c)

Check that there are specified number of matches of predicate in the Stream

  
  assertTrue(StreamUtils.xMatch(Stream.ofAll(1,2,3,5,6,7),3, i->i>4));

noneMatch

public static final <T> boolean noneMatch(<any> stream,
                                          java.util.function.Predicate<? super T> c)

  
 assertThat(StreamUtils.noneMatch(of(1,2,3,4,5),it-> it==5000),equalTo(true));

join

public static final <T> java.lang.String join(<any> stream)

join

public static final <T> java.lang.String join(<any> stream,
                                              java.lang.String sep)

join

public static final <T> java.lang.String join(<any> stream,
                                              java.lang.String sep,
                                              java.lang.String start,
                                              java.lang.String end)

minBy

public static final <T,C extends java.lang.Comparable<C>> java.util.Optional<T> minBy(<any> stream,
                                                                                      java.util.function.Function<T,C> f)

min

public static final <T> java.util.Optional<T> min(<any> stream,
                                                  java.util.Comparator<? super T> comparator)

maxBy

public static final <T,C extends java.lang.Comparable<? super C>> java.util.Optional<T> maxBy(<any> stream,
                                                                                              java.util.function.Function<T,C> f)

max

public static final <T> java.util.Optional<T> max(<any> stream,
                                                  java.util.Comparator<? super T> comparator)

mapReduce
```
public static final <T,R> R mapReduce(<any> stream,
                                      com.aol.cyclops.sequence.Monoid<R> 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

Parameters:

reducer - Monoid to reduce values

Returns:

Reduce result

mapReduce

public static final <T,R> R mapReduce(<any> stream,
                                      java.util.function.Function<? super T,? extends R> mapper,
                                      com.aol.cyclops.sequence.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

Parameters:: mapper - Function to map Monad type; reducer - Monoid to reduce values
Returns:: Reduce result

foldLeft

public static final <T> T foldLeft(<any> stream,
                                   com.aol.cyclops.sequence.Monoid<T> reducer)

Parameters:: reducer - Use supplied Monoid to reduce values starting via foldLeft
Returns:: Reduced result

foldLeftMapToType
```
public static final <T> T foldLeftMapToType(<any> stream,
                                            com.aol.cyclops.sequence.Monoid<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

Parameters:

reducer - Monoid to reduce values

Returns:

Reduce result

foldRight

public static final <T> T foldRight(<any> stream,
                                    com.aol.cyclops.sequence.Monoid<T> reducer)

Parameters:: reducer - Use supplied Monoid to reduce values starting via foldRight
Returns:: Reduced result

foldRightMapToType
```
public static final <T> T foldRightMapToType(<any> stream,
                                             com.aol.cyclops.sequence.Monoid<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

Parameters:

reducer - Monoid to reduce values

Returns:

Reduce result

toStreamable

public static final <T> com.aol.cyclops.sequence.streamable.Streamable<T> toStreamable(<any> stream)

Returns:: Underlying monad converted to a Streamable instance

toSet

public static final <T> <any> toSet(<any> stream)

Returns:: This monad converted to a set

toList

public static final <T> <any> toList(<any> stream)

Returns:: this monad converted to a list

startsWith

public static final <T> boolean startsWith(<any> stream,
                                           java.lang.Iterable<T> iterable)

 
 assertTrue(StreamUtils.startsWith(Stream.ofAll(1,2,3,4),Arrays.asList(1,2,3)));

Parameters:: iterable -
Returns:: True if Monad starts with Iterable sequence of data

endsWith

public static final <T> boolean endsWith(<any> stream,
                                         java.lang.Iterable<T> iterable)

startsWith

public static final <T> boolean startsWith(<any> stream,
                                           java.util.Iterator<T> iterator)

 
 		 assertTrue(StreamUtils.startsWith(Stream.ofAll(1,2,3,4),Arrays.asList(1,2,3).iterator()))

Parameters:: iterator -
Returns:: True if Monad starts with Iterators sequence of data

intersperse

public static <T> <any> intersperse(<any> stream,
                                    T value)

Returns a stream with a given value interspersed between any two values of this stream.

  
 assertThat(Arrays.asList(1, 0, 2, 0, 3, 0, 4),
 			equalTo( StreamUtils.intersperse(Stream.ofAll(1, 2, 3, 4),0));

ofType
```
public static <T,U> <any> ofType(<any> stream,
                                 java.lang.Class<U> type)
```
Keep only those elements in a stream that are of a given type. assertThat(Arrays.asList(1, 2, 3), equalTo( StreamUtils.ofType(Stream.ofAll(1, "a", 2, "b", 3,Integer.class));

cast

public static <T,U> <any> cast(<any> stream,
                               java.lang.Class<U> type)

Cast all elements in a stream to a given type, possibly throwing a ClassCastException.

 
 StreamUtils.cast(Stream.ofAll(1, "a", 2, "b", 3),Integer.class)
  // throws ClassCastException

flatMapSequenceM

public static final <T,R> <any> flatMapSequenceM(<any> stream,
                                                 java.util.function.Function<? super T,com.aol.cyclops.sequence.SequenceM<? extends R>> fn)

flatMap operation

  
 		assertThat(StreamUtils.flatMapSequenceM(Stream.ofAll(1,2,3),
 							i->SequenceM.of(i+2)).collect(Collectors.toList()),
 								equalTo(Arrays.asList(3,4,5)));

Parameters:: fn -
Returns:

flatMapAnyM

public static final <T,R> <any> flatMapAnyM(<any> stream,
                                            java.util.function.Function<? super T,com.aol.cyclops.monad.AnyM<? extends R>> fn)

flatMapCollection

public static final <T,R> <any> flatMapCollection(<any> stream,
                                                  java.util.function.Function<? super T,java.util.Collection<? extends R>> fn)

flatMap operation that allows a Collection to be returned

  
 	assertThat(StreamUtils.flatMapCollection(Stream.ofAll(20),i->Arrays.asList(1,2,i))
 								.collect(Collectors.toList()),
 								equalTo(Arrays.asList(1,2,20)));

flatMapStream

public static final <T,R> <any> flatMapStream(<any> stream,
                                              java.util.function.Function<? super T,java.util.stream.BaseStream<? extends R,?>> fn)

  
 	assertThat(StreamUtils.flatMapStream(Stream.ofAll(1,2,3),
 							i->Stream.ofAll(i)).collect(Collectors.toList()),
 							equalTo(Arrays.asList(1,2,3)));

flatMapOptional

public static final <T,R> <any> flatMapOptional(<any> stream,
                                                java.util.function.Function<? super T,java.util.Optional<? extends R>> fn)

cross type flatMap, removes null entries

  
 	 assertThat(StreamUtils.flatMapOptional(Stream.ofAll(1,2,3,null),
 										Optional::ofNullable)
 										.collect(Collectors.toList()),
 										equalTo(Arrays.asList(1,2,3)));

flatten

public static final <T,R> <any> flatten(<any> stream)

flatMapCompletableFuture

public static final <T,R> <any> flatMapCompletableFuture(<any> stream,
                                                         java.util.function.Function<? super T,java.util.concurrent.CompletableFuture<? extends R>> fn)

  
 	assertThat(StreamUtils.flatMapCompletableFuture(Stream.ofAll(1,2,3),
 								i->CompletableFuture.completedFuture(i+2))
 								.collect(Collectors.toList()),
 								equalTo(Arrays.asList(3,4,5)));

flatMapCharSequence

public static final <T> <any> flatMapCharSequence(<any> stream,
                                                  java.util.function.Function<? super T,java.lang.CharSequence> fn)

Perform a flatMap operation where the result will be a flattened stream of Characters from the CharSequence returned by the supplied function.

  
   List<Character> result = StreamUtils.liftAndBindCharSequence(Stream.ofAll("input.file"),
									.i->"hello world")
									.toList();
		
		assertThat(result,equalTo(Arrays.asList('h','e','l','l','o',' ','w','o','r','l','d')));

Parameters:: fn -
Returns:

flatMapFile

public static final <T> <any> flatMapFile(<any> stream,
                                          java.util.function.Function<? super T,java.io.File> fn)

Perform a flatMap operation where the result will be a flattened stream of Strings from the text loaded from the supplied files.

 
 
		List<String> result = StreamUtils.liftAndBindFile(Stream.ofAll("input.file")
								.map(getClass().getClassLoader()::getResource)
								.peek(System.out::println)
								.map(URL::getFile)
								,File::new)
								.toList();
		
		assertThat(result,equalTo(Arrays.asList("hello","world")));

Parameters:: fn -
Returns:

flatMapURL

public static final <T> <any> flatMapURL(<any> stream,
                                         java.util.function.Function<? super T,java.net.URL> fn)

Perform a flatMap operation where the result will be a flattened stream of Strings from the text loaded from the supplied URLs

  
 List<String> result = StreamUtils.liftAndBindURL(Stream.ofAll("input.file")
								,getClass().getClassLoader()::getResource)
								.collect(Collectors.toList();
		
		assertThat(result,equalTo(Arrays.asList("hello","world")));

Parameters:: fn -
Returns:

flatMapBufferedReader

public static final <T> <any> flatMapBufferedReader(<any> stream,
                                                    java.util.function.Function<? super T,java.io.BufferedReader> fn)

Perform a flatMap operation where the result will be a flattened stream of Strings from the text loaded from the supplied BufferedReaders

 List result = StreamUtils.liftAndBindBufferedReader(Stream.ofAll("input.file")
                                                                .map(getClass().getClassLoader()::getResourceAsStream)
                                                                .map(InputStreamReader::new)
                                                                ,BufferedReader::new)
                                                                .collect(Collectors.toList();
                
                assertThat(result,equalTo(Arrays.asList("hello","world")));

Parameters:: fn -
Returns:

toBufferingDuplicator

public static final <A> <any> toBufferingDuplicator(java.util.Iterator<A> iterator)

toBufferingDuplicator

public static final <A> <any> toBufferingDuplicator(java.util.Iterator<A> iterator,
                                                    long pos)

toBufferingCopier

public static final <A> <any> toBufferingCopier(java.util.Iterator<A> iterator,
                                                int copies)

toLazyCollection
```
public static final <A> java.util.Collection<A> toLazyCollection(<any> stream)
```
Projects an immutable collection of this stream. Initial iteration over the collection is not thread safe (can't be performed by multiple threads concurrently) subsequent iterations are.

Returns:

An immutable collection of this stream.

toConcurrentLazyCollection
```
public static final <A> java.util.Collection<A> toConcurrentLazyCollection(<any> stream)
```
Lazily constructs a Collection from specified Stream. Collections iterator may be safely used concurrently by multiple threads.

Parameters:

stream -

Returns:

windowByTime

public static final <T> <any> windowByTime(<any> stream,
                                           long time,
                                           java.util.concurrent.TimeUnit t)

batchByTime

public static final <T> <any> batchByTime(<any> stream,
                                          long time,
                                          java.util.concurrent.TimeUnit t)

batchByTime

public static final <T,C extends java.util.Collection<T>> <any> batchByTime(<any> stream,
                                                                            long time,
                                                                            java.util.concurrent.TimeUnit t,
                                                                            java.util.function.Supplier<C> factory)

windowStatefullyWhile

public static final <T> <any> windowStatefullyWhile(<any> stream,
                                                    java.util.function.BiPredicate<com.aol.cyclops.sequence.streamable.Streamable<T>,T> predicate)

windowWhile

public static final <T> <any> windowWhile(<any> stream,
                                          java.util.function.Predicate<T> predicate)

batchWhile

public static final <T> <any> batchWhile(<any> stream,
                                         java.util.function.Predicate<T> predicate)

batchWhile

public static final <T,C extends java.util.Collection<T>> <any> batchWhile(<any> stream,
                                                                           java.util.function.Predicate<T> predicate,
                                                                           java.util.function.Supplier<C> factory)

batchUntil

public static final <T> <any> batchUntil(<any> stream,
                                         java.util.function.Predicate<T> predicate)

batchBySizeAndTime

public static final <T> <any> batchBySizeAndTime(<any> stream,
                                                 int size,
                                                 long time,
                                                 java.util.concurrent.TimeUnit t)

batchBySizeAndTime

public static final <T,C extends java.util.Collection<T>> <any> batchBySizeAndTime(<any> stream,
                                                                                   int size,
                                                                                   long time,
                                                                                   java.util.concurrent.TimeUnit t,
                                                                                   java.util.function.Supplier<C> factory)

windowBySizeAndTime

public static final <T> <any> windowBySizeAndTime(<any> stream,
                                                  int size,
                                                  long time,
                                                  java.util.concurrent.TimeUnit t)

debounce

public static final <T> <any> debounce(<any> stream,
                                       long time,
                                       java.util.concurrent.TimeUnit t)

onePer

public static final <T> <any> onePer(<any> stream,
                                     long time,
                                     java.util.concurrent.TimeUnit t)

jitter

public static final <T> <any> jitter(<any> stream,
                                     long jitterInNanos)

fixedDelay

public static final <T> <any> fixedDelay(<any> stream,
                                         long time,
                                         java.util.concurrent.TimeUnit unit)

xPer

public static final <T> <any> xPer(<any> stream,
                                   int x,
                                   long time,
                                   java.util.concurrent.TimeUnit t)

hotStream

public static final <T> JavaslangHotStream<T> hotStream(<any> stream,
                                                        java.util.concurrent.Executor exec)

Class StreamUtils

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

StreamUtils

Method Detail

streamToOptional

optionalToStream

streamToCompletableFuture

completableFutureToStream

splitAt

splitBy

partition

duplicate

triplicate

quadruplicate

appendStream

prependStream

append

prepend

insertAt

deleteBetween

insertStreamAt

cycle

headAndTail

headAndTailOptional

skipUntil

skipLast

limitLast

recover

recover

skipWhile

limit

skip

limitWhile

limitUntil

reverse

reversedStream

cycle

cycle

cycle

stream

stream

stream

concat

stream

stream

futureOperations

firstValue

reduce

reduce

collect

collect

collect

cycleWhile

cycleUntil

zipSequence

zipAnyM

zipStream

sliding

window

sliding

batchBySize

batchBySize

shuffle

toLazyStreamable

toConcurrentLazyStreamable

scanRight

scanLeft

xMatch

noneMatch

join

join

join

minBy

min

maxBy

max

mapReduce