com.landawn.abacus.util.stream

Class CharStream

java.lang.Object

com.landawn.abacus.util.stream.CharStream

All Implemented Interfaces:

BaseStream<java.lang.Character,char[],CharPredicate,CharConsumer,CharList,u.OptionalChar,com.landawn.abacus.util.IndexedChar,CharIterator,CharStream>, java.lang.AutoCloseable

public abstract class CharStream
extends java.lang.Object

The Stream will be automatically closed after execution(A terminal method is executed/triggered).

See Also:

Stream

Nested Class Summary

Nested classes/interfaces inherited from interface com.landawn.abacus.util.stream.BaseStream

BaseStream.Splitor

Method Summary

Modifier and Type	Method and Description
<R> R	__(Function<? super CharStream,R> transfer)
abstract <E extends java.lang.Exception> boolean	allMatch(Try.CharPredicate<E> predicate)
abstract <E extends java.lang.Exception> boolean	anyMatch(Try.CharPredicate<E> predicate)
abstract IntStream	asIntStream() Returns a LongStream consisting of the elements of this stream, converted to long.
abstract u.OptionalDouble	average()
abstract Stream<java.lang.Character>	boxed() Returns a Stream consisting of the elements of this stream, each boxed to an Chareger.
S	carry(C action) Same as peek
void	close()
abstract Stream<CharList>	collapse(CharBiPredicate collapsible) Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.
abstract CharStream	collapse(CharBiPredicate collapsible, CharBinaryOperator mergeFunction) Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.
abstract <R> R	collect(Supplier<R> supplier, ObjCharConsumer<? super R> accumulator)
abstract <R> R	collect(Supplier<R> supplier, ObjCharConsumer<? super R> accumulator, BiConsumer<R,R> combiner) Performs a mutable reduction operation on the elements of this stream.
static CharStream	concat(char[]... a)
static CharStream	concat(CharIterator... a)
static CharStream	concat(CharStream... a)
static CharStream	concat(java.util.Collection<? extends CharStream> c)
static CharStream	empty()
abstract <E extends java.lang.Exception> u.OptionalChar	findAny(Try.CharPredicate<E> predicate)
abstract <E extends java.lang.Exception> u.OptionalChar	findFirst(Try.CharPredicate<E> predicate)
abstract <E extends java.lang.Exception,E2 extends java.lang.Exception> u.OptionalChar	findFirstOrLast(Try.CharPredicate<E> predicateForFirst, Try.CharPredicate<E> predicateForLast)
abstract <E extends java.lang.Exception> u.OptionalChar	findLast(Try.CharPredicate<E> predicate)
static CharStream	flat(char[][] a)
static CharStream	flat(char[][][] a)
static CharStream	flat(char[][] a, boolean vertically)
static CharStream	flat(char[][] a, char valueForNone, boolean vertically)
abstract CharStream	flatMap(CharFunction<? extends CharStream> mapper) Returns a stream consisting of the results of replacing each element of this stream with the contents of a mapped stream produced by applying the provided mapping function to each element.
abstract <T> Stream<T>	flatMappToObj(CharFunction<T[]> mapper)
abstract IntStream	flatMapToInt(CharFunction<? extends IntStream> mapper)
abstract <T> Stream<T>	flatMapToObj(CharFunction<? extends Stream<T>> mapper)
abstract CharStream	flattMap(CharFunction<char[]> mapper)
abstract <T> Stream<T>	flattMapToObj(CharFunction<? extends java.util.Collection<T>> mapper)
abstract <E extends java.lang.Exception> void	forEach(Try.CharConsumer<E> action)
static CharStream	generate(CharSupplier s)
boolean	isParallel()
static CharStream	iterate(BooleanSupplier hasNext, CharSupplier next)
static CharStream	iterate(char init, BooleanSupplier hasNext, CharUnaryOperator f)
static CharStream	iterate(char init, CharPredicate hasNext, CharUnaryOperator f)
static CharStream	iterate(char init, CharUnaryOperator f)
CharIterator	iterator() Remember to close this Stream after the iteration is done, if required.
java.lang.String	join(java.lang.CharSequence delimiter)
abstract u.OptionalChar	kthLargest(int k)
abstract CharStream	map(CharUnaryOperator mapper) Returns a stream consisting of the results of applying the given function to the elements of this stream.
abstract IntStream	mapToInt(CharToIntFunction mapper) Returns a IntStream consisting of the results of applying the given function to the elements of this stream.
abstract <U> Stream<U>	mapToObj(CharFunction<? extends U> mapper) Returns an object-valued Stream consisting of the results of applying the given function to the elements of this stream.
abstract u.OptionalChar	max() Returns an OptionalChar describing the maximum element of this stream, or an empty optional if this stream is empty.
static CharStream	merge(char[] a, char[] b, char[] c, CharBiFunction<com.landawn.abacus.util.Nth> nextSelector)
static CharStream	merge(char[] a, char[] b, CharBiFunction<com.landawn.abacus.util.Nth> nextSelector)
static CharStream	merge(CharIterator a, CharIterator b, CharBiFunction<com.landawn.abacus.util.Nth> nextSelector)
static CharStream	merge(CharIterator a, CharIterator b, CharIterator c, CharBiFunction<com.landawn.abacus.util.Nth> nextSelector)
abstract CharStream	merge(CharStream b, CharBiFunction<com.landawn.abacus.util.Nth> nextSelector)
static CharStream	merge(CharStream a, CharStream b, CharBiFunction<com.landawn.abacus.util.Nth> nextSelector)
static CharStream	merge(CharStream a, CharStream b, CharStream c, CharBiFunction<com.landawn.abacus.util.Nth> nextSelector)
static CharStream	merge(java.util.Collection<? extends CharStream> c, CharBiFunction<com.landawn.abacus.util.Nth> nextSelector)
abstract u.OptionalChar	min() Returns an OptionalChar describing the minimum element of this stream, or an empty optional if this stream is empty.
abstract <E extends java.lang.Exception> boolean	noneMatch(Try.CharPredicate<E> predicate)
static CharStream	of(char... a)
static CharStream	of(char[] a, int startIndex, int endIndex)
static CharStream	of(java.lang.Character[] a)
static CharStream	of(java.lang.Character[] a, int startIndex, int endIndex)
static CharStream	of(CharIterator iterator)
static CharStream	of(java.lang.CharSequence str) Takes the chars in the specified String as the elements of the Stream
static CharStream	of(java.lang.CharSequence str, int startIndex, int endIndex) Takes the chars in the specified String as the elements of the Stream
static CharStream	of(java.util.Collection<java.lang.Character> c)
static CharStream	of(Supplier<CharList> supplier) Lazy evaluation.
S	parallel()
S	parallel(BaseStream.Splitor splitor)
S	parallel(java.util.concurrent.Executor exector)
S	parallel(int maxThreadNum)
static CharStream	parallelMerge(java.util.Collection<? extends CharStream> c, CharBiFunction<com.landawn.abacus.util.Nth> nextSelector)
static CharStream	parallelMerge(java.util.Collection<? extends CharStream> c, CharBiFunction<com.landawn.abacus.util.Nth> nextSelector, int maxThreadNum)
void	println()
static CharStream	random()
static CharStream	random(char[] candicates)
static CharStream	random(char startInclusive, char endExclusive)
static CharStream	range(char startInclusive, char endExclusive)
static CharStream	range(char startInclusive, char endExclusive, int by)
static CharStream	rangeClosed(char startInclusive, char endInclusive)
static CharStream	rangeClosed(char startInclusive, char endInclusive, int by)
abstract CharStream	rangeMap(CharBiPredicate sameRange, CharBinaryOperator 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.
abstract <T> Stream<T>	rangeMapp(CharBiPredicate sameRange, CharBiFunction<T> 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.
abstract u.OptionalChar	reduce(CharBinaryOperator op) Performs a reduction on the elements of this stream, using an associative accumulation function, and returns an OptionalChar describing the reduced value, if any.
abstract char	reduce(char identity, CharBinaryOperator op) Performs a reduction on the elements of this stream, using the provided identity value and an associative accumulation function, and returns the reduced value.
static CharStream	repeat(char element, long n)
abstract CharStream	scan(CharBinaryOperator accumulator) Returns a Stream produced by iterative application of a accumulation function to an initial element init and next element of the current stream.
abstract CharStream	scan(char init, CharBinaryOperator accumulator) Returns a Stream produced by iterative application of a accumulation function to an initial element init and next element of the current stream.
abstract CharStream	scan(char init, CharBinaryOperator accumulator, boolean initIncluded)
S	sequential()
S	shuffled() This method only run sequentially, even in parallel stream and all elements will be loaded to memory.
S	slice(long from, long to) Same as: stream.skip(from).limit(to - from).
Stream<S>	sliding(int windowSize)
Stream<PL>	slidingToList(int windowSize)
abstract int	sum()
abstract com.landawn.abacus.util.CharSummaryStatistics	summarize()
abstract Pair<com.landawn.abacus.util.CharSummaryStatistics,u.Optional<java.util.Map<com.landawn.abacus.util.Percentage,java.lang.Character>>>	summarizeAndPercentiles()
abstract CharList	toCharList()
ImmutableList<T>	toImmutableList()
ImmutableSet<T>	toImmutableSet()
abstract <K,V> java.util.Map<K,V>	toMap(CharFunction<? extends K> keyMapper, CharFunction<? extends V> valueMapper)
abstract <K,V> java.util.Map<K,V>	toMap(CharFunction<? extends K> keyMapper, CharFunction<? extends V> valueMapper, BinaryOperator<V> mergeFunction)
abstract <K,V,M extends java.util.Map<K,V>> M	toMap(CharFunction<? extends K> keyMapper, CharFunction<? extends V> valueMapper, BinaryOperator<V> mergeFunction, Supplier<? extends M> mapFactory)
abstract <K,V,M extends java.util.Map<K,V>> M	toMap(CharFunction<? extends K> keyMapper, CharFunction<? extends V> valueMapper, Supplier<? extends M> mapFactory)
abstract <K,A,D> java.util.Map<K,D>	toMap(CharFunction<? extends K> keyMapper, Collector<java.lang.Character,A,D> downstream)
abstract <K,A,D,M extends java.util.Map<K,D>> M	toMap(CharFunction<? extends K> keyMapper, Collector<java.lang.Character,A,D> downstream, Supplier<? extends M> mapFactory)
abstract CharMatrix	toMatrix()
static CharStream	zip(char[] a, char[] b, char[] c, char valueForNoneA, char valueForNoneB, char valueForNoneC, CharTernaryOperator zipFunction) Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static CharStream	zip(char[] a, char[] b, char[] c, CharTernaryOperator zipFunction) Zip together the "a", "b" and "c" arrays until one of them runs out of values.
static CharStream	zip(char[] a, char[] b, CharBinaryOperator zipFunction) Zip together the "a" and "b" arrays until one of them runs out of values.
static CharStream	zip(char[] a, char[] b, char valueForNoneA, char valueForNoneB, CharBinaryOperator zipFunction) Zip together the "a" and "b" iterators until all of them runs out of values.
static CharStream	zip(CharIterator a, CharIterator b, CharBinaryOperator zipFunction) Zip together the "a" and "b" iterators until one of them runs out of values.
static CharStream	zip(CharIterator a, CharIterator b, char valueForNoneA, char valueForNoneB, CharBinaryOperator zipFunction) Zip together the "a" and "b" iterators until all of them runs out of values.
static CharStream	zip(CharIterator a, CharIterator b, CharIterator c, char valueForNoneA, char valueForNoneB, char valueForNoneC, CharTernaryOperator zipFunction) Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static CharStream	zip(CharIterator a, CharIterator b, CharIterator c, CharTernaryOperator zipFunction) Zip together the "a", "b" and "c" iterators until one of them runs out of values.
static CharStream	zip(CharStream a, CharStream b, CharBinaryOperator zipFunction) Zip together the "a" and "b" streams until one of them runs out of values.
static CharStream	zip(CharStream a, CharStream b, char valueForNoneA, char valueForNoneB, CharBinaryOperator zipFunction) Zip together the "a" and "b" iterators until all of them runs out of values.
static CharStream	zip(CharStream a, CharStream b, CharStream c, char valueForNoneA, char valueForNoneB, char valueForNoneC, CharTernaryOperator zipFunction) Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static CharStream	zip(CharStream a, CharStream b, CharStream c, CharTernaryOperator zipFunction) Zip together the "a", "b" and "c" streams until one of them runs out of values.
static CharStream	zip(java.util.Collection<? extends CharStream> c, char[] valuesForNone, CharNFunction<java.lang.Character> zipFunction) Zip together the iterators until all of them runs out of values.
static CharStream	zip(java.util.Collection<? extends CharStream> c, CharNFunction<java.lang.Character> zipFunction) Zip together the iterators until one of them runs out of values.
abstract CharStream	zipWith(CharStream b, CharBinaryOperator zipFunction)
abstract CharStream	zipWith(CharStream b, char valueForNoneA, char valueForNoneB, CharBinaryOperator zipFunction)
abstract CharStream	zipWith(CharStream b, CharStream c, char valueForNoneA, char valueForNoneB, char valueForNoneC, CharTernaryOperator zipFunction)
abstract CharStream	zipWith(CharStream b, CharStream c, CharTernaryOperator zipFunction)

Methods inherited from class java.lang.Object

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

Methods inherited from interface com.landawn.abacus.util.stream.BaseStream

append, appendIfEmpty, count, difference, distinct, dropWhile, dropWhile, filter, first, indexed, intersection, join, last, limit, onClose, onlyOne, parallel, parallel, peek, percentiles, prepend, removeIf, removeIf, reversed, reverseSorted, rotated, shuffled, skip, skip, sliding, slidingToList, sorted, split, split, splitAt, splitBy, splitToList, splitToList, step, symmetricDifference, takeWhile, toArray, toCollection, toList, toLongMultiset, toLongMultiset, toMultiset, toMultiset, toSet

Method Detail

map

public abstract CharStream map(CharUnaryOperator mapper)

Returns a stream consisting of the results of applying the given function to the elements of this stream.

This is an intermediate operation.

Parameters:

mapper - a non-interfering, stateless function to apply to each element

Returns:

the new stream

mapToInt

public abstract IntStream mapToInt(CharToIntFunction mapper)

Returns a IntStream consisting of the results of applying the given function to the elements of this stream.

This is an intermediate operation.

Parameters:

mapper - a non-interfering, stateless function to apply to each element

Returns:

the new stream

mapToObj

public abstract <U> Stream<U> mapToObj(CharFunction<? extends U> mapper)

Returns an object-valued Stream consisting of the results of applying the given function to the elements of this stream.

This is an intermediate operation.

Type Parameters:

U - the element type of the new stream

Parameters:

mapper - a non-interfering, stateless function to apply to each element

Returns:

the new stream

flatMap

public abstract CharStream flatMap(CharFunction<? extends CharStream> mapper)

Returns a stream consisting of the results of replacing each element of this stream with the contents of a mapped stream produced by applying the provided mapping function to each element.

This is an intermediate operation.

Parameters:

mapper - a non-interfering, stateless function to apply to each element which produces an CharStream of new values

Returns:

the new stream

See Also:

Stream.flatMap(Function)

flattMap

public abstract CharStream flattMap(CharFunction<char[]> mapper)

flatMapToInt

public abstract IntStream flatMapToInt(CharFunction<? extends IntStream> mapper)

flatMapToObj

public abstract <T> Stream<T> flatMapToObj(CharFunction<? extends Stream<T>> mapper)

flattMapToObj

public abstract <T> Stream<T> flattMapToObj(CharFunction<? extends java.util.Collection<T>> mapper)

flatMappToObj

public abstract <T> Stream<T> flatMappToObj(CharFunction<T[]> mapper)

rangeMap

@SequentialOnly
public abstract CharStream rangeMap(CharBiPredicate sameRange,
                                                     CharBinaryOperator 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. This is a quasi-intermediate partial reduction operation.

Parameters:

sameRange - a non-interfering, stateless predicate to apply to the leftmost and next elements which returns true for elements which belong to the same range.

mapper - a non-interfering, stateless function to apply to the range borders and produce the resulting element. If value was not merged to the interval, then mapper will receive the same value twice, otherwise it will receive the leftmost and the rightmost values which were merged to the range.

Returns:

the new stream

See Also:

collapse(CharBiPredicate, CharBinaryOperator), Stream.rangeMap(BiPredicate, BiFunction)

rangeMapp

@SequentialOnly
public abstract <T> Stream<T> rangeMapp(CharBiPredicate sameRange,
                                                         CharBiFunction<T> 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. This is a quasi-intermediate partial reduction operation.

Parameters:

sameRange - a non-interfering, stateless predicate to apply to the leftmost and next elements which returns true for elements which belong to the same range.

mapper - a non-interfering, stateless function to apply to the range borders and produce the resulting element. If value was not merged to the interval, then mapper will receive the same value twice, otherwise it will receive the leftmost and the rightmost values which were merged to the range.

Returns:

the new stream

See Also:

Stream.rangeMap(BiPredicate, BiFunction)

collapse

@SequentialOnly
public abstract Stream<CharList> collapse(CharBiPredicate collapsible)

Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.
This method only run sequentially, even in parallel stream.

Parameters:

collapsible -

Returns:

collapse

@SequentialOnly
public abstract CharStream collapse(CharBiPredicate collapsible,
                                                     CharBinaryOperator mergeFunction)

Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.
This method only run sequentially, even in parallel stream.

Parameters:

collapsible -

mergeFunction -

Returns:

scan

@SequentialOnly
public abstract CharStream scan(CharBinaryOperator accumulator)

Returns a Stream produced by iterative application of a accumulation function to an initial element init and next element of the current stream. Produces a Stream consisting of init, acc(init, value1), acc(acc(init, value1), value2), etc.

This is an intermediate operation.

Example:

 accumulator: (a, b) -> a + b
 stream: [1, 2, 3, 4, 5]
 result: [1, 3, 6, 10, 15]
 

This method only run sequentially, even in parallel stream.

Parameters:

accumulator - the accumulation function

Returns:

the new stream which has the extract same size as this stream.

scan

@SequentialOnly
public abstract CharStream scan(char init,
                                                 CharBinaryOperator accumulator)

Returns a Stream produced by iterative application of a accumulation function to an initial element init and next element of the current stream. Produces a Stream consisting of init, acc(init, value1), acc(acc(init, value1), value2), etc.

This is an intermediate operation.

Example:

 init:10
 accumulator: (a, b) -> a + b
 stream: [1, 2, 3, 4, 5]
 result: [11, 13, 16, 20, 25]
 

This method only run sequentially, even in parallel stream.

Parameters:

init - the initial value. it's only used once by accumulator to calculate the fist element in the returned stream. It will be ignored if this stream is empty and won't be the first element of the returned stream.

accumulator - the accumulation function

Returns:

the new stream which has the extract same size as this stream.

scan

@SequentialOnly
public abstract CharStream scan(char init,
                                                 CharBinaryOperator accumulator,
                                                 boolean initIncluded)

Parameters:

init -

accumulator -

initIncluded -

Returns:

toCharList

public abstract CharList toCharList()

toMap

public abstract <K,V> java.util.Map<K,V> toMap(CharFunction<? extends K> keyMapper,
                                               CharFunction<? extends V> valueMapper)

Parameters:

keyMapper -

valueMapper -

Returns:

See Also:

Collectors.toMap(Function, Function)

toMap

public abstract <K,V,M extends java.util.Map<K,V>> M toMap(CharFunction<? extends K> keyMapper,
                                                           CharFunction<? extends V> valueMapper,
                                                           Supplier<? extends M> mapFactory)

Parameters:

keyMapper -

valueMapper -

mapFactory -

Returns:

See Also:

Collectors.toMap(Function, Function, Supplier)

toMap

public abstract <K,V> java.util.Map<K,V> toMap(CharFunction<? extends K> keyMapper,
                                               CharFunction<? extends V> valueMapper,
                                               BinaryOperator<V> mergeFunction)

Parameters:

keyMapper -

valueMapper -

mergeFunction -

Returns:

See Also:

Collectors.toMap(Function, Function, BinaryOperator)

toMap

public abstract <K,V,M extends java.util.Map<K,V>> M toMap(CharFunction<? extends K> keyMapper,
                                                           CharFunction<? extends V> valueMapper,
                                                           BinaryOperator<V> mergeFunction,
                                                           Supplier<? extends M> mapFactory)

Parameters:

keyMapper -

valueMapper -

mergeFunction -

mapFactory -

Returns:

See Also:

Collectors.toMap(Function, Function, BinaryOperator, Supplier)

toMap

public abstract <K,A,D> java.util.Map<K,D> toMap(CharFunction<? extends K> keyMapper,
                                                 Collector<java.lang.Character,A,D> downstream)

Parameters:

keyMapper -

downstream -

Returns:

See Also:

Collectors.groupingBy(Function, Collector)

toMap

public abstract <K,A,D,M extends java.util.Map<K,D>> M toMap(CharFunction<? extends K> keyMapper,
                                                             Collector<java.lang.Character,A,D> downstream,
                                                             Supplier<? extends M> mapFactory)

Parameters:

keyMapper -

downstream -

mapFactory -

Returns:

See Also:

Collectors.groupingBy(Function, Collector, Supplier)

toMatrix

public abstract CharMatrix toMatrix()

reduce

public abstract char reduce(char identity,
                            CharBinaryOperator op)

Performs a reduction on the elements of this stream, using the provided identity value and an associative accumulation function, and returns the reduced value. This is equivalent to:

     int result = identity;
     for (int element : this stream)
         result = accumulator.applyAsChar(result, element)
     return result;
 

but is not constrained to execute sequentially.

The identity value must be an identity for the accumulator function. This means that for all x, accumulator.apply(identity, x) is equal to x. The accumulator function must be an associative function.

This is a terminal operation.

Parameters:

identity - the identity value for the accumulating function

op - an associative, non-interfering, stateless function for combining two values

Returns:

the result of the reduction

See Also:

sum(), min(), max(), average()

reduce

public abstract u.OptionalChar reduce(CharBinaryOperator op)

Performs a reduction on the elements of this stream, using an associative accumulation function, and returns an OptionalChar describing the reduced value, if any. This is equivalent to:

     boolean foundAny = false;
     int result = null;
     for (int element : this stream) {
         if (!foundAny) {
             foundAny = true;
             result = element;
         }
         else
             result = accumulator.applyAsChar(result, element);
     }
     return foundAny ? OptionalChar.of(result) : OptionalChar.empty();
 

but is not constrained to execute sequentially.

The accumulator function must be an associative function.

This is a terminal operation.

Parameters:

op - an associative, non-interfering, stateless function for combining two values

Returns:

the result of the reduction

See Also:

#reduce(int, CharBinaryOperator)

collect

public abstract <R> R collect(Supplier<R> supplier,
                              ObjCharConsumer<? super R> accumulator,
                              BiConsumer<R,R> combiner)

Performs a mutable reduction operation on the elements of this stream. A mutable reduction is one in which the reduced value is a mutable result container, such as an ArrayList, and elements are incorporated by updating the state of the result rather than by replacing the result. This produces a result equivalent to:

     R result = supplier.get();
     for (int element : this stream)
         accumulator.accept(result, element);
     return result;
 

Like #reduce(int, CharBinaryOperator), collect operations can be parallelized without requiring additional synchronization.

This is a terminal operation.

Type Parameters:

R - type of the result

Parameters:

supplier - a function that creates a new result container. For a parallel execution, this function may be called multiple times and must return a fresh value each time.

accumulator - an associative, non-interfering, stateless function for incorporating an additional element into a result

combiner - an associative, non-interfering, stateless function for combining two values, which must be compatible with the accumulator function

Returns:

the result of the reduction

See Also:

Stream.collect(Supplier, BiConsumer, BiConsumer)

collect

public abstract <R> R collect(Supplier<R> supplier,
                              ObjCharConsumer<? super R> accumulator)

Parameters:

supplier -

accumulator -

Returns:

forEach

public abstract <E extends java.lang.Exception> void forEach(Try.CharConsumer<E> action)
                                                      throws E extends java.lang.Exception

Throws:

E extends java.lang.Exception

anyMatch

public abstract <E extends java.lang.Exception> boolean anyMatch(Try.CharPredicate<E> predicate)
                                                          throws E extends java.lang.Exception

Throws:

E extends java.lang.Exception

allMatch

public abstract <E extends java.lang.Exception> boolean allMatch(Try.CharPredicate<E> predicate)
                                                          throws E extends java.lang.Exception

Throws:

E extends java.lang.Exception

noneMatch

public abstract <E extends java.lang.Exception> boolean noneMatch(Try.CharPredicate<E> predicate)
                                                           throws E extends java.lang.Exception

Throws:

E extends java.lang.Exception

findFirst

public abstract <E extends java.lang.Exception> u.OptionalChar findFirst(Try.CharPredicate<E> predicate)
                                                                  throws E extends java.lang.Exception

Throws:

E extends java.lang.Exception

findLast

public abstract <E extends java.lang.Exception> u.OptionalChar findLast(Try.CharPredicate<E> predicate)
                                                                 throws E extends java.lang.Exception

Throws:

E extends java.lang.Exception

findFirstOrLast

public abstract <E extends java.lang.Exception,E2 extends java.lang.Exception> u.OptionalChar findFirstOrLast(Try.CharPredicate<E> predicateForFirst,
                                                                                                              Try.CharPredicate<E> predicateForLast)
                                                                                                       throws E extends java.lang.Exception,
                                                                                                              E2 extends java.lang.Exception

Throws:

E extends java.lang.Exception

findAny

public abstract <E extends java.lang.Exception> u.OptionalChar findAny(Try.CharPredicate<E> predicate)
                                                                throws E extends java.lang.Exception

Throws:

E extends java.lang.Exception

min

public abstract u.OptionalChar min()

Returns an OptionalChar describing the minimum element of this stream, or an empty optional if this stream is empty. This is a special case of a reduction and is equivalent to:

     return reduce(Chareger::min);
 

This is a terminal operation.

Returns:

an OptionalChar containing the minimum element of this stream, or an empty OptionalChar if the stream is empty

max

public abstract u.OptionalChar max()

Returns an OptionalChar describing the maximum element of this stream, or an empty optional if this stream is empty. This is a special case of a reduction and is equivalent to:

     return reduce(Chareger::max);
 

This is a terminal operation.

Returns:

an OptionalChar containing the maximum element of this stream, or an empty OptionalChar if the stream is empty

kthLargest

public abstract u.OptionalChar kthLargest(int k)

Parameters:

k -

Returns:

OptionalByte.empty() if there is no element or count less than k, otherwise the kth largest element.

sum

public abstract int sum()

average

public abstract u.OptionalDouble average()

summarize

public abstract com.landawn.abacus.util.CharSummaryStatistics summarize()

summarizeAndPercentiles

public abstract Pair<com.landawn.abacus.util.CharSummaryStatistics,u.Optional<java.util.Map<com.landawn.abacus.util.Percentage,java.lang.Character>>> summarizeAndPercentiles()

merge

public abstract CharStream merge(CharStream b,
                                 CharBiFunction<com.landawn.abacus.util.Nth> nextSelector)

Parameters:

b -

nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.

Returns:

zipWith

public abstract CharStream zipWith(CharStream b,
                                   CharBinaryOperator zipFunction)

zipWith

public abstract CharStream zipWith(CharStream b,
                                   CharStream c,
                                   CharTernaryOperator zipFunction)

zipWith

public abstract CharStream zipWith(CharStream b,
                                   char valueForNoneA,
                                   char valueForNoneB,
                                   CharBinaryOperator zipFunction)

zipWith

public abstract CharStream zipWith(CharStream b,
                                   CharStream c,
                                   char valueForNoneA,
                                   char valueForNoneB,
                                   char valueForNoneC,
                                   CharTernaryOperator zipFunction)

asIntStream

public abstract IntStream asIntStream()

Returns a LongStream consisting of the elements of this stream, converted to long.

This is an intermediate operation.

Returns:

a LongStream consisting of the elements of this stream, converted to long

boxed

public abstract Stream<java.lang.Character> boxed()

Returns a Stream consisting of the elements of this stream, each boxed to an Chareger.

This is an intermediate operation.

Returns:

a Stream consistent of the elements of this stream, each boxed to an Chareger

iterator

@SequentialOnly
public CharIterator iterator()

Remember to close this Stream after the iteration is done, if required.

Returns:

__

public <R> R __(Function<? super CharStream,R> transfer)

empty

public static CharStream empty()

of

@SafeVarargs
public static CharStream of(char... a)

of

public static CharStream of(char[] a,
                            int startIndex,
                            int endIndex)

of

public static CharStream of(java.lang.CharSequence str)

Takes the chars in the specified String as the elements of the Stream

Parameters:

str -

Returns:

of

public static CharStream of(java.lang.CharSequence str,
                            int startIndex,
                            int endIndex)

Takes the chars in the specified String as the elements of the Stream

Parameters:

str -

startIndex -

endIndex -

Returns:

of

public static CharStream of(java.lang.Character[] a)

of

public static CharStream of(java.lang.Character[] a,
                            int startIndex,
                            int endIndex)

of

public static CharStream of(java.util.Collection<java.lang.Character> c)

of

public static CharStream of(CharIterator iterator)

of

public static CharStream of(Supplier<CharList> supplier)

Lazy evaluation.

Parameters:

supplier -

Returns:

flat

public static CharStream flat(char[][] a)

flat

public static CharStream flat(char[][] a,
                              boolean vertically)

flat

public static CharStream flat(char[][] a,
                              char valueForNone,
                              boolean vertically)

flat

public static CharStream flat(char[][][] a)

range

public static CharStream range(char startInclusive,
                               char endExclusive)

range

public static CharStream range(char startInclusive,
                               char endExclusive,
                               int by)

rangeClosed

public static CharStream rangeClosed(char startInclusive,
                                     char endInclusive)

rangeClosed

public static CharStream rangeClosed(char startInclusive,
                                     char endInclusive,
                                     int by)

repeat

public static CharStream repeat(char element,
                                long n)

random

public static CharStream random()

random

public static CharStream random(char startInclusive,
                                char endExclusive)

random

public static CharStream random(char[] candicates)

iterate

public static CharStream iterate(BooleanSupplier hasNext,
                                 CharSupplier next)

iterate

public static CharStream iterate(char init,
                                 BooleanSupplier hasNext,
                                 CharUnaryOperator f)

iterate

public static CharStream iterate(char init,
                                 CharPredicate hasNext,
                                 CharUnaryOperator f)

Parameters:

init -

hasNext - test if has next by hasNext.test(init) for first time and hasNext.test(f.apply(previous)) for remaining.

f -

Returns:

iterate

public static CharStream iterate(char init,
                                 CharUnaryOperator f)

generate

public static CharStream generate(CharSupplier s)

concat

@SafeVarargs
public static CharStream concat(char[]... a)

concat

@SafeVarargs
public static CharStream concat(CharIterator... a)

concat

@SafeVarargs
public static CharStream concat(CharStream... a)

concat

public static CharStream concat(java.util.Collection<? extends CharStream> c)

zip

public static CharStream zip(char[] a,
                             char[] b,
                             CharBinaryOperator zipFunction)

Zip together the "a" and "b" arrays until one of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static CharStream zip(char[] a,
                             char[] b,
                             char[] c,
                             CharTernaryOperator zipFunction)

Zip together the "a", "b" and "c" arrays until one of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

c -

Returns:

zip

public static CharStream zip(CharIterator a,
                             CharIterator b,
                             CharBinaryOperator zipFunction)

Zip together the "a" and "b" iterators until one of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static CharStream zip(CharIterator a,
                             CharIterator b,
                             CharIterator c,
                             CharTernaryOperator zipFunction)

Zip together the "a", "b" and "c" iterators until one of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static CharStream zip(CharStream a,
                             CharStream b,
                             CharBinaryOperator zipFunction)

Zip together the "a" and "b" streams until one of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static CharStream zip(CharStream a,
                             CharStream b,
                             CharStream c,
                             CharTernaryOperator zipFunction)

Zip together the "a", "b" and "c" streams until one of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static CharStream zip(java.util.Collection<? extends CharStream> c,
                             CharNFunction<java.lang.Character> zipFunction)

Zip together the iterators until one of them runs out of values. Each array of values is combined into a single value using the supplied zipFunction function.

Parameters:

c -

zipFunction -

Returns:

zip

public static CharStream zip(char[] a,
                             char[] b,
                             char valueForNoneA,
                             char valueForNoneB,
                             CharBinaryOperator zipFunction)

Zip together the "a" and "b" iterators until all of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

valueForNoneA - value to fill if "a" runs out of values first.

valueForNoneB - value to fill if "b" runs out of values first.

zipFunction -

Returns:

zip

public static CharStream zip(char[] a,
                             char[] b,
                             char[] c,
                             char valueForNoneA,
                             char valueForNoneB,
                             char valueForNoneC,
                             CharTernaryOperator zipFunction)

Zip together the "a", "b" and "c" iterators until all of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

c -

valueForNoneA - value to fill if "a" runs out of values.

valueForNoneB - value to fill if "b" runs out of values.

valueForNoneC - value to fill if "c" runs out of values.

zipFunction -

Returns:

zip

public static CharStream zip(CharIterator a,
                             CharIterator b,
                             char valueForNoneA,
                             char valueForNoneB,
                             CharBinaryOperator zipFunction)

Zip together the "a" and "b" iterators until all of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

valueForNoneA - value to fill if "a" runs out of values first.

valueForNoneB - value to fill if "b" runs out of values first.

zipFunction -

Returns:

zip

public static CharStream zip(CharIterator a,
                             CharIterator b,
                             CharIterator c,
                             char valueForNoneA,
                             char valueForNoneB,
                             char valueForNoneC,
                             CharTernaryOperator zipFunction)

Zip together the "a", "b" and "c" iterators until all of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

c -

valueForNoneA - value to fill if "a" runs out of values.

valueForNoneB - value to fill if "b" runs out of values.

valueForNoneC - value to fill if "c" runs out of values.

zipFunction -

Returns:

zip

public static CharStream zip(CharStream a,
                             CharStream b,
                             char valueForNoneA,
                             char valueForNoneB,
                             CharBinaryOperator zipFunction)

Zip together the "a" and "b" iterators until all of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

valueForNoneA - value to fill if "a" runs out of values first.

valueForNoneB - value to fill if "b" runs out of values first.

zipFunction -

Returns:

zip

public static CharStream zip(CharStream a,
                             CharStream b,
                             CharStream c,
                             char valueForNoneA,
                             char valueForNoneB,
                             char valueForNoneC,
                             CharTernaryOperator zipFunction)

Zip together the "a", "b" and "c" iterators until all of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

c -

valueForNoneA - value to fill if "a" runs out of values.

valueForNoneB - value to fill if "b" runs out of values.

valueForNoneC - value to fill if "c" runs out of values.

zipFunction -

Returns:

zip

public static CharStream zip(java.util.Collection<? extends CharStream> c,
                             char[] valuesForNone,
                             CharNFunction<java.lang.Character> zipFunction)

Zip together the iterators until all of them runs out of values. Each array of values is combined into a single value using the supplied zipFunction function.

Parameters:

c -

valuesForNone - value to fill for any iterator runs out of values.

zipFunction -

Returns:

merge

public static CharStream merge(char[] a,
                               char[] b,
                               CharBiFunction<com.landawn.abacus.util.Nth> nextSelector)

Parameters:

a -

b -

nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.

Returns:

merge

public static CharStream merge(char[] a,
                               char[] b,
                               char[] c,
                               CharBiFunction<com.landawn.abacus.util.Nth> nextSelector)

Parameters:

a -

b -

c -

nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.

Returns:

merge

public static CharStream merge(CharIterator a,
                               CharIterator b,
                               CharBiFunction<com.landawn.abacus.util.Nth> nextSelector)

Parameters:

a -

b -

nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.

Returns:

merge

public static CharStream merge(CharIterator a,
                               CharIterator b,
                               CharIterator c,
                               CharBiFunction<com.landawn.abacus.util.Nth> nextSelector)

Parameters:

a -

b -

c -

nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.

Returns:

merge

public static CharStream merge(CharStream a,
                               CharStream b,
                               CharBiFunction<com.landawn.abacus.util.Nth> nextSelector)

Parameters:

a -

b -

nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.

Returns:

merge

public static CharStream merge(CharStream a,
                               CharStream b,
                               CharStream c,
                               CharBiFunction<com.landawn.abacus.util.Nth> nextSelector)

Parameters:

a -

b -

c -

nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.

Returns:

merge

public static CharStream merge(java.util.Collection<? extends CharStream> c,
                               CharBiFunction<com.landawn.abacus.util.Nth> nextSelector)

Parameters:

c -

nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.

Returns:

parallelMerge

public static CharStream parallelMerge(java.util.Collection<? extends CharStream> c,
                                       CharBiFunction<com.landawn.abacus.util.Nth> nextSelector)

Parameters:

c -

nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.

Returns:

parallelMerge

public static CharStream parallelMerge(java.util.Collection<? extends CharStream> c,
                                       CharBiFunction<com.landawn.abacus.util.Nth> nextSelector,
                                       int maxThreadNum)

Parameters:

c -

nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.

maxThreadNum -

Returns:

carry

public S carry(C action)

Description copied from interface: BaseStream

Same as peek

Specified by:

carry in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

See Also:

BaseStream.peek(Object)

slice

public S slice(long from,
               long to)

Description copied from interface: BaseStream

Same as: stream.skip(from).limit(to - from).

Specified by:

slice in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

sliding

public Stream<S> sliding(int windowSize)

Specified by:

sliding in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

See Also:

BaseStream.sliding(int, int)

slidingToList

public Stream<PL> slidingToList(int windowSize)

Specified by:

slidingToList in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

See Also:

BaseStream.sliding(int, int)

shuffled

public S shuffled()

Description copied from interface: BaseStream

This method only run sequentially, even in parallel stream and all elements will be loaded to memory.

Specified by:

shuffled in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

toImmutableList

public ImmutableList<T> toImmutableList()

Specified by:

toImmutableList in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

toImmutableSet

public ImmutableSet<T> toImmutableSet()

Specified by:

toImmutableSet in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

join

public java.lang.String join(java.lang.CharSequence delimiter)

Specified by:

join in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

println

public void println()

Specified by:

println in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

isParallel

public boolean isParallel()

Specified by:

isParallel in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

sequential

public S sequential()

Specified by:

sequential in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

parallel

public S parallel()

Specified by:

parallel in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

parallel

public S parallel(int maxThreadNum)

Specified by:

parallel in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

parallel

public S parallel(BaseStream.Splitor splitor)

Specified by:

parallel in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

parallel

public S parallel(java.util.concurrent.Executor exector)

Specified by:

parallel in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Parameters:

exector - should be able to execute sum of maxThreadNum operations in parallel.

Returns:

close

public void close()

Specified by:

close in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Specified by:

close in interface java.lang.AutoCloseable