com.aol.cyclops.streams

Class StreamUtils

java.lang.Object

com.aol.cyclops.streams.StreamUtils

public class StreamUtils
extends java.lang.Object

Constructor Summary

Constructors

Constructor and Description
StreamUtils()

Method Summary

Modifier and Type	Method and Description
static <T> AnyM<T>	anyM(java.util.stream.Stream<T> monad)
static <T,U> java.util.stream.Stream<U>	cast(java.util.stream.Stream<T> stream, java.lang.Class<U> type) Cast all elements in a stream to a given type, possibly throwing a ClassCastException.
static <T,A,R> java.util.List<R>	collect(java.util.stream.Stream<T> stream, java.lang.Iterable<java.util.stream.Collector> collectors) Apply multiple Collectors, simultaneously to a Stream
static <T,A,R> java.util.List<R>	collect(java.util.stream.Stream<T> stream, java.util.stream.Stream<java.util.stream.Collector> collectors) Apply multiple Collectors, simultaneously to a Stream
static <T> java.util.List	collect(java.util.stream.Stream<T> stream, Streamable<java.util.stream.Collector> collectors) Apply multiple Collectors, simultaneously to a Stream
static <U> java.util.stream.Stream<U>	concat(java.lang.Object o, java.util.stream.Stream<U> 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.of(o) is created
static <U> java.util.stream.Stream<U>	cycle(int times, Streamable<U> s) Create a Stream that finitely cycles the provided Streamable, provided number of times
static <T> java.util.stream.Stream<T>	cycle(java.util.stream.Stream<T> stream, Monoid<T> m, int times) Convert to a Stream with the result of a reduction operation repeated specified times
static <U> java.util.stream.Stream<U>	cycle(java.util.stream.Stream<U> s) Create a new Stream that infiniteable cycles the provided Stream
static <U> java.util.stream.Stream<U>	cycle(Streamable<U> s) Create a Stream that infiniteable cycles the provided Streamable
static <T> java.util.stream.Stream<T>	cycleUntil(java.util.stream.Stream<T> stream, java.util.function.Predicate<? super T> predicate) Repeat in a Stream until specified predicate holds
static <T> java.util.stream.Stream<T>	cycleWhile(java.util.stream.Stream<T> stream, java.util.function.Predicate<? super T> predicate) Repeat in a Stream while specified predicate holds
static <T,R> java.util.stream.Stream<R>	flatMapAnyM(java.util.stream.Stream<T> stream, java.util.function.Function<? super T,AnyM<? extends R>> fn)
static <T,R> java.util.stream.Stream<R>	flatMapCollection(java.util.stream.Stream<T> 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> java.util.stream.Stream<R>	flatMapCompletableFuture(java.util.stream.Stream<T> stream, java.util.function.Function<? super T,java.util.concurrent.CompletableFuture<? extends R>> fn) assertThat(StreamUtils.flatMapCompletableFuture(Stream.of(1,2,3), i->CompletableFuture.completedFuture(i+2)) .collect(Collectors.toList()), equalTo(Arrays.asList(3,4,5)));
static <T,R> java.util.stream.Stream<R>	flatMapLazySeq(java.util.stream.Stream<T> stream, java.util.function.Function<? super T,com.nurkiewicz.lazyseq.LazySeq<? extends R>> fn) assertThat(StreamUtils.flatMapLazySeq(Stream.of(1,2,3), i->LazySeq.of(i+2)) .collect(Collectors.toList()), equalTo(Arrays.asList(3,4,5)));
static <T,R> java.util.stream.Stream<R>	flatMapOptional(java.util.stream.Stream<T> stream, java.util.function.Function<? super T,java.util.Optional<? extends R>> fn) cross type flatMap, removes null entries
static <T,R> java.util.stream.Stream<R>	flatMapSequenceM(java.util.stream.Stream<T> stream, java.util.function.Function<? super T,SequenceM<? extends R>> fn) flatMap operation
static <T,R> java.util.stream.Stream<R>	flatMapStream(java.util.stream.Stream<T> stream, java.util.function.Function<? super T,java.util.stream.BaseStream<? extends R,?>> fn) assertThat(StreamUtils.flatMapStream(Stream.of(1,2,3), i->Stream.of(i)).collect(Collectors.toList()), equalTo(Arrays.asList(1,2,3)));
static <T> T	foldLeft(java.util.stream.Stream<T> stream, Monoid<T> reducer)
static <T> T	foldLeftMapToType(java.util.stream.Stream<T> stream, 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(java.util.stream.Stream<T> stream, Monoid<T> reducer)
static <T> T	foldRightMapToType(java.util.stream.Stream<T> stream, 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> java.util.stream.Stream<java.util.List<T>>	grouped(java.util.stream.Stream<T> stream, int groupSize) Group elements in a Monad into a Stream
static <T> HeadAndTail<T>	headAndTail(java.util.stream.Stream<T> stream) extract head and tail together
static <T> java.util.Optional<HeadAndTail<T>>	headAndTailOptional(java.util.stream.Stream<T> stream) Stream<String> helloWorld = Stream.of(); Optional<HeadAndTail<String>> headAndTail = StreamUtils.headAndTailOptional(helloWorld); assertTrue(!headAndTail.isPresent());
static <T> java.util.stream.Stream<T>	intersperse(java.util.stream.Stream<T> stream, T value) Returns a stream with a given value interspersed between any two values of this stream.
static <T> java.lang.String	join(java.util.stream.Stream<T> stream)
static <T> java.lang.String	join(java.util.stream.Stream<T> stream, java.lang.String sep)
static <T> java.lang.String	join(java.util.stream.Stream<T> stream, java.lang.String sep, java.lang.String start, java.lang.String end)
static <T> java.util.stream.Stream<java.lang.String>	liftAndBindBufferedReader(java.util.stream.Stream<T> 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> java.util.stream.Stream<java.lang.Character>	liftAndBindCharSequence(java.util.stream.Stream<T> 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> java.util.stream.Stream<java.lang.String>	liftAndBindFile(java.util.stream.Stream<T> 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> java.util.stream.Stream<java.lang.String>	liftAndBindURL(java.util.stream.Stream<T> 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 <U> java.util.stream.Stream<U>	limitUntil(java.util.stream.Stream<U> stream, java.util.function.Predicate<? super U> predicate) Take elements from a Stream until the predicate holds
static <U> java.util.stream.Stream<U>	limitWhile(java.util.stream.Stream<U> stream, java.util.function.Predicate<? super U> predicate) Take elements from a stream while the predicates hold
static <T,R> R	mapReduce(java.util.stream.Stream<T> stream, java.util.function.Function<? super T,? 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
static <T,R> R	mapReduce(java.util.stream.Stream<T> stream, 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(java.util.stream.Stream<T> stream, java.util.Comparator<? super T> comparator)
static <T,C extends java.lang.Comparable<? super C>> java.util.Optional<T>	maxBy(java.util.stream.Stream<T> stream, java.util.function.Function<T,C> f)
static <T> java.util.Optional<T>	min(java.util.stream.Stream<T> stream, java.util.Comparator<? super T> comparator)
static <T,C extends java.lang.Comparable<? super C>> java.util.Optional<T>	minBy(java.util.stream.Stream<T> stream, java.util.function.Function<T,C> f)
static <T> boolean	noneMatch(java.util.stream.Stream<T> 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> java.util.stream.Stream<U>	ofType(java.util.stream.Stream<T> stream, java.lang.Class<U> type) Keep only those elements in a stream that are of a given type.
static <R> java.util.List<R>	reduce(java.util.stream.Stream<R> stream, java.lang.Iterable<Monoid<R>> reducers) Simultaneously reduce a stream with multiple reducers
static <R> java.util.List<R>	reduce(java.util.stream.Stream<R> stream, java.util.stream.Stream<Monoid<R>> reducers) Simultanously reduce a stream with multiple reducers
static <U> java.util.stream.Stream<U>	reverse(java.util.stream.Stream<U> stream) Reverse a Stream
static <U> java.util.stream.Stream<U>	reversedStream(java.util.List<U> list) Create a reversed Stream from a List
static <T> java.util.stream.Stream<T>	scanLeft(java.util.stream.Stream<T> stream, Monoid<T> monoid) Scan left using supplied Monoid
static <T> SequenceM<T>	sequenceM(java.util.stream.Stream<T> monad)
static <U> java.util.stream.Stream<U>	skipUntil(java.util.stream.Stream<U> stream, java.util.function.Predicate<? super U> predicate) skip elements in Stream until Predicate holds true
static <U> java.util.stream.Stream<U>	skipWhile(java.util.stream.Stream<U> stream, java.util.function.Predicate<? super U> predicate) skip elements in a Stream while Predicate holds true
static <T> java.util.stream.Stream<java.util.List<T>>	sliding(java.util.stream.Stream<T> stream, int windowSize) Create a sliding view over this Stream
static <T> java.util.stream.Stream<java.util.List<T>>	sliding(java.util.stream.Stream<T> stream, int windowSize, int increment) Create a sliding view over this Stream
static <T> boolean	startsWith(java.util.stream.Stream<T> stream, java.lang.Iterable<T> iterable) assertTrue(StreamUtils.startsWith(Stream.of(1,2,3,4),Arrays.asList(1,2,3)));
static <T> boolean	startsWith(java.util.stream.Stream<T> stream, java.util.Iterator<T> iterator) assertTrue(StreamUtils.startsWith(Stream.of(1,2,3,4),Arrays.asList(1,2,3).iterator()))
static <T> com.nurkiewicz.lazyseq.LazySeq<T>	steamToLazySeq(java.util.stream.Stream<T> stream) Convert a Stream to a LazySeq
static <U> java.util.stream.Stream<U>	stream(java.lang.Iterable<U> it) Create a stream from an iterable
static <U> java.util.stream.Stream<U>	stream(java.util.Iterator<U> it) Create a stream from an iterator
static <K,V> java.util.stream.Stream<java.util.Map.Entry<K,V>>	stream(java.util.Map<K,V> it) Create a stream from a map
static <U> java.util.stream.Stream<U>	stream(java.util.Spliterator<U> it)
static <A> java.util.List<java.util.Iterator<A>>	toBufferingCopier(java.util.Iterator<A> iterator, int copies)
static <A> Pair<java.util.Iterator<A>,java.util.Iterator<A>>	toBufferingDuplicator(java.util.Iterator<A> iterator)
static <A> Pair<java.util.Iterator<A>,java.util.Iterator<A>>	toBufferingDuplicator(java.util.Iterator<A> iterator, long pos)
static <A> java.util.Collection<A>	toConcurrentLazyCollection(java.util.Iterator<A> iterator)
static <A> java.util.Collection<A>	toConcurrentLazyCollection(java.util.stream.Stream<A> stream) Lazily constructs a Collection from specified Stream.
static <A> java.util.Collection<A>	toLazyCollection(java.util.Iterator<A> iterator)
static <A> java.util.Collection<A>	toLazyCollection(java.util.stream.Stream<A> stream) Projects an immutable collection of this stream.
static <T> java.util.List<T>	toList(java.util.stream.Stream<T> stream)
static <T> java.util.Set<T>	toSet(java.util.stream.Stream<T> stream)
static <T> Streamable<T>	toStreamable(java.util.stream.Stream<T> stream)
static <T> boolean	xMatch(java.util.stream.Stream<T> 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,S,R> java.util.stream.Stream<R>	zip(java.util.stream.Stream<T> stream, AnyM<? extends S> second, java.util.function.BiFunction<? super T,? super S,? extends R> zipper) Generic zip function.
static <T,S,R> java.util.stream.Stream<R>	zip(java.util.stream.Stream<T> stream, SequenceM<? extends S> second, java.util.function.BiFunction<? super T,? super S,? extends R> zipper) Generic zip function.
static <T,S,R> java.util.stream.Stream<R>	zipStream(java.util.stream.Stream<T> 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

cycle

public static final <T> java.util.stream.Stream<T> cycle(java.util.stream.Stream<T> stream,
                                                         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.of(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> HeadAndTail<T> headAndTail(java.util.stream.Stream<T> stream)

extract head and tail together

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

Returns:

headAndTailOptional

public static final <T> java.util.Optional<HeadAndTail<T>> headAndTailOptional(java.util.stream.Stream<T> stream)

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

Parameters:

stream - to extract head and tail from

Returns:

skipUntil

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

skip elements in Stream until Predicate holds true

   StreamUtils.skipUntil(Stream.of(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

skipWhile

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

skip elements in a Stream while Predicate holds true

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

Parameters:

stream -

predicate -

Returns:

limitWhile

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

Take elements from a stream while the predicates hold

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

Parameters:

stream -

predicate -

Returns:

limitUntil

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

Take elements from a Stream until the predicate holds

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

Parameters:

stream -

predicate -

Returns:

reverse

public static <U> java.util.stream.Stream<U> reverse(java.util.stream.Stream<U> stream)

Reverse a Stream

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

Parameters:

stream - Stream to reverse

Returns:

Reversed stream

reversedStream

public static <U> java.util.stream.Stream<U> reversedStream(java.util.List<U> 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> java.util.stream.Stream<U> cycle(java.util.stream.Stream<U> s)

Create a new Stream that infiniteable cycles the provided Stream

  		
 assertThat(StreamUtils.cycle(Stream.of(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> java.util.stream.Stream<U> cycle(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> java.util.stream.Stream<U> cycle(int times,
                                                   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> java.util.stream.Stream<U> 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> java.util.stream.Stream<U> stream(java.util.Spliterator<U> it)

stream

public static <U> java.util.stream.Stream<U> 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> java.util.stream.Stream<U> concat(java.lang.Object o,
                                                    java.util.stream.Stream<U> 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.of(o) is created

Parameters:

o - Object to concat

stream - Stream to concat

Returns:

Concatonated Stream

stream

public static <K,V> java.util.stream.Stream<java.util.Map.Entry<K,V>> 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

reduce

public static <R> java.util.List<R> reduce(java.util.stream.Stream<R> stream,
                                           java.lang.Iterable<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.of(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> java.util.List<R> reduce(java.util.stream.Stream<R> stream,
                                           java.util.stream.Stream<Monoid<R>> 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.of("hello", "world", "woo!"),Stream.of(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> java.util.List<R> collect(java.util.stream.Stream<T> stream,
                                                java.util.stream.Stream<java.util.stream.Collector> collectors)

Apply multiple Collectors, simultaneously to a Stream

  
 List result = StreamUtils.collect(Stream.of(1,2,3),
								Stream.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

collect

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

Apply multiple Collectors, simultaneously to a Stream

  
 List result = StreamUtils.collect(Stream.of(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> java.util.List collect(java.util.stream.Stream<T> stream,
                                         Streamable<java.util.stream.Collector> collectors)

Apply multiple Collectors, simultaneously to a Stream

 
 List result = StreamUtils.collect(Stream.of(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> java.util.stream.Stream<T> cycleWhile(java.util.stream.Stream<T> stream,
                                                              java.util.function.Predicate<? super T> predicate)

Repeat in a Stream while specified predicate holds

  
  int count =0;
  
		assertThat(StreamUtils.cycleWhile(Stream.of(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> java.util.stream.Stream<T> cycleUntil(java.util.stream.Stream<T> stream,
                                                              java.util.function.Predicate<? super T> predicate)

Repeat in a Stream until specified predicate holds

  
 	count =0;
		assertThat(StreamUtils.cycleUntil(Stream.of(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

zip

public static final <T,S,R> java.util.stream.Stream<R> zip(java.util.stream.Stream<T> stream,
                                                           SequenceM<? 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.of(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

zip

public static final <T,S,R> java.util.stream.Stream<R> zip(java.util.stream.Stream<T> stream,
                                                           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.of(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> java.util.stream.Stream<R> zipStream(java.util.stream.Stream<T> 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.of(1,2,3)
												,Stream.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 - Stream to zip with

zipper - Zip funciton

Returns:

This monad zipped with a Stream

sliding

public static final <T> java.util.stream.Stream<java.util.List<T>> sliding(java.util.stream.Stream<T> stream,
                                                                           int windowSize,
                                                                           int increment)

Create a sliding view over this Stream

  
 List<List<Integer>> list = StreamUtils.sliding(Stream.of(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> java.util.stream.Stream<java.util.List<T>> sliding(java.util.stream.Stream<T> stream,
                                                                           int windowSize)

Create a sliding view over this Stream

  
 List<List<Integer>> list = StreamUtils.sliding(Stream.of(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:

grouped

public static final <T> java.util.stream.Stream<java.util.List<T>> grouped(java.util.stream.Stream<T> stream,
                                                                           int groupSize)

Group elements in a Monad into a Stream

            
 	List<List<Integer>> list = StreamUtils.grouped(Stream.of(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

scanLeft

public static final <T> java.util.stream.Stream<T> scanLeft(java.util.stream.Stream<T> stream,
                                                            Monoid<T> monoid)

Scan left using supplied Monoid

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

Parameters:

monoid -

Returns:

steamToLazySeq

public static <T> com.nurkiewicz.lazyseq.LazySeq<T> steamToLazySeq(java.util.stream.Stream<T> stream)

Convert a Stream to a LazySeq

  
 assertThat(Arrays.asList(1,2,3),equalTo(StreamUtils.steamToLazySeq(Stream.of(1,2,3)).toList()));
 
 

Parameters:

LazySeq -

Returns:

xMatch

public static <T> boolean xMatch(java.util.stream.Stream<T> 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.of(1,2,3,5,6,7),3, i->i>4));
 
 

noneMatch

public static final <T> boolean noneMatch(java.util.stream.Stream<T> 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(java.util.stream.Stream<T> stream)

join

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

join

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

minBy

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

min

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

maxBy

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

max

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

mapReduce

public static final <T,R> R mapReduce(java.util.stream.Stream<T> stream,
                                      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(java.util.stream.Stream<T> stream,
                                      java.util.function.Function<? super T,? 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

Parameters:

mapper - Function to map Monad type

reducer - Monoid to reduce values

Returns:

Reduce result

foldLeft

public static final <T> T foldLeft(java.util.stream.Stream<T> stream,
                                   Monoid<T> reducer)

Parameters:

reducer - Use supplied Monoid to reduce values starting via foldLeft

Returns:

Reduced result

foldLeftMapToType

public static final <T> T foldLeftMapToType(java.util.stream.Stream<T> stream,
                                            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(java.util.stream.Stream<T> stream,
                                    Monoid<T> reducer)

Parameters:

reducer - Use supplied Monoid to reduce values starting via foldRight

Returns:

Reduced result

foldRightMapToType

public static final <T> T foldRightMapToType(java.util.stream.Stream<T> stream,
                                             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> Streamable<T> toStreamable(java.util.stream.Stream<T> stream)

Returns:

Underlying monad converted to a Streamable instance

toSet

public static final <T> java.util.Set<T> toSet(java.util.stream.Stream<T> stream)

Returns:

This monad converted to a set

toList

public static final <T> java.util.List<T> toList(java.util.stream.Stream<T> stream)

Returns:

this monad converted to a list

startsWith

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

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

Parameters:

iterable -

Returns:

True if Monad starts with Iterable sequence of data

startsWith

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

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

Parameters:

iterator -

Returns:

True if Monad starts with Iterators sequence of data

anyM

public static <T> AnyM<T> anyM(java.util.stream.Stream<T> monad)

sequenceM

public static <T> SequenceM<T> sequenceM(java.util.stream.Stream<T> monad)

intersperse

public static <T> java.util.stream.Stream<T> intersperse(java.util.stream.Stream<T> 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.of(1, 2, 3, 4),0));
 
 

ofType

public static <T,U> java.util.stream.Stream<U> ofType(java.util.stream.Stream<T> 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.of(1, "a", 2, "b", 3,Integer.class));

cast

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

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

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

flatMapSequenceM

public static final <T,R> java.util.stream.Stream<R> flatMapSequenceM(java.util.stream.Stream<T> stream,
                                                                      java.util.function.Function<? super T,SequenceM<? extends R>> fn)

flatMap operation

  
 		assertThat(StreamUtils.flatMapSequenceM(Stream.of(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> java.util.stream.Stream<R> flatMapAnyM(java.util.stream.Stream<T> stream,
                                                                 java.util.function.Function<? super T,AnyM<? extends R>> fn)

flatMapCollection

public static final <T,R> java.util.stream.Stream<R> flatMapCollection(java.util.stream.Stream<T> 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.of(20),i->Arrays.asList(1,2,i))
 								.collect(Collectors.toList()),
 								equalTo(Arrays.asList(1,2,20)));

 
 

flatMapStream

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

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

 
 
 

flatMapOptional

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

cross type flatMap, removes null entries

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

 
 

flatMapCompletableFuture

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

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

 

flatMapLazySeq

public static final <T,R> java.util.stream.Stream<R> flatMapLazySeq(java.util.stream.Stream<T> stream,
                                                                    java.util.function.Function<? super T,com.nurkiewicz.lazyseq.LazySeq<? extends R>> fn)

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

 
 

liftAndBindCharSequence

public static final <T> java.util.stream.Stream<java.lang.Character> liftAndBindCharSequence(java.util.stream.Stream<T> 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.of("input.file"),
									.i->"hello world")
									.toList();
		
		assertThat(result,equalTo(Arrays.asList('h','e','l','l','o',' ','w','o','r','l','d')));
 
 

Parameters:

fn -

Returns:

liftAndBindFile

public static final <T> java.util.stream.Stream<java.lang.String> liftAndBindFile(java.util.stream.Stream<T> 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.of("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:

liftAndBindURL

public static final <T> java.util.stream.Stream<java.lang.String> liftAndBindURL(java.util.stream.Stream<T> 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.of("input.file")
								,getClass().getClassLoader()::getResource)
								.collect(Collectors.toList();
		
		assertThat(result,equalTo(Arrays.asList("hello","world")));
 
 
 

Parameters:

fn -

Returns:

liftAndBindBufferedReader

public static final <T> java.util.stream.Stream<java.lang.String> liftAndBindBufferedReader(java.util.stream.Stream<T> 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.of("input.file")
                                                                .map(getClass().getClassLoader()::getResourceAsStream)
                                                                .map(InputStreamReader::new)
                                                                ,BufferedReader::new)
                                                                .collect(Collectors.toList();
                
                assertThat(result,equalTo(Arrays.asList("hello","world")));
 
 

Parameters:

fn -

Returns:

toLazyCollection

public static final <A> java.util.Collection<A> toLazyCollection(java.util.stream.Stream<A> 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.

toLazyCollection

public static final <A> java.util.Collection<A> toLazyCollection(java.util.Iterator<A> iterator)

toConcurrentLazyCollection

public static final <A> java.util.Collection<A> toConcurrentLazyCollection(java.util.stream.Stream<A> stream)

Lazily constructs a Collection from specified Stream. Collections iterator may be safely used concurrently by multiple threads.

Parameters:

stream -

Returns:

toConcurrentLazyCollection

public static final <A> java.util.Collection<A> toConcurrentLazyCollection(java.util.Iterator<A> iterator)

toBufferingDuplicator

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

toBufferingDuplicator

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

toBufferingCopier

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