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()
Set<E>	asSet(boolean sequential)
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)
boolean	contains(E e)
int	count()
Pipeline<E>	distinct()
Pipeline<E>	filter(Predicate<E> predicate)
Pipeline<E>	filter(Predicate<E> predicate, Predicate<E> breakPredicate)
Pipeline<E>	filter(Predicate2<Integer,E> predicate)
Pipeline<E>	filter(Predicate2<Integer,E> predicate, Predicate2<Integer,E> breakPredicate)
E	findFirst()
E	findFirst(Predicate<E> predicate)
Pipeline<E>	findN(int n)
Pipeline<E>	findN(Predicate<E> predicate, int n)
<O> O	firstMap(Function2<Integer,E,O> mapper)
<O> O	firstMap(Function2<Integer,E,O> mapper, Predicate<O> breakPredicate)
<O> O	firstMap(Function2<Integer,E,O> mapper, Predicate2<E,O> breakPredicate)
<O> Pipeline<O>	flat()
<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)
void	forEach(Consumer2<Integer,E> consumer, Predicate2<Integer,E> breakPredicate)
void	forEach(Predicate<E> consumePredicate, Consumer<E> consumer)
void	forEach(Predicate<E> consumePredicate, Consumer<E> consumer, Predicate<E> breakPredicate)
void	forEach(Predicate2<Integer,E> consumePredicate, Consumer2<Integer,E> consumer)
void	forEach(Predicate2<Integer,E> consumePredicate, Consumer2<Integer,E> consumer, Predicate2<Integer,E> breakPredicate)
Collection<E>	getAll()
<K> Map<K,List<E>>	groupBy(Function<E,K> classifier)
<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)
<K> Pipeline<List<E>>	partitionBy(Function<E,K> classifier)
<K> Pipeline<List<E>>	partitionBy(Function2<Integer,E,K> classifier)
E	reduce(Operator2<E> operator)
Pipeline<E>	remove(E e)
Pipeline<E>	removeAll(Collection<E> removed)
Pipeline<E>	removeIf(Predicate<E> predicate)
Pipeline<E>	reverse()
Pipeline<E>	reverse(boolean newOne)
Pipeline<E>	shuffle()
Pipeline<E>	shuffle(Random random)
Pipeline<E>	skip(int n)
Pipeline<E>	sort(Comparator<E> comparator)
Pipeline<E>	sorted(Comparator<E> comparator)
Pipeline<E>	subPipeline(int offset, int limit)
Double	sum()
Pipeline<E>	swap(int i, int j)
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)

flat

public <O> Pipeline<O> flat()

flatMap

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

firstMap

public <O> O firstMap(@NonNull
                      Function2<Integer,E,O> mapper)

firstMap

public <O> O firstMap(@NonNull
                      Function2<Integer,E,O> mapper,
                      Predicate<O> breakPredicate)

firstMap

public <O> O firstMap(@NonNull
                      Function2<Integer,E,O> mapper,
                      Predicate2<E,O> breakPredicate)

filter

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

filter

public Pipeline<E> filter(Predicate<E> predicate,
                          @Nullable
                          Predicate<E> breakPredicate)

filter

public Pipeline<E> filter(Predicate2<Integer,E> predicate)

filter

public Pipeline<E> filter(Predicate2<Integer,E> predicate,
                          @Nullable
                          Predicate2<Integer,E> breakPredicate)

limit

public Pipeline<E> limit(int maxSize)

skip

public Pipeline<E> skip(int n)

partitionBy

public <K> Pipeline<List<E>> partitionBy(Function<E,K> classifier)

partitionBy

public <K> Pipeline<List<E>> partitionBy(Function2<Integer,E,K> classifier)

sorted

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

sort

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

distinct

public Pipeline<E> distinct()

forEach

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

forEach

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

forEach

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

forEach

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

forEach

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

forEach

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

forEach

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

forEach

public void forEach(@Nullable
                    Predicate2<Integer,E> consumePredicate,
                    @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)

findN

public Pipeline<E> findN(int n)

findN

public Pipeline<E> findN(@NonNull
                         Predicate<E> predicate,
                         int n)

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)

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)

contains

public boolean contains(E e)

subPipeline

public Pipeline<E> subPipeline(int offset,
                               int limit)

listized

public Pipeline<E> listized()

addTo

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

add

public Pipeline<E> add(E e)

addAll

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

remove

public Pipeline<E> remove(E e)

removeIf

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

从以下版本开始:

4.6.5

removeAll

public Pipeline<E> removeAll(Collection<E> removed)

从以下版本开始:

4.6.5

shuffle

public Pipeline<E> shuffle()

shuffle

public Pipeline<E> shuffle(Random random)

reverse

public Pipeline<E> reverse()

reverse

public Pipeline<E> reverse(boolean newOne)

swap

public Pipeline<E> swap(int i,
                        int j)

asSet

public Set<E> asSet(boolean sequential)

asList

public List<E> asList()

of

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

of

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

of

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