| Package | Description |
|---|---|
| com.landawn.abacus | |
| com.landawn.abacus.android.util | |
| com.landawn.abacus.util | |
| com.landawn.abacus.util.function | |
| com.landawn.abacus.util.stream |
| Modifier and Type | Method and Description |
|---|---|
<R> R |
DataSet.forEach(java.util.Collection<java.lang.String> columnNames,
int fromRowIndex,
int toRowIndex,
R seed,
BiFunction<R,? super java.lang.Object[],R> accumulator,
BiPredicate<? super R,? super java.lang.Object[]> conditionToBreak) |
<R> R |
DataSet.forEach(java.util.Collection<java.lang.String> columnNames,
int fromRowIndex,
int toRowIndex,
R seed,
BiFunction<R,? super java.lang.Object[],R> accumulator,
BiPredicate<? super R,? super java.lang.Object[]> conditionToBreak,
boolean shareRowArray)
Execute
accumulator on each element till true is returned by conditionToBreak |
<R> R |
DataSet.forEach(java.util.Collection<java.lang.String> columnNames,
R seed,
BiFunction<R,? super java.lang.Object[],R> accumulator,
BiPredicate<? super R,? super java.lang.Object[]> conditionToBreak) |
<R> R |
DataSet.forEach(java.util.Collection<java.lang.String> columnNames,
R seed,
BiFunction<R,? super java.lang.Object[],R> accumulator,
BiPredicate<? super R,? super java.lang.Object[]> conditionToBreak,
boolean shareRowArray)
Execute
accumulator on each element till true is returned by conditionToBreak |
<R> R |
DataSet.forEach(int fromRowIndex,
int toRowIndex,
R seed,
BiFunction<R,? super java.lang.Object[],R> accumulator,
BiPredicate<? super R,? super java.lang.Object[]> conditionToBreak) |
<R> R |
DataSet.forEach(int fromRowIndex,
int toRowIndex,
R seed,
BiFunction<R,? super java.lang.Object[],R> accumulator,
BiPredicate<? super R,? super java.lang.Object[]> conditionToBreak,
boolean shareRowArray) |
<R> R |
DataSet.forEach(R seed,
BiFunction<R,? super java.lang.Object[],R> accumulator,
BiPredicate<? super R,? super java.lang.Object[]> conditionToBreak) |
<R> R |
DataSet.forEach(R seed,
BiFunction<R,? super java.lang.Object[],R> accumulator,
BiPredicate<? super R,? super java.lang.Object[]> conditionToBreak,
boolean shareRowArray) |
| Modifier and Type | Method and Description |
|---|---|
<U,R> CompletableFuture<R> |
CompletableFuture.callAfterBoth(CompletableFuture<U> other,
BiFunction<T,U,R> action) |
<R> CompletableFuture<R> |
CompletableFuture.callAfterEither(CompletableFuture<? extends T> other,
BiFunction<? super T,java.lang.Exception,R> action) |
<U,R> CompletableFuture<R> |
CompletableFuture.callByTPAfterBoth(CompletableFuture<U> other,
BiFunction<T,U,R> action) |
<U,R> CompletableFuture<R> |
CompletableFuture.callByTPAfterEither(CompletableFuture<? extends T> other,
BiFunction<? super T,java.lang.Exception,R> action) |
<U,R> CompletableFuture<R> |
CompletableFuture.callOnUIAfterBoth(CompletableFuture<U> other,
BiFunction<T,U,R> action) |
<U,R> CompletableFuture<R> |
CompletableFuture.callOnUIAfterEither(CompletableFuture<? extends T> other,
BiFunction<? super T,java.lang.Exception,R> action) |
static <T1,T2,R> CompletableFuture<R> |
Futures.combine(CompletableFuture<? extends T1> cf1,
CompletableFuture<? extends T2> cf2,
BiFunction<? super T1,? super T2,? extends R> action) |
<U> U |
CompletableFuture.get(BiFunction<? super T,java.lang.Exception,? extends U> action) |
<U> U |
CompletableFuture.get(long timeout,
java.util.concurrent.TimeUnit unit,
BiFunction<? super T,java.lang.Exception,? extends U> action) |
<R> CompletableFuture<R> |
CompletableFuture.thenCall(BiFunction<? super T,java.lang.Exception,R> action) |
<R> CompletableFuture<R> |
CompletableFuture.thenCallByTP(BiFunction<? super T,java.lang.Exception,R> action) |
<R> CompletableFuture<R> |
CompletableFuture.thenCallOnUI(BiFunction<? super T,java.lang.Exception,R> action) |
| Modifier and Type | Method and Description |
|---|---|
static <K,V> BiFunction<K,V,java.util.Map.Entry<K,V>> |
Fn.entry() |
static <U,T,R> BiFunction<U,T,R> |
Fn.BiFunctions.indexed(IndexedBiFunction<U,T,R> func) |
static <U,T,R> BiFunction<U,T,R> |
Fn.indexeD(IndexedBiFunction<U,T,R> func)
Returns a stateful
BiFunction which should not be used in parallel stream. |
static <T,U,R> BiFunction<T,U,Optional<R>> |
Fn.BiFunctions.of(BiConsumer<? super T,? super U> action)
Returns a
BiFunction which calls the specified action and always return an emptyOptional if action is executed successfully. |
static <T,C extends java.util.Collection<? super T>> |
Fn.BiFunctions.ofAdd() |
static <T,C extends java.util.Collection<T>> |
Fn.BiFunctions.ofAddAll() |
static <T extends PrimitiveList> |
Fn.BiFunctions.ofAddAll2() |
static <T> BiFunction<java.lang.StringBuilder,T,java.lang.StringBuilder> |
Fn.BiFunctions.ofAppend() |
static BiFunction<Joiner,Joiner,Joiner> |
Fn.BiFunctions.ofMerge() |
static <K,V,M extends java.util.Map<K,V>,E extends java.util.Map.Entry<K,V>> |
Fn.BiFunctions.ofPut() |
static <K,V,M extends java.util.Map<K,V>> |
Fn.BiFunctions.ofPutAll() |
static <T,C extends java.util.Collection<? super T>> |
Fn.BiFunctions.ofRemove() |
static <T,C extends java.util.Collection<T>> |
Fn.BiFunctions.ofRemoveAll() |
static <T extends PrimitiveList> |
Fn.BiFunctions.ofRemoveAll2() |
static <K,V,M extends java.util.Map<K,V>,U> |
Fn.BiFunctions.ofRemoveByKey() |
static <T,U> BiFunction<T,U,Tuple.Tuple2<T,U>> |
Fn.BiFunctions.ofTuple() |
static <K,V> BiFunction<K,V,Pair<K,V>> |
Fn.pair() |
static <T,U> BiFunction<T,U,T> |
Fn.BiFunctions.returnFirst() |
static <T,U> BiFunction<T,U,U> |
Fn.BiFunctions.returnSecond() |
| Modifier and Type | Method and Description |
|---|---|
static <K,V,R> Function<java.util.Map.Entry<K,V>,R> |
Fn.applyKeyVal(BiFunction<? super K,? super V,R> func) |
<U,R> CompletableFuture<R> |
CompletableFuture.callAfterBoth(CompletableFuture<U> other,
BiFunction<T,U,R> action) |
<R> CompletableFuture<R> |
CompletableFuture.callAfterEither(CompletableFuture<? extends T> other,
BiFunction<? super T,java.lang.Exception,R> action) |
java.util.List<T> |
Seq.collapse(BiPredicate<? super T,? super T> collapsible,
BiFunction<? super T,? super T,T> mergeFunction)
Merge series of adjacent elements which satisfy the given predicate using
the merger function and return a new stream.
|
static <T1,T2,R> CompletableFuture<R> |
Futures.combine(CompletableFuture<? extends T1> cf1,
CompletableFuture<? extends T2> cf2,
BiFunction<? super T1,? super T2,? extends R> action) |
int |
Multiset.compute(E key,
BiFunction<? super E,java.lang.Integer,java.lang.Integer> remappingFunction)
The implementation is equivalent to performing the following steps for this Multiset:
|
long |
LongMultiset.compute(E key,
BiFunction<? super E,java.lang.Long,java.lang.Long> remappingFunction)
The implementation is equivalent to performing the following steps for this LongMultiset:
|
V |
Multimap.compute(K key,
BiFunction<? super K,? super V,? extends V> remappingFunction)
The implementation is equivalent to performing the following steps for this Multimap:
|
static <K,V> V |
Maps.compute(java.util.Map<K,V> map,
K key,
BiFunction<? super K,? super V,? extends V> remappingFunction)
Attempts to compute a mapping for the specified key and its current
mapped value (or
null if there is no current mapping). |
int |
Multiset.computeIfPresent(E e,
BiFunction<? super E,java.lang.Integer,java.lang.Integer> remappingFunction)
The implementation is equivalent to performing the following steps for this Multiset:
|
long |
LongMultiset.computeIfPresent(E e,
BiFunction<? super E,java.lang.Long,java.lang.Long> remappingFunction)
The implementation is equivalent to performing the following steps for this LongMultiset:
|
V |
Multimap.computeIfPresent(K key,
BiFunction<? super K,? super V,? extends V> remappingFunction)
The implementation is equivalent to performing the following steps for this Multimap:
|
static <K,V> V |
Maps.computeIfPresent(java.util.Map<K,V> map,
K key,
BiFunction<? super K,? super V,? extends V> remappingFunction)
If the value for the specified key is present and non-null, attempts to
compute a new mapping given the key and its current mapped value.
|
<U,R> java.util.List<R> |
Seq.flatMap(Function<? super T,? extends java.util.Collection<U>> mapper,
BiFunction<? super T,? super U,? extends R> func) |
static <T,C extends java.util.Collection<? extends T>,R> |
N.forEach(C c,
int fromIndex,
int toIndex,
R seed,
BiFunction<R,? super T,R> accumulator,
BiPredicate<? super R,? super T> conditionToBreak)
Execute
accumulator on each element till true is returned by conditionToBreak |
static <T,C extends java.util.Collection<? extends T>,R> |
N.forEach(C c,
R seed,
BiFunction<R,? super T,R> accumulator,
BiPredicate<? super R,? super T> conditionToBreak) |
<R> R |
Seq.forEach(R seed,
BiFunction<R,? super T,R> accumulator,
BiPredicate<? super R,? super T> conditionToBreak) |
static <T,R> R |
N.forEach(T[] a,
int fromIndex,
int toIndex,
R seed,
BiFunction<R,? super T,R> accumulator,
BiPredicate<? super R,? super T> conditionToBreak)
Execute
accumulator on each element till true is returned by conditionToBreak |
static <T,R> R |
N.forEach(T[] a,
R seed,
BiFunction<R,? super T,R> accumulator,
BiPredicate<? super R,? super T> conditionToBreak) |
<U> U |
CompletableFuture.get(BiFunction<? super T,java.lang.Exception,? extends U> action) |
<U> U |
CompletableFuture.get(long timeout,
java.util.concurrent.TimeUnit unit,
BiFunction<? super T,java.lang.Exception,? extends U> action) |
<U> U |
Pair.map(BiFunction<? super L,? super R,U> mapper) |
java.util.List<T> |
Seq.merge(java.util.Collection<? extends T> b,
BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector) |
static <T> java.util.List<T> |
Seq.merge(java.util.Collection<? extends T> a,
java.util.Collection<? extends T> b,
BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector) |
int |
Multiset.merge(E key,
int value,
BiFunction<java.lang.Integer,java.lang.Integer,java.lang.Integer> remappingFunction)
The implementation is equivalent to performing the following steps for this Multiset:
|
long |
LongMultiset.merge(E key,
long value,
BiFunction<java.lang.Long,java.lang.Long,java.lang.Long> remappingFunction)
The implementation is equivalent to performing the following steps for this LongMultiset:
|
static <T> ObjIterator<T> |
Iterators.merge(java.util.Iterator<? extends T> a,
java.util.Iterator<? extends T> b,
BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector) |
V |
Multimap.merge(K key,
E e,
BiFunction<? super V,? super E,? extends V> remappingFunction)
The implementation is equivalent to performing the following steps for this Multimap:
|
V |
Multimap.merge(K key,
V value,
BiFunction<? super V,? super V,? extends V> remappingFunction)
The implementation is equivalent to performing the following steps for this Multimap:
|
static <K,V> V |
Maps.merge(java.util.Map<K,V> map,
K key,
V value,
BiFunction<? super V,? super V,? extends V> remappingFunction)
If the specified key is not already associated with a value or is
associated with null, associates it with the given non-null value.
|
Sheet<R,C,E> |
Sheet.merge(Sheet<? extends R,? extends C,? extends E> source,
BiFunction<? super E,? super E,E> mergeFunction) |
static <T> java.util.List<T> |
Seq.merge(T[] a,
T[] b,
BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector) |
static <T,U> BiConsumer<T,U> |
Fn.BiConsumers.of(BiFunction<? super T,? super U,?> func)
Returns a
BiConsumer which calls the specified func. |
static <T,U,R> Function<T,R> |
Fn.Functions.of(U u,
BiFunction<? super T,? super U,R> func) |
<U> U |
Seq.reduce(U identity,
BiFunction<U,? super T,U> accumulator)
This is equivalent to:
|
void |
Multiset.replaceAll(BiFunction<? super E,? super java.lang.Integer,java.lang.Integer> function)
The associated elements will be removed if zero or negative occurrences are returned by the specified
function. |
void |
LongMultiset.replaceAll(BiFunction<? super E,? super java.lang.Long,java.lang.Long> function)
The associated elements will be removed if zero or negative occurrences are returned by the specified
function. |
void |
Multimap.replaceAll(BiFunction<? super K,? super V,? extends V> function)
The associated keys will be removed if null or empty values are returned by the specified
function. |
static <K,V> void |
Maps.replaceAll(java.util.Map<K,V> map,
BiFunction<? super K,? super V,? extends V> function)
Replaces each entry's value with the result of invoking the given
function on that entry until all entries have been processed or the
function throws an exception.
|
java.util.List<T> |
Seq.scan(BiFunction<? super T,? super T,T> accumulator)
Returns a
Stream produced by iterative application of a accumulation function
to an initial element identity and next element of the current stream. |
<R> java.util.List<R> |
Seq.scan(R seed,
BiFunction<? super R,? super T,R> accumulator)
Returns a
Stream produced by iterative application of a accumulation function
to an initial element identity and next element of the current stream. |
<R> CompletableFuture<R> |
CompletableFuture.thenCall(BiFunction<? super T,java.lang.Exception,R> action) |
static <A,B,R> java.util.List<R> |
Seq.zip(A[] a,
B[] b,
A valueForNoneA,
B valueForNoneB,
BiFunction<? super A,? super B,R> zipFunction) |
static <A,B,R> java.util.List<R> |
Seq.zip(A[] a,
B[] b,
BiFunction<? super A,? super B,R> zipFunction) |
static <A,B,R> R[][][] |
f.zip(java.lang.Class<R> cls,
A[][][] a,
B[][][] b,
A valueForNoneA,
B valueForNoneB,
BiFunction<? super A,? super B,R> zipFunction) |
static <A,B,R> R[][][] |
f.zip(java.lang.Class<R> cls,
A[][][] a,
B[][][] b,
BiFunction<? super A,? super B,R> zipFunction) |
static <A,B,R> R[][] |
f.zip(java.lang.Class<R> cls,
A[][] a,
B[][] b,
A valueForNoneA,
B valueForNoneB,
BiFunction<? super A,? super B,R> zipFunction) |
static <A,B,R> R[][] |
f.zip(java.lang.Class<R> cls,
A[][] a,
B[][] b,
BiFunction<? super A,? super B,R> zipFunction) |
static <A,B,R> R[] |
f.zip(java.lang.Class<R> cls,
A[] a,
B[] b,
A valueForNoneA,
B valueForNoneB,
BiFunction<? super A,? super B,R> zipFunction) |
static <A,B,R> R[] |
f.zip(java.lang.Class<R> cls,
A[] a,
B[] b,
BiFunction<? super A,? super B,R> zipFunction) |
static <A,B,R> java.util.List<R> |
Seq.zip(java.util.Collection<A> a,
java.util.Collection<B> b,
A valueForNoneA,
B valueForNoneB,
BiFunction<? super A,? super B,R> zipFunction) |
static <A,B,R> java.util.List<R> |
Seq.zip(java.util.Collection<A> a,
java.util.Collection<B> b,
BiFunction<? super A,? super B,R> zipFunction) |
static <A,B,R> ObjIterator<R> |
Iterators.zip(java.util.Iterator<A> a,
java.util.Iterator<B> b,
A valueForNoneA,
B valueForNoneB,
BiFunction<? super A,? super B,R> zipFunction) |
static <A,B,R> ObjIterator<R> |
Iterators.zip(java.util.Iterator<A> a,
java.util.Iterator<B> b,
BiFunction<? super A,? super B,R> zipFunction) |
static <A,B> A[][][] |
f.zip2(A[][][] a,
B[][][] b,
A valueForNoneA,
B valueForNoneB,
BiFunction<? super A,? super B,A> zipFunction) |
static <A,B> A[][][] |
f.zip2(A[][][] a,
B[][][] b,
BiFunction<? super A,? super B,A> zipFunction) |
static <A,B> A[][] |
f.zip2(A[][] a,
B[][] b,
A valueForNoneA,
B valueForNoneB,
BiFunction<? super A,? super B,A> zipFunction) |
static <A,B> A[][] |
f.zip2(A[][] a,
B[][] b,
BiFunction<? super A,? super B,A> zipFunction) |
static <A,B> A[] |
f.zip2(A[] a,
B[] b,
A valueForNoneA,
B valueForNoneB,
BiFunction<? super A,? super B,A> zipFunction) |
static <A,B> A[] |
f.zip2(A[] a,
B[] b,
BiFunction<? super A,? super B,A> zipFunction) |
<B,R> Matrix<R> |
Matrix.zipWith(java.lang.Class<R> cls,
Matrix<B> matrixB,
BiFunction<? super T,? super B,R> zipFunction) |
<B,R> java.util.List<R> |
Seq.zipWith(java.util.Collection<B> b,
BiFunction<? super T,? super B,R> zipFunction) |
<B,R> java.util.List<R> |
Seq.zipWith(java.util.Collection<B> b,
T valueForNoneA,
B valueForNoneB,
BiFunction<? super T,? super B,R> zipFunction) |
<B> Matrix<T> |
Matrix.zipWith(Matrix<B> matrixB,
BiFunction<? super T,? super B,T> zipFunction) |
| Modifier and Type | Interface and Description |
|---|---|
interface |
BinaryOperator<T>
Refer to JDK API documentation at: https://docs.oracle.com/javase/8/docs/api/java/util/function/package-summary.html
|
| Modifier and Type | Method and Description |
|---|---|
static <T,R extends java.util.Collection<? super T>> |
BiFunction.ofAdd() |
static <T,C extends java.util.Collection<T>> |
BiFunction.ofAddAll() |
static <K,V,M extends java.util.Map<K,V>> |
BiFunction.ofPutAll() |
static <T,R extends java.util.Collection<? super T>> |
BiFunction.ofRemove() |
static <T,C extends java.util.Collection<T>> |
BiFunction.ofRemoveAll() |
| Modifier and Type | Method and Description |
|---|---|
abstract <R> Stream<R> |
Stream.biMap(BiFunction<? super T,? super T,? extends R> mapper) |
abstract <R> Stream<R> |
Stream.biMap(BiFunction<? super T,? super T,? extends R> mapper,
boolean ignoreNotPaired)
Returns a stream consisting of the results of applying the given function
to the every two adjacent elements of this stream.
|
abstract Stream<T> |
Stream.collapse(BiPredicate<? super T,? super T> collapsible,
BiFunction<? super T,? super T,T> mergeFunction)
Merge series of adjacent elements which satisfy the given predicate using
the merger function and return a new stream.
|
Stream<java.util.Map.Entry<K,V>> |
EntryStream.collapseByKey(BiPredicate<? super K,? super K> collapsible,
BiFunction<? super java.util.Map.Entry<K,V>,? super java.util.Map.Entry<K,V>,java.util.Map.Entry<K,V>> mergeFunction) |
abstract <U,R> Stream<R> |
Stream.flatArray(U seed,
BiFunction<? super T,? super U,R[]> mapper) |
abstract <U,R> Stream<R> |
Stream.flatCollection(U seed,
BiFunction<? super T,? super U,? extends java.util.Collection<? extends R>> mapper) |
abstract <U,R> Stream<R> |
Stream.flatMap(U seed,
BiFunction<? super T,? super U,? extends Stream<? extends R>> mapper) |
abstract <R> R |
Stream.forEach(R seed,
BiFunction<R,? super T,R> accumulator,
BiPredicate<? super R,? super T> conditionToBreak)
Execute
accumulator on each element till true is returned by conditionToBreak
This method only run sequentially, even in parallel stream. |
<KK,VV> EntryStream<KK,VV> |
EntryStream.map(BiFunction<? super K,? super V,java.util.Map.Entry<KK,VV>> mapper) |
abstract <U,R> Stream<R> |
Stream.map(U seed,
BiFunction<? super T,? super U,? extends R> mapper) |
static <T> Stream<T> |
Stream.merge(java.util.Collection<? extends Stream<? extends T>> c,
BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector) |
static <T> Stream<T> |
Stream.merge(java.util.Collection<? extends T> a,
java.util.Collection<? extends T> b,
BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector) |
static <T> Stream<T> |
Stream.merge(java.util.Collection<? extends T> a,
java.util.Collection<? extends T> b,
java.util.Collection<? extends T> c,
BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector) |
static <T> Stream<T> |
Stream.merge(java.util.Iterator<? extends T> a,
java.util.Iterator<? extends T> b,
BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector) |
static <T> Stream<T> |
Stream.merge(java.util.Iterator<? extends T> a,
java.util.Iterator<? extends T> b,
java.util.Iterator<? extends T> c,
BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector) |
abstract Stream<T> |
Stream.merge(Stream<? extends T> b,
BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector) |
static <T> Stream<T> |
Stream.merge(Stream<? extends T> a,
Stream<? extends T> b,
BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector) |
static <T> Stream<T> |
Stream.merge(Stream<? extends T> a,
Stream<? extends T> b,
Stream<? extends T> c,
BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector) |
static <T> Stream<T> |
Stream.merge(T[] a,
T[] b,
BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector) |
static <T> Stream<T> |
Stream.merge(T[] a,
T[] b,
T[] c,
BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector) |
static <T> Stream<T> |
Stream.merge2(java.util.Collection<? extends java.util.Iterator<? extends T>> c,
BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector) |
static <T,R> Collector<T,?,R> |
Collectors.minMax(java.util.Comparator<? super T> comparator,
BiFunction<? super Nullable<T>,? super Nullable<T>,? extends R> finisher)
It's copied from StreamEx: https://github.com/amaembo/streamex
Returns a Collector which finds the minimal and maximal element
according to the supplied comparator, then applies finisher function to
them producing the final result. |
static <T,A1,A2,R1,R2,R> |
Collectors.pairing(Collector<? super T,A1,R1> c1,
Collector<? super T,A2,R2> c2,
BiFunction<? super R1,? super R2,? extends R> finisher)
It's copied from StreamEx: https://github.com/amaembo/streamex
Returns a Collector which aggregates the results of two supplied
collectors using the supplied finisher function. |
static <T> Stream<T> |
Stream.parallelMerge(java.util.Collection<? extends Stream<? extends T>> c,
BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector) |
static <T> Stream<T> |
Stream.parallelMerge(java.util.Collection<? extends Stream<? extends T>> c,
BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector,
int maxThreadNum) |
static <T> Stream<T> |
Stream.parallelMerge2(java.util.Collection<? extends java.util.Iterator<? extends T>> c,
BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector) |
static <T> Stream<T> |
Stream.parallelMerge2(java.util.Collection<? extends java.util.Iterator<? extends T>> c,
BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector,
int maxThreadNum) |
static <A,B,R> Stream<R> |
Stream.parallelZip(java.util.Iterator<? extends A> a,
java.util.Iterator<? extends B> b,
A valueForNoneA,
B valueForNoneB,
BiFunction<? super A,? super B,R> zipFunction)
Put the stream in try-catch to stop the back-end reading thread if error happens
try (Stream |
static <A,B,R> Stream<R> |
Stream.parallelZip(java.util.Iterator<? extends A> a,
java.util.Iterator<? extends B> b,
A valueForNoneA,
B valueForNoneB,
BiFunction<? super A,? super B,R> zipFunction,
int queueSize)
Put the stream in try-catch to stop the back-end reading thread if error happens
try (Stream |
static <A,B,R> Stream<R> |
Stream.parallelZip(java.util.Iterator<? extends A> a,
java.util.Iterator<? extends B> b,
BiFunction<? super A,? super B,R> zipFunction)
Put the stream in try-catch to stop the back-end reading thread if error happens
try (Stream |
static <A,B,R> Stream<R> |
Stream.parallelZip(java.util.Iterator<? extends A> a,
java.util.Iterator<? extends B> b,
BiFunction<? super A,? super B,R> zipFunction,
int queueSize)
Put the stream in try-catch to stop the back-end reading thread if error happens
try (Stream |
static <A,B,R> Stream<R> |
Stream.parallelZip(Stream<A> a,
Stream<B> b,
A valueForNoneA,
B valueForNoneB,
BiFunction<? super A,? super B,R> zipFunction)
Put the stream in try-catch to stop the back-end reading thread if error happens
try (Stream |
static <A,B,R> Stream<R> |
Stream.parallelZip(Stream<A> a,
Stream<B> b,
A valueForNoneA,
B valueForNoneB,
BiFunction<? super A,? super B,R> zipFunction,
int queueSize)
Put the stream in try-catch to stop the back-end reading thread if error happens
try (Stream |
static <A,B,R> Stream<R> |
Stream.parallelZip(Stream<A> a,
Stream<B> b,
BiFunction<? super A,? super B,R> zipFunction)
Put the stream in try-catch to stop the back-end reading thread if error happens
try (Stream |
static <A,B,R> Stream<R> |
Stream.parallelZip(Stream<A> a,
Stream<B> b,
BiFunction<? super A,? super B,R> zipFunction,
int queueSize)
Put the stream in try-catch to stop the back-end reading thread if error happens
try (Stream |
abstract <U> Stream<U> |
Stream.rangeMap(BiPredicate<? super T,? super T> sameRange,
BiFunction<? super T,? super T,? extends U> mapper)
Note: copied from StreamEx: https://github.com/amaembo/streamex
Returns a stream consisting of results of applying the given function to the ranges created from the source elements. |
<U> U |
EntryStream.reduce(U identity,
BiFunction<U,? super java.util.Map.Entry<K,V>,U> accumulator) |
<U> U |
EntryStream.reduce(U identity,
BiFunction<U,? super java.util.Map.Entry<K,V>,U> accumulator,
BinaryOperator<U> combiner) |
abstract <U> U |
Stream.reduce(U identity,
BiFunction<U,? super T,U> accumulator)
The result will be merged by:
a.addAll(b) if result container is Collection/Multiset/LongMultiset/IntList/CharList/...,
or a.putAll(b) if result container is Map/Multimap/Sheet,
or a.append(b) if result container is StringBuilder,
or N.concat(a, b) if result container is array: boolean[]/char[]/int[]/.../Object[] when it's necessary in Parallel Stream. |
abstract <U> U |
Stream.reduce(U identity,
BiFunction<U,? super T,U> accumulator,
BinaryOperator<U> combiner)
Performs a reduction on the
elements of this stream, using the provided identity, accumulation and
combining functions.
|
abstract Stream<T> |
Stream.scan(BiFunction<? super T,? super T,T> accumulator)
Returns a
Stream produced by iterative application of a accumulation function
to an initial element seed and next element of the current stream. |
abstract <R> Stream<R> |
Stream.scan(R seed,
BiFunction<? super R,? super T,R> accumulator)
Returns a
Stream produced by iterative application of a accumulation function
to an initial element seed and next element of the current stream. |
abstract <R> Stream<R> |
Stream.slidingMap(BiFunction<? super T,? super T,R> mapper) |
abstract <R> Stream<R> |
Stream.slidingMap(BiFunction<? super T,? super T,R> mapper,
int increment)
Slide with
windowSize = 2 and the specified increment, then map by the specified mapper. |
static <A,B,R> Stream<R> |
Stream.zip(A[] a,
B[] b,
A valueForNoneA,
B valueForNoneB,
BiFunction<? super A,? super B,R> zipFunction)
Zip together the "a" and "b" iterators until all of them runs out of values.
|
static <A,B,R> Stream<R> |
Stream.zip(A[] a,
B[] b,
BiFunction<? super A,? super B,R> zipFunction)
Zip together the "a" and "b" arrays until one of them runs out of values.
|
static <A,B,R> Stream<R> |
Stream.zip(java.util.Collection<? extends A> a,
java.util.Collection<? extends B> b,
A valueForNoneA,
B valueForNoneB,
BiFunction<? super A,? super B,R> zipFunction)
Zip together the "a" and "b" iterators until all of them runs out of values.
|
static <A,B,R> Stream<R> |
Stream.zip(java.util.Collection<? extends A> a,
java.util.Collection<? extends B> b,
BiFunction<? super A,? super B,R> zipFunction)
Zip together the "a" and "b" arrays until one of them runs out of values.
|
static <A,B,R> Stream<R> |
Stream.zip(java.util.Iterator<? extends A> a,
java.util.Iterator<? extends B> b,
A valueForNoneA,
B valueForNoneB,
BiFunction<? super A,? super B,R> zipFunction)
Zip together the "a" and "b" iterators until all of them runs out of values.
|
static <A,B,R> Stream<R> |
Stream.zip(java.util.Iterator<? extends A> a,
java.util.Iterator<? extends B> b,
BiFunction<? super A,? super B,R> zipFunction)
Zip together the "a" and "b" iterators until one of them runs out of values.
|
static <A,B,R> Stream<R> |
Stream.zip(Stream<? extends A> a,
Stream<? extends B> b,
A valueForNoneA,
B valueForNoneB,
BiFunction<? super A,? super B,R> zipFunction)
Zip together the "a" and "b" iterators until all of them runs out of values.
|
static <A,B,R> Stream<R> |
Stream.zip(Stream<? extends A> a,
Stream<? extends B> b,
BiFunction<? super A,? super B,R> zipFunction)
Zip together the "a" and "b" streams until one of them runs out of values.
|
abstract <T2,R> Stream<R> |
Stream.zipWith(Stream<T2> b,
BiFunction<? super T,? super T2,R> zipFunction) |
abstract <T2,R> Stream<R> |
Stream.zipWith(Stream<T2> b,
T valueForNoneA,
T2 valueForNoneB,
BiFunction<? super T,? super T2,R> zipFunction) |