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,OptionalChar,com.landawn.abacus.util.IndexedChar,CharStream>, java.lang.AutoCloseable

public abstract class CharStream
extends java.lang.Object

Note: It's copied from OpenJDK at: http://hg.openjdk.java.net/jdk8u/hs-dev/jdk
A sequence of primitive int-valued elements supporting sequential and parallel aggregate operations. This is the int primitive specialization of Stream.

The following example illustrates an aggregate operation using Stream and CharStream, computing the sum of the weights of the red widgets:

     int sum = widgets.stream()
                      .filter(w -> w.getColor() == RED)
                      .mapToChar(w -> w.getWeight())
                      .sum();
 

See the class documentation for Stream and the package documentation for java.util.stream for additional specification of streams, stream operations, stream pipelines, and parallelism.

Since:

1.8

See Also:

Stream, java.util.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 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() Closes this stream, causing all close handlers for this stream pipeline to be called.
abstract CharStream	collapse(CharBiPredicate collapsible, CharBiFunction<java.lang.Character> 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<R> accumulator)
abstract <R> R	collect(Supplier<R> supplier, ObjCharConsumer<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> OptionalChar	findAny(Try.CharPredicate<E> predicate)
abstract <E extends java.lang.Exception> OptionalChar	findFirst(Try.CharPredicate<E> predicate)
abstract <E extends java.lang.Exception,E2 extends java.lang.Exception> OptionalChar	findFirstOrLast(Try.CharPredicate<E> predicateForFirst, Try.CharPredicate<E> predicateForLast)
abstract <E extends java.lang.Exception> OptionalChar	findLast(Try.CharPredicate<E> predicate)
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 IntStream	flatMapToInt(CharFunction<? extends IntStream> mapper)
abstract <T> Stream<T>	flatMapToObj(CharFunction<? extends Stream<T>> mapper)
abstract CharStream	flattMap(CharFunction<char[]> mapper)
abstract <E extends java.lang.Exception> void	forEach(Try.CharConsumer<E> action)
static CharStream	generate(CharSupplier s)
abstract OptionalChar	head() Head and tail should be used by pair.
abstract Pair<OptionalChar,CharStream>	headAndTail()
abstract Pair<CharStream,OptionalChar>	headAndTaill()
abstract CharStream	headd() Head2 and tail2 should be used by pair.
boolean	isParallel() Returns whether this stream, if a terminal operation were to be executed, would execute in parallel.
static CharStream	iterate(char seed, CharPredicate hasNext, CharUnaryOperator f)
static CharStream	iterate(char seed, CharUnaryOperator f)
static CharStream	iterate(char seed, Supplier<java.lang.Boolean> hasNext, CharUnaryOperator f)
static CharStream	iterate(Supplier<java.lang.Boolean> hasNext, CharSupplier next)
CharIterator	iterator() Returns an iterator for the elements of this stream.
abstract 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 OptionalChar	max() Returns an OptionalChar describing the maximum element of this stream, or an empty optional if this stream is empty.
int	maxThreadNum() Return the underlying maxThreadNum if the stream is parallel, otherwise 1 is returned.
S	maxThreadNum(int maxThreadNum) Returns a parallel stream with the specified maxThreadNum .
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 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)
static CharStream	of(char[][][] a)
static CharStream	of(char[] 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(Supplier<CharList> supplier) Lazy evaluation.
S	parallel() Returns an equivalent stream that is parallel.
S	parallel(BaseStream.Splitor splitor) Returns an equivalent stream that is parallel.
S	parallel(int maxThreadNum) Returns an equivalent stream that is parallel.
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 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(CharBiFunction<java.lang.Character> 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 CharStream	scan(char seed, CharBiFunction<java.lang.Character> accumulator) Returns a Stream produced by iterative application of a accumulation function to an initial element seed and next element of the current stream.
S	sequential() Returns an equivalent stream that is sequential.
Stream<S>	sliding(int windowSize)
Stream<PL>	slidingToList(int windowSize)
BaseStream.Splitor	splitor() Return the underlying splitor if the stream is parallel, otherwise the default value splitor.ITERATOR is returned.
S	splitor(BaseStream.Splitor splitor) Returns a parallel stream with the specified splitor .
abstract long	sum()
abstract com.landawn.abacus.util.CharSummaryStatistics	summarize()
abstract Pair<com.landawn.abacus.util.CharSummaryStatistics,Optional<java.util.Map<com.landawn.abacus.util.Percentage,java.lang.Character>>>	summarizze()
abstract CharStream	tail() Head and tail should be used by pair.
abstract OptionalChar	taill() Head2 and tail2 should be used by pair.
abstract CharList	toCharList()
abstract <K,U> java.util.Map<K,U>	toMap(CharFunction<? extends K> keyExtractor, CharFunction<? extends U> valueMapper)
abstract <K,U> java.util.Map<K,U>	toMap(CharFunction<? extends K> keyExtractor, CharFunction<? extends U> valueMapper, BinaryOperator<U> mergeFunction)
abstract <K,U,M extends java.util.Map<K,U>> M	toMap(CharFunction<? extends K> keyExtractor, CharFunction<? extends U> valueMapper, BinaryOperator<U> mergeFunction, Supplier<M> mapFactory)
abstract <K,U,M extends java.util.Map<K,U>> M	toMap(CharFunction<? extends K> keyExtractor, CharFunction<? extends U> valueMapper, Supplier<M> mapFactory)
abstract <K,A,D> java.util.Map<K,D>	toMap(CharFunction<? extends K> classifier, Collector<java.lang.Character,A,D> downstream)
abstract <K,A,D,M extends java.util.Map<K,D>> M	toMap(CharFunction<? extends K> classifier, Collector<java.lang.Character,A,D> downstream, Supplier<M> mapFactory)
abstract CharMatrix	toMatrix()
Try<S>	tried()
static CharStream	zip(char[] a, char[] b, char[] c, char valueForNoneA, char valueForNoneB, char valueForNoneC, CharTriFunction<java.lang.Character> 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, CharTriFunction<java.lang.Character> zipFunction) Zip together the "a", "b" and "c" arrays until one of them runs out of values.
static CharStream	zip(char[] a, char[] b, CharBiFunction<java.lang.Character> 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, CharBiFunction<java.lang.Character> zipFunction) Zip together the "a" and "b" iterators until all of them runs out of values.
static CharStream	zip(CharIterator a, CharIterator b, CharBiFunction<java.lang.Character> 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, CharBiFunction<java.lang.Character> 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, CharTriFunction<java.lang.Character> 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, CharTriFunction<java.lang.Character> zipFunction) Zip together the "a", "b" and "c" iterators until one of them runs out of values.
static CharStream	zip(CharStream a, CharStream b, CharBiFunction<java.lang.Character> 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, CharBiFunction<java.lang.Character> 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, CharTriFunction<java.lang.Character> 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, CharTriFunction<java.lang.Character> 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, CharBiFunction<java.lang.Character> zipFunction)
abstract CharStream	zipWith(CharStream b, char valueForNoneA, char valueForNoneB, CharBiFunction<java.lang.Character> zipFunction)
abstract CharStream	zipWith(CharStream b, CharStream c, char valueForNoneA, char valueForNoneB, char valueForNoneC, CharTriFunction<java.lang.Character> zipFunction)
abstract CharStream	zipWith(CharStream b, CharStream c, CharTriFunction<java.lang.Character> 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, cached, count, difference, distinct, dropWhile, filter, first, indexed, intersection, join, join, last, limit, onClose, parallel, peek, percentiles, prepend, remove, removeIf, removeIf, removeWhile, reversed, reverseSorted, rotated, shuffled, shuffled, skip, sliding, slidingToList, sorted, split, split, split, splitAt, splitBy, splitToList, splitToList, splitToList, step, symmetricDifference, takeWhile, toArray, toList, toList, toLongMultiset, toLongMultiset, toMultiset, toMultiset, toSet, 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)

collapse

public abstract CharStream collapse(CharBiPredicate collapsible,
                                    CharBiFunction<java.lang.Character> 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

public abstract CharStream scan(CharBiFunction<java.lang.Character> accumulator)

Returns a Stream produced by iterative application of a accumulation function to an initial element seed and next element of the current stream. Produces a Stream consisting of seed, acc(seed, value1), acc(acc(seed, 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

public abstract CharStream scan(char seed,
                                CharBiFunction<java.lang.Character> accumulator)

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

This is an intermediate operation.

Example:

 seed: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:

seed - 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.

toCharList

public abstract CharList toCharList()

toMap

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

Parameters:

keyExtractor -

valueMapper -

Returns:

See Also:

Collectors.toMap(Function, Function)

toMap

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

Parameters:

keyExtractor -

valueMapper -

mapFactory -

Returns:

See Also:

Collectors.toMap(Function, Function, Supplier)

toMap

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

Parameters:

keyExtractor -

valueMapper -

mergeFunction -

Returns:

See Also:

Collectors.toMap(Function, Function, BinaryOperator)

toMap

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

Parameters:

keyExtractor -

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> classifier,
                                                 Collector<java.lang.Character,A,D> downstream)

Parameters:

classifier -

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> classifier,
                                                             Collector<java.lang.Character,A,D> downstream,
                                                             Supplier<M> mapFactory)

Parameters:

classifier -

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 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<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<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> 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> 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> 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> OptionalChar findAny(Try.CharPredicate<E> predicate)
                                                              throws E extends java.lang.Exception

Throws:

E extends java.lang.Exception

head

public abstract OptionalChar head()

Head and tail should be used by pair. If only one is called, should use first() or skip(1) instead. Don't call any other methods with this stream after head() and tail() are called.

Returns:

tail

public abstract CharStream tail()

Head and tail should be used by pair. If only one is called, should use first() or skip(1) instead. Don't call any other methods with this stream after head() and tail() are called.

Returns:

headd

public abstract CharStream headd()

Head2 and tail2 should be used by pair. Don't call any other methods with this stream after headd() and taill() are called.

Returns:

taill

public abstract OptionalChar taill()

Head2 and tail2 should be used by pair. Don't call any other methods with this stream after headd() and taill() are called.

Returns:

headAndTail

public abstract Pair<OptionalChar,CharStream> headAndTail()

headAndTaill

public abstract Pair<CharStream,OptionalChar> headAndTaill()

min

public abstract 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 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 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 long sum()

average

public abstract OptionalDouble average()

summarize

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

summarizze

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

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,
                                   CharBiFunction<java.lang.Character> zipFunction)

zipWith

public abstract CharStream zipWith(CharStream b,
                                   CharStream c,
                                   CharTriFunction<java.lang.Character> zipFunction)

zipWith

public abstract CharStream zipWith(CharStream b,
                                   char valueForNoneA,
                                   char valueForNoneB,
                                   CharBiFunction<java.lang.Character> zipFunction)

zipWith

public abstract CharStream zipWith(CharStream b,
                                   CharStream c,
                                   char valueForNoneA,
                                   char valueForNoneB,
                                   char valueForNoneC,
                                   CharTriFunction<java.lang.Character> 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

public CharIterator iterator()

Description copied from interface: BaseStream

Returns an iterator for the elements of this stream.

Returns:

the element iterator for this stream

__

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(char[][] a)

of

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

of

public static CharStream of(CharIterator iterator)

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(Supplier<CharList> supplier)

Lazy evaluation.

Parameters:

supplier -

Returns:

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(Supplier<java.lang.Boolean> hasNext,
                                 CharSupplier next)

iterate

public static CharStream iterate(char seed,
                                 Supplier<java.lang.Boolean> hasNext,
                                 CharUnaryOperator f)

iterate

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

Parameters:

seed -

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

f -

Returns:

iterate

public static CharStream iterate(char seed,
                                 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,
                             CharBiFunction<java.lang.Character> 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,
                             CharTriFunction<java.lang.Character> 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 -

Returns:

zip

public static CharStream zip(CharIterator a,
                             CharIterator b,
                             CharBiFunction<java.lang.Character> 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,
                             CharTriFunction<java.lang.Character> 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,
                             CharBiFunction<java.lang.Character> 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,
                             CharTriFunction<java.lang.Character> 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,
                             CharBiFunction<java.lang.Character> 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,
                             CharTriFunction<java.lang.Character> 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,
                             CharBiFunction<java.lang.Character> 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,
                             CharTriFunction<java.lang.Character> 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,
                             CharBiFunction<java.lang.Character> 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,
                             CharTriFunction<java.lang.Character> 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,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>

Returns:

See Also:

BaseStream.peek(Object)

sliding

public Stream<S> sliding(int windowSize)

Specified by:

sliding in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,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,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>

Returns:

See Also:

BaseStream.sliding(int, int)

println

public void println()

Specified by:

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

isParallel

public boolean isParallel()

Description copied from interface: BaseStream

Returns whether this stream, if a terminal operation were to be executed, would execute in parallel. Calling this method after invoking an terminal stream operation method may yield unpredictable results.

Specified by:

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

Returns:

true if this stream would execute in parallel if executed

sequential

public S sequential()

Description copied from interface: BaseStream

Returns an equivalent stream that is sequential. May return itself, either because the stream was already sequential, or because the underlying stream state was modified to be sequential.

Specified by:

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

Returns:

a sequential stream

parallel

public S parallel()

Description copied from interface: BaseStream

Returns an equivalent stream that is parallel. May return itself if the stream was already parallel. Any parallel should be closed by try-catch or call tried before last step.

Specified by:

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

Returns:

a parallel stream

See Also:

BaseStream.parallel(int, Splitor)

parallel

public S parallel(int maxThreadNum)

Description copied from interface: BaseStream

Returns an equivalent stream that is parallel. May return itself if the stream was already parallel with the same maxThreadNum as the specified one.

Specified by:

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

Returns:

See Also:

BaseStream.parallel(int, Splitor)

parallel

public S parallel(BaseStream.Splitor splitor)

Description copied from interface: BaseStream

Returns an equivalent stream that is parallel. May return itself if the stream was already parallel with the same splitor as the specified one.

Specified by:

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

Returns:

See Also:

BaseStream.parallel(int, Splitor)

maxThreadNum

public int maxThreadNum()

Description copied from interface: BaseStream

Return the underlying maxThreadNum if the stream is parallel, otherwise 1 is returned.

Specified by:

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

Returns:

maxThreadNum

public S maxThreadNum(int maxThreadNum)

Description copied from interface: BaseStream

Returns a parallel stream with the specified maxThreadNum . Or return itself, either because the stream was already parallel with same maxThreadNum, or because it's a sequential stream.

Specified by:

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

Returns:

splitor

public BaseStream.Splitor splitor()

Description copied from interface: BaseStream

Return the underlying splitor if the stream is parallel, otherwise the default value splitor.ITERATOR is returned.

Specified by:

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

Returns:

splitor

public S splitor(BaseStream.Splitor splitor)

Description copied from interface: BaseStream

Returns a parallel stream with the specified splitor . Or return itself, either because the stream was already parallel with same splitor, or because it's a sequential stream.

Specified by:

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

Returns:

tried

public Try<S> tried()

Specified by:

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

close

public void close()

Description copied from interface: BaseStream

Closes this stream, causing all close handlers for this stream pipeline to be called.

Specified by:

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

Specified by:

close in interface java.lang.AutoCloseable

See Also:

AutoCloseable.close()