com.jn.langx.util.collection

类 Pipeline<E>

java.lang.Object

com.jn.langx.util.collection.Pipeline<E>

public class Pipeline<E>
extends Object

作者:

jinuo.fang

构造器概要

构造器

构造器和说明
Pipeline(C collection)

方法概要

限定符和类型	方法和说明
Pipeline<E>	add(E e)
<C extends Collection<E>> Pipeline<E>	addAll(C collection)
<C extends Collection<E>> void	addTo(C collection)
boolean	allMatch(Predicate<E> predicate)
boolean	anyMatch(Predicate<E> predicate)
List<E>	asList()
Double	average()
Pipeline<E>	clearNulls()
<R> R	collect(Collector<E,R> collector)
<C extends Collection<E>> Pipeline<E>	concat(C another)
Pipeline<E>	concat(Pipeline<E> another)
int	count()
Pipeline<E>	distinct()
Pipeline<E>	filter(Predicate<E> predicate)
E	findFirst()
E	findFirst(Predicate<E> predicate)
<I,O> Pipeline<O>	flatMap(Function<I,O> mapper)
void	forEach(Consumer<E> consumer)
void	forEach(Consumer<E> consumer, Predicate<E> breakPredicate)
void	forEach(Consumer2<Integer,E> consumer, Predicate2<Integer,E> breakPredicate)
Collection<E>	getAll()
<K> Map<K,List<E>>	groupBy(Function<E,K> classifier, Supplier0<Map<K,List<E>>> mapFactory)
Iterator<E>	iterator()
Pipeline<E>	limit(int maxSize)
Pipeline<E>	listized()
<O> Pipeline<O>	map(Function<E,O> mapper)
E	max(Comparator<E> comparator)
E	min(Comparator<E> comparator)
boolean	noneMatch(Predicate<E> predicate)
static <T> Pipeline<T>	of(Iterable<T> iterable)
static <T> Pipeline<T>	of(Object anyObject)
static <T> Pipeline<T>	of(T... array)
E	reduce(Operator2<E> operator)
Pipeline	skip(int n)
Pipeline<E>	sorted(Comparator<E> comparator)
Double	sum()
Object[]	toArray()
E[]	toArray(Class<E[]> clazz)

从类继承的方法 java.lang.Object

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

构造器详细资料

Pipeline

public Pipeline(C collection)

方法详细资料

map

public <O> Pipeline<O> map(Function<E,O> mapper)

flatMap

public <I,O> Pipeline<O> flatMap(Function<I,O> mapper)

filter

public Pipeline<E> filter(Predicate<E> predicate)

limit

public Pipeline<E> limit(int maxSize)

skip

public Pipeline skip(int n)

sorted

public Pipeline<E> sorted(@NonNull
                          Comparator<E> comparator)

distinct

public Pipeline<E> distinct()

forEach

public void forEach(@NonNull
                    Consumer<E> consumer)

forEach

public void forEach(@NonNull
                    Consumer<E> consumer,
                    @Nullable
                    Predicate<E> breakPredicate)

forEach

public void forEach(@NonNull
                    Consumer2<Integer,E> consumer,
                    @Nullable
                    Predicate2<Integer,E> breakPredicate)

anyMatch

public boolean anyMatch(@NonNull
                        Predicate<E> predicate)

allMatch

public boolean allMatch(@NonNull
                        Predicate<E> predicate)

noneMatch

public boolean noneMatch(@NonNull
                         Predicate<E> predicate)

findFirst

public E findFirst()

findFirst

public E findFirst(@NonNull
                   Predicate<E> predicate)

clearNulls

public Pipeline<E> clearNulls()

count

public int count()

toArray

public Object[] toArray()

toArray

public E[] toArray(Class<E[]> clazz)

iterator

public Iterator<E> iterator()

getAll

public Collection<E> getAll()

sum

public Double sum()

average

public Double average()

max

public E max(Comparator<E> comparator)

min

public E min(Comparator<E> comparator)

reduce

public E reduce(Operator2<E> operator)

groupBy

public <K> Map<K,List<E>> groupBy(Function<E,K> classifier,
                                  Supplier0<Map<K,List<E>>> mapFactory)

collect

public <R> R collect(Collector<E,R> collector)

concat

public Pipeline<E> concat(Pipeline<E> another)

concat

public <C extends Collection<E>> Pipeline<E> concat(C another)

listized

public Pipeline<E> listized()

addTo

public <C extends Collection<E>> void addTo(C collection)

add

public Pipeline<E> add(E e)

addAll

public <C extends Collection<E>> Pipeline<E> addAll(C collection)

asList

public List<E> asList()

of

public static <T> Pipeline<T> of(Object anyObject)

of

public static <T> Pipeline<T> of(Iterable<T> iterable)

of

public static <T> Pipeline<T> of(T... array)