com.aol.cyclops.sequence

Class SeqUtils

java.lang.Object

com.aol.cyclops.sequence.SeqUtils

public class SeqUtils
extends java.lang.Object

Constructor Summary

Constructors

Constructor and Description
SeqUtils()

Method Summary

Modifier and Type	Method and Description
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 <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 <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.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

SeqUtils

public SeqUtils()

Method Detail

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(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

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)