CharList (abacus-util 1.9.7 API)

java.lang.Object
- com.landawn.abacus.util.PrimitiveList<Character,char[],CharList>
- - com.landawn.abacus.util.CharList

All Implemented Interfaces:

Serializable, RandomAccess
```
public final class CharList
extends PrimitiveList<Character,char[],CharList>
```
The Class CharList.

Since:

0.8

Author:

Haiyang Li

See Also:

Serialized Form

Constructor Summary

Constructors
Constructor and Description
`CharList()` Instantiates a new char list.
`CharList(char[] a)` The specified array is used as the element array for this list without copying action.
`CharList(char[] a, int size)` Instantiates a new char list.
`CharList(int initialCapacity)` Instantiates a new char list.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`<E extends Exception> void`	`accept(Try.Consumer<? super CharList,E> action)`
`<E extends Exception> void`	`acceptIfNotEmpty(Try.Consumer<? super CharList,E> action)` Accept if not empty.
`void`	`add(char e)`
`void`	`add(int index, char e)`
`boolean`	`addAll(char[] a)` Adds the all.
`boolean`	`addAll(CharList c)` Adds the all.
`boolean`	`addAll(int index, char[] a)` Adds the all.
`boolean`	`addAll(int index, CharList c)` Adds the all.
`<E extends Exception> boolean`	`allMatch(int fromIndex, int toIndex, Try.CharPredicate<E> filter)`
`<E extends Exception> boolean`	`allMatch(Try.CharPredicate<E> filter)` Returns whether all elements of this List match the provided predicate.
`<E extends Exception> boolean`	`anyMatch(int fromIndex, int toIndex, Try.CharPredicate<E> filter)`
`<E extends Exception> boolean`	`anyMatch(Try.CharPredicate<E> filter)` Returns whether any elements of this List match the provided predicate.
`<R,E extends Exception> R`	`apply(Try.Function<? super CharList,R,E> func)`
`<R,E extends Exception> u.Optional<R>`	`applyIfNotEmpty(Try.Function<? super CharList,R,E> func)` Apply if not empty.
`char[]`	`array()` Returns the original element array without copying.
`u.OptionalDouble`	`average()`
`u.OptionalDouble`	`average(int fromIndex, int toIndex)`
`int`	`binarySearch(char key)` This List should be sorted first.
`int`	`binarySearch(int fromIndex, int toIndex, char key)` This List should be sorted first.
`List<Character>`	`boxed()`
`List<Character>`	`boxed(int fromIndex, int toIndex)`
`void`	`clear()` Clear.
`boolean`	`contains(char e)`
`boolean`	`containsAll(char[] a)`
`boolean`	`containsAll(CharList c)`
`boolean`	`containsAny(char[] a)`
`boolean`	`containsAny(CharList c)`
`CharList`	`copy()`
`CharList`	`copy(int fromIndex, int toIndex)`
`CharList`	`copy(int from, int to, int step)`
`static CharList`	`copyOf(char[] a)`
`static CharList`	`copyOf(char[] a, int fromIndex, int toIndex)`
`<E extends Exception> int`	`count(int fromIndex, int toIndex, Try.CharPredicate<E> filter)`
`<E extends Exception> int`	`count(Try.CharPredicate<E> filter)`
`char`	`delete(int index)`
`void`	`deleteAll(int... indices)`
`void`	`deleteRange(int fromIndex, int toIndex)`
`CharList`	`difference(char[] a)`
`CharList`	`difference(CharList b)`
`boolean`	`disjoint(char[] b)`
`boolean`	`disjoint(CharList c)`
`CharList`	`distinct(int fromIndex, int toIndex)`
`boolean`	`equals(Object obj)`
`void`	`fill(char val)`
`void`	`fill(int fromIndex, int toIndex, char val)`
`<E extends Exception> CharList`	`filter(int fromIndex, int toIndex, Try.CharPredicate<E> filter)`
`<E extends Exception> CharList`	`filter(int fromIndex, int toIndex, Try.CharPredicate<E> filter, int max)`
`<E extends Exception> CharList`	`filter(Try.CharPredicate<E> filter)`
`<E extends Exception> CharList`	`filter(Try.CharPredicate<E> filter, int max)`
`<E extends Exception> u.OptionalChar`	`findFirst(Try.CharPredicate<E> predicate)`
`<E extends Exception> u.OptionalInt`	`findFirstIndex(Try.CharPredicate<E> predicate)` Find first index.
`<E extends Exception> u.OptionalChar`	`findLast(Try.CharPredicate<E> predicate)`
`<E extends Exception> u.OptionalInt`	`findLastIndex(Try.CharPredicate<E> predicate)` Find last index.
`u.OptionalChar`	`first()`
`<E extends Exception> void`	`forEach(int fromIndex, int toIndex, Try.CharConsumer<E> action)`
`<E extends Exception> void`	`forEach(Try.CharConsumer<E> action)`
`static CharList`	`from(Collection<Character> c)`
`static CharList`	`from(Collection<Character> c, char defaultForNull)`
`static CharList`	`from(Collection<Character> c, int fromIndex, int toIndex)`
`static CharList`	`from(Collection<Character> c, int fromIndex, int toIndex, char defaultForNull)`
`char`	`get(int index)`
`boolean`	`hasDuplicates()` Checks for duplicates.
`int`	`hashCode()`
`int`	`indexOf(char e)`
`int`	`indexOf(int fromIndex, char e)`
`CharList`	`intersection(char[] a)`
`CharList`	`intersection(CharList b)`
`boolean`	`isEmpty()` Checks if is empty.
`CharIterator`	`iterator()`
`String`	`join(int fromIndex, int toIndex, char delimiter)`
`String`	`join(int fromIndex, int toIndex, String delimiter)`
`u.OptionalChar`	`kthLargest(int k)`
`u.OptionalChar`	`kthLargest(int fromIndex, int toIndex, int k)`
`u.OptionalChar`	`last()`
`int`	`lastIndexOf(char e)` Last index of.
`int`	`lastIndexOf(int fromIndex, char e)` Last index of.
`<E extends Exception> CharList`	`map(int fromIndex, int toIndex, Try.CharUnaryOperator<E> mapper)`
`<E extends Exception> CharList`	`map(Try.CharUnaryOperator<E> mapper)`
`<T,E extends Exception> List<T>`	`mapToObj(int fromIndex, int toIndex, Try.CharFunction<? extends T,E> mapper)` Map to obj.
`<T,E extends Exception> List<T>`	`mapToObj(Try.CharFunction<? extends T,E> mapper)` Map to obj.
`u.OptionalChar`	`max()`
`u.OptionalChar`	`max(int fromIndex, int toIndex)`
`u.OptionalChar`	`median()`
`u.OptionalChar`	`median(int fromIndex, int toIndex)`
`u.OptionalChar`	`min()`
`u.OptionalChar`	`min(int fromIndex, int toIndex)`
`<E extends Exception> boolean`	`noneMatch(int fromIndex, int toIndex, Try.CharPredicate<E> filter)`
`<E extends Exception> boolean`	`noneMatch(Try.CharPredicate<E> filter)` Returns whether no elements of this List match the provided predicate.
`int`	`occurrencesOf(char objectToFind)`
`static CharList`	`of(char... a)`
`static CharList`	`of(char[] a, int size)`
`void`	`parallelSort()` Parallel sort.
`static CharList`	`random(char[] candicates, int len)`
`static CharList`	`random(char startInclusive, char endExclusive, int len)`
`static CharList`	`random(int len)`
`static CharList`	`range(char startInclusive, char endExclusive)`
`static CharList`	`range(char startInclusive, char endExclusive, int by)`
`static CharList`	`rangeClosed(char startInclusive, char endInclusive)`
`static CharList`	`rangeClosed(char startInclusive, char endInclusive, int by)`
`<E extends Exception> char`	`reduce(char identity, Try.CharBinaryOperator<E> accumulator)` This is equivalent to:
`<E extends Exception> u.OptionalChar`	`reduce(Try.CharBinaryOperator<E> accumulator)` This is equivalent to:
`boolean`	`remove(char e)`
`boolean`	`removeAll(char[] a)` Removes the all.
`boolean`	`removeAll(CharList c)` Removes the all.
`boolean`	`removeAllOccurrences(char e)` Removes the all occurrences.
`<E extends Exception> boolean`	`removeIf(Try.CharPredicate<E> p)` Removes the if.
`static CharList`	`repeat(char element, int len)`
`int`	`replaceAll(char oldVal, char newVal)`
`<E extends Exception> void`	`replaceAll(Try.CharUnaryOperator<E> operator)`
`<E extends Exception> boolean`	`replaceIf(Try.CharPredicate<E> predicate, char newValue)`
`boolean`	`retainAll(char[] a)`
`boolean`	`retainAll(CharList c)`
`void`	`reverse()` Reverse.
`void`	`reverse(int fromIndex, int toIndex)`
`void`	`reverseSort()` Reverse sort.
`void`	`rotate(int distance)`
`char`	`set(int index, char e)`
`void`	`shuffle()` Shuffle.
`void`	`shuffle(Random rnd)`
`int`	`size()`
`void`	`sort()` Sort.
`List<CharList>`	`split(int fromIndex, int toIndex, int chunkSize)` Returns List of `CharList` with consecutive sub sequences of the elements, each of the same size (the final sequence may be smaller).
`CharStream`	`stream()`
`CharStream`	`stream(int fromIndex, int toIndex)`
`int`	`sum()`
`int`	`sum(int fromIndex, int toIndex)`
`void`	`swap(int i, int j)`
`CharList`	`symmetricDifference(char[] a)`
`CharList`	`symmetricDifference(CharList b)`
`char[]`	`toArray()`
`<C extends Collection<Character>> C`	`toCollection(int fromIndex, int toIndex, IntFunction<? extends C> supplier)`
`IntList`	`toIntList()` To int list.
`<K,A,D,E extends Exception> Map<K,D>`	`toMap(Try.CharFunction<? extends K,E> keyMapper, Collector<Character,A,D> downstream)`
`<K,A,D,M extends Map<K,D>,E extends Exception> M`	`toMap(Try.CharFunction<? extends K,E> keyMapper, Collector<Character,A,D> downstream, IntFunction<? extends M> mapFactory)`
`<K,V,E extends Exception,E2 extends Exception> Map<K,V>`	`toMap(Try.CharFunction<? extends K,E> keyMapper, Try.CharFunction<? extends V,E2> valueMapper)`
`<K,V,M extends Map<K,V>,E extends Exception,E2 extends Exception> M`	`toMap(Try.CharFunction<? extends K,E> keyMapper, Try.CharFunction<? extends V,E2> valueMapper, IntFunction<? extends M> mapFactory)`
`<K,V,E extends Exception,E2 extends Exception,E3 extends Exception> Map<K,V>`	`toMap(Try.CharFunction<? extends K,E> keyMapper, Try.CharFunction<? extends V,E2> valueMapper, Try.BinaryOperator<V,E3> mergeFunction)`
`<K,V,M extends Map<K,V>,E extends Exception,E2 extends Exception,E3 extends Exception> M`	`toMap(Try.CharFunction<? extends K,E> keyMapper, Try.CharFunction<? extends V,E2> valueMapper, Try.BinaryOperator<V,E3> mergeFunction, IntFunction<? extends M> mapFactory)`
`Multiset<Character>`	`toMultiset(int fromIndex, int toIndex, IntFunction<Multiset<Character>> supplier)`
`String`	`toString()`
`CharList`	`trimToSize()` Trim to size.

Methods inherited from class com.landawn.abacus.util.PrimitiveList
distinct, join, join, join, join, println, split, toCollection, toList, toList, toMultiset, toMultiset, toMultiset, toSet, toSet

Methods inherited from class java.lang.Object
getClass, notify, notifyAll, wait, wait, wait

Constructor Detail
- CharList
```
public CharList()
```
  Instantiates a new char list.
- CharList
```
public CharList(int initialCapacity)
```
  Instantiates a new char list.
  
  Parameters:
  
  initialCapacity -
- CharList
```
public CharList(char[] a)
```
  The specified array is used as the element array for this list without copying action.
  
  Parameters:
  
  a -
- CharList
```
public CharList(char[] a,
                int size)
```
  Instantiates a new char list.
  
  Parameters:
  
  a -
  
  size -

Method Detail

of

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

Parameters:: a -
Returns:

of

public static CharList of(char[] a,
                          int size)

Parameters:: a -; size -
Returns:

copyOf

public static CharList copyOf(char[] a)

Parameters:: a -
Returns:

copyOf

public static CharList copyOf(char[] a,
                              int fromIndex,
                              int toIndex)

Parameters:: a -; fromIndex -; toIndex -
Returns:

from

public static CharList from(Collection<Character> c)

Parameters:: c -
Returns:

from

public static CharList from(Collection<Character> c,
                            char defaultForNull)

Parameters:: c -; defaultForNull -
Returns:

from

public static CharList from(Collection<Character> c,
                            int fromIndex,
                            int toIndex)

Parameters:: c -; fromIndex -; toIndex -
Returns:

from

public static CharList from(Collection<Character> c,
                            int fromIndex,
                            int toIndex,
                            char defaultForNull)

Parameters:: c -; fromIndex -; toIndex -; defaultForNull -
Returns:

range

public static CharList range(char startInclusive,
                             char endExclusive)

Parameters:: startInclusive -; endExclusive -
Returns:

range

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

Parameters:: startInclusive -; endExclusive -; by -
Returns:

rangeClosed

public static CharList rangeClosed(char startInclusive,
                                   char endInclusive)

Parameters:: startInclusive -; endInclusive -
Returns:

rangeClosed

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

Parameters:: startInclusive -; endInclusive -; by -
Returns:

repeat

public static CharList repeat(char element,
                              int len)

Parameters:: element -; len -
Returns:

random

public static CharList random(int len)

Parameters:: len -
Returns:

random

public static CharList random(char startInclusive,
                              char endExclusive,
                              int len)

Parameters:: startInclusive -; endExclusive -; len -
Returns:

random

public static CharList random(char[] candicates,
                              int len)

Parameters:: candicates -; len -
Returns:

array
```
public char[] array()
```
Returns the original element array without copying.

Specified by:

array in class PrimitiveList<Character,char[],CharList>

Returns:

get
```
public char get(int index)
```
Parameters:

index -

Returns:

set

public char set(int index,
                char e)

Parameters:: index -; e -
Returns:

add
```
public void add(char e)
```
Parameters:

e -

add

public void add(int index,
                char e)

Parameters:: index -; e -

addAll
```
public boolean addAll(CharList c)
```
Adds the all.

Parameters:

c -

Returns:

true, if successful

addAll

public boolean addAll(int index,
                      CharList c)

Adds the all.

Parameters:: index -; c -
Returns:: true, if successful

addAll
```
public boolean addAll(char[] a)
```
Adds the all.

Specified by:

addAll in class PrimitiveList<Character,char[],CharList>

Parameters:

a -

Returns:

true, if successful

addAll
```
public boolean addAll(int index,
                      char[] a)
```
Adds the all.

Specified by:

addAll in class PrimitiveList<Character,char[],CharList>

Parameters:

index -

a -

Returns:

true, if successful

remove
```
public boolean remove(char e)
```
Parameters:

e -

Returns:

true if this list contained the specified element

removeAllOccurrences
```
public boolean removeAllOccurrences(char e)
```
Removes the all occurrences.

Parameters:

e -

Returns:

true if this list contained the specified element

removeAll
```
public boolean removeAll(CharList c)
```
Removes the all.

Parameters:

c -

Returns:

true, if successful

removeAll
```
public boolean removeAll(char[] a)
```
Removes the all.

Specified by:

removeAll in class PrimitiveList<Character,char[],CharList>

Parameters:

a -

Returns:

true, if successful

removeIf

public <E extends Exception> boolean removeIf(Try.CharPredicate<E> p)
                                       throws E extends Exception

Removes the if.

Type Parameters:: E -
Parameters:: p -
Returns:: true, if successful
Throws:: E - the e; E extends Exception

retainAll
```
public boolean retainAll(CharList c)
```
Parameters:

c -

Returns:

true, if successful

retainAll
```
public boolean retainAll(char[] a)
```
Parameters:

a -

Returns:

true, if successful

delete
```
public char delete(int index)
```
Parameters:

index -

Returns:

deleteAll
```
@SafeVarargs
public final void deleteAll(int... indices)
```
Specified by:

deleteAll in class PrimitiveList<Character,char[],CharList>

Parameters:

indices -

deleteRange
```
public void deleteRange(int fromIndex,
                        int toIndex)
```
Specified by:

deleteRange in class PrimitiveList<Character,char[],CharList>

Parameters:

fromIndex -

toIndex -

replaceAll

public int replaceAll(char oldVal,
                      char newVal)

Parameters:: oldVal -; newVal -
Returns:

replaceAll

public <E extends Exception> void replaceAll(Try.CharUnaryOperator<E> operator)
                                      throws E extends Exception

Type Parameters:: E -
Parameters:: operator -
Throws:: E - the e; E extends Exception

replaceIf

public <E extends Exception> boolean replaceIf(Try.CharPredicate<E> predicate,
                                               char newValue)
                                        throws E extends Exception

Type Parameters:: E -
Parameters:: predicate -; newValue -
Returns:: true, if successful
Throws:: E - the e; E extends Exception

fill
```
public void fill(char val)
```
Parameters:

val -

fill

public void fill(int fromIndex,
                 int toIndex,
                 char val)

Parameters:: fromIndex -; toIndex -; val -

contains
```
public boolean contains(char e)
```
Parameters:

e -

Returns:

true, if successful

containsAll
```
public boolean containsAll(CharList c)
```
Parameters:

c -

Returns:

true, if successful

containsAll
```
public boolean containsAll(char[] a)
```
Specified by:

containsAll in class PrimitiveList<Character,char[],CharList>

Parameters:

a -

Returns:

true, if successful

containsAny
```
public boolean containsAny(CharList c)
```
Parameters:

c -

Returns:

true, if successful

containsAny
```
public boolean containsAny(char[] a)
```
Specified by:

containsAny in class PrimitiveList<Character,char[],CharList>

Parameters:

a -

Returns:

true, if successful

disjoint
```
public boolean disjoint(CharList c)
```
Parameters:

c -

Returns:

true, if successful

disjoint
```
public boolean disjoint(char[] b)
```
Specified by:

disjoint in class PrimitiveList<Character,char[],CharList>

Parameters:

b -

Returns:

true, if successful

intersection
```
public CharList intersection(CharList b)
```
Parameters:

b -

Returns:

See Also:

IntList.intersection(IntList)

intersection

public CharList intersection(char[] a)

Parameters:: a -
Returns:

difference
```
public CharList difference(CharList b)
```
Parameters:

b -

Returns:

See Also:

IntList.difference(IntList)

difference
```
public CharList difference(char[] a)
```
Parameters:

a -

Returns:

symmetricDifference
```
public CharList symmetricDifference(CharList b)
```
Parameters:

b -

Returns:

this.difference(b).addAll(b.difference(this))

See Also:

IntList.symmetricDifference(IntList)

symmetricDifference

public CharList symmetricDifference(char[] a)

Parameters:: a -
Returns:

occurrencesOf

public int occurrencesOf(char objectToFind)

Parameters:: objectToFind -
Returns:

indexOf
```
public int indexOf(char e)
```
Parameters:

e -

Returns:

indexOf

public int indexOf(int fromIndex,
                   char e)

Parameters:: fromIndex -; e -
Returns:

lastIndexOf
```
public int lastIndexOf(char e)
```
Last index of.

Parameters:

e -

Returns:

lastIndexOf
```
public int lastIndexOf(int fromIndex,
                       char e)
```
Last index of.

Parameters:

fromIndex - the start index to traverse backwards from. Inclusive.

e -

Returns:

min
```
public u.OptionalChar min()
```
Returns:

min

public u.OptionalChar min(int fromIndex,
                          int toIndex)

Parameters:: fromIndex -; toIndex -
Returns:

median
```
public u.OptionalChar median()
```
Returns:

median

public u.OptionalChar median(int fromIndex,
                             int toIndex)

Parameters:: fromIndex -; toIndex -
Returns:

max
```
public u.OptionalChar max()
```
Returns:

max

public u.OptionalChar max(int fromIndex,
                          int toIndex)

Parameters:: fromIndex -; toIndex -
Returns:

kthLargest

public u.OptionalChar kthLargest(int k)

Parameters:: k -
Returns:

kthLargest

public u.OptionalChar kthLargest(int fromIndex,
                                 int toIndex,
                                 int k)

Parameters:: fromIndex -; toIndex -; k -
Returns:

sum
```
public int sum()
```
Returns:

sum

public int sum(int fromIndex,
               int toIndex)

Parameters:: fromIndex -; toIndex -
Returns:

average
```
public u.OptionalDouble average()
```
Returns:

average

public u.OptionalDouble average(int fromIndex,
                                int toIndex)

Parameters:: fromIndex -; toIndex -
Returns:

forEach

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

Type Parameters:: E -
Parameters:: action -
Throws:: E - the e; E extends Exception

forEach

public <E extends Exception> void forEach(int fromIndex,
                                          int toIndex,
                                          Try.CharConsumer<E> action)
                                   throws E extends Exception

Type Parameters:: E -
Parameters:: fromIndex -; toIndex -; action -
Throws:: E - the e; E extends Exception

first
```
public u.OptionalChar first()
```
Returns:

last
```
public u.OptionalChar last()
```
Returns:

findFirst

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

Type Parameters:: E -
Parameters:: predicate -
Returns:
Throws:: E - the e; E extends Exception

findLast

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

Type Parameters:: E -
Parameters:: predicate -
Returns:
Throws:: E - the e; E extends Exception

findFirstIndex

public <E extends Exception> u.OptionalInt findFirstIndex(Try.CharPredicate<E> predicate)
                                                   throws E extends Exception

Find first index.

Type Parameters:: E -
Parameters:: predicate -
Returns:
Throws:: E - the e; E extends Exception

findLastIndex

public <E extends Exception> u.OptionalInt findLastIndex(Try.CharPredicate<E> predicate)
                                                  throws E extends Exception

Find last index.

Type Parameters:: E -
Parameters:: predicate -
Returns:
Throws:: E - the e; E extends Exception

allMatch
```
public <E extends Exception> boolean allMatch(Try.CharPredicate<E> filter)
                                       throws E extends Exception
```
Returns whether all elements of this List match the provided predicate.

Type Parameters:

E -

Parameters:

filter -

Returns:

true, if successful

Throws:

E - the e

E extends Exception

allMatch

public <E extends Exception> boolean allMatch(int fromIndex,
                                              int toIndex,
                                              Try.CharPredicate<E> filter)
                                       throws E extends Exception

Type Parameters:: E -
Parameters:: fromIndex -; toIndex -; filter -
Returns:: true, if successful
Throws:: E - the e; E extends Exception

anyMatch
```
public <E extends Exception> boolean anyMatch(Try.CharPredicate<E> filter)
                                       throws E extends Exception
```
Returns whether any elements of this List match the provided predicate.

Type Parameters:

E -

Parameters:

filter -

Returns:

true, if successful

Throws:

E - the e

E extends Exception

anyMatch

public <E extends Exception> boolean anyMatch(int fromIndex,
                                              int toIndex,
                                              Try.CharPredicate<E> filter)
                                       throws E extends Exception

Type Parameters:: E -
Parameters:: fromIndex -; toIndex -; filter -
Returns:: true, if successful
Throws:: E - the e; E extends Exception

noneMatch
```
public <E extends Exception> boolean noneMatch(Try.CharPredicate<E> filter)
                                        throws E extends Exception
```
Returns whether no elements of this List match the provided predicate.

Type Parameters:

E -

Parameters:

filter -

Returns:

true, if successful

Throws:

E - the e

E extends Exception

noneMatch

public <E extends Exception> boolean noneMatch(int fromIndex,
                                               int toIndex,
                                               Try.CharPredicate<E> filter)
                                        throws E extends Exception

Type Parameters:: E -
Parameters:: fromIndex -; toIndex -; filter -
Returns:: true, if successful
Throws:: E - the e; E extends Exception

count

public <E extends Exception> int count(Try.CharPredicate<E> filter)
                                throws E extends Exception

Type Parameters:: E -
Parameters:: filter -
Returns:
Throws:: E - the e; E extends Exception

count

public <E extends Exception> int count(int fromIndex,
                                       int toIndex,
                                       Try.CharPredicate<E> filter)
                                throws E extends Exception

Type Parameters:: E -
Parameters:: fromIndex -; toIndex -; filter -
Returns:
Throws:: E - the e; E extends Exception

filter

public <E extends Exception> CharList filter(Try.CharPredicate<E> filter)
                                      throws E extends Exception

Type Parameters:: E -
Parameters:: filter -
Returns:: a new List with the elements match the provided predicate.
Throws:: E - the e; E extends Exception

filter

public <E extends Exception> CharList filter(int fromIndex,
                                             int toIndex,
                                             Try.CharPredicate<E> filter)
                                      throws E extends Exception

Type Parameters:: E -
Parameters:: fromIndex -; toIndex -; filter -
Returns:
Throws:: E - the e; E extends Exception

filter

public <E extends Exception> CharList filter(Try.CharPredicate<E> filter,
                                             int max)
                                      throws E extends Exception

Type Parameters:: E -
Parameters:: filter -; max -
Returns:: a new List with the elements match the provided predicate.
Throws:: E - the e; E extends Exception

filter

public <E extends Exception> CharList filter(int fromIndex,
                                             int toIndex,
                                             Try.CharPredicate<E> filter,
                                             int max)
                                      throws E extends Exception

Type Parameters:: E -
Parameters:: fromIndex -; toIndex -; filter -; max -
Returns:
Throws:: E - the e; E extends Exception

map

public <E extends Exception> CharList map(Try.CharUnaryOperator<E> mapper)
                                   throws E extends Exception

Type Parameters:: E -
Parameters:: mapper -
Returns:
Throws:: E - the e; E extends Exception

map

public <E extends Exception> CharList map(int fromIndex,
                                          int toIndex,
                                          Try.CharUnaryOperator<E> mapper)
                                   throws E extends Exception

Type Parameters:: E -
Parameters:: fromIndex -; toIndex -; mapper -
Returns:
Throws:: E - the e; E extends Exception

mapToObj

public <T,E extends Exception> List<T> mapToObj(Try.CharFunction<? extends T,E> mapper)
                                         throws E extends Exception

Map to obj.

Type Parameters:: T -; E -
Parameters:: mapper -
Returns:
Throws:: E - the e; E extends Exception

mapToObj

public <T,E extends Exception> List<T> mapToObj(int fromIndex,
                                                int toIndex,
                                                Try.CharFunction<? extends T,E> mapper)
                                         throws E extends Exception

Map to obj.

Type Parameters:: T -; E -
Parameters:: fromIndex -; toIndex -; mapper -
Returns:
Throws:: E - the e; E extends Exception

reduce

public <E extends Exception> u.OptionalChar reduce(Try.CharBinaryOperator<E> accumulator)
                                            throws E extends Exception

This is equivalent to:

 
    if (isEmpty()) {
        return OptionalChar.empty();
    }
 
    char result = elementData[0];
 
    for (int i = 1; i < size; i++) {
        result = accumulator.applyAsChar(result, elementData[i]);
    }
 
    return OptionalChar.of(result);

Type Parameters:: E -
Parameters:: accumulator -
Returns:
Throws:: E - the e; E extends Exception

reduce

public <E extends Exception> char reduce(char identity,
                                         Try.CharBinaryOperator<E> accumulator)
                                  throws E extends Exception

This is equivalent to:

 
     if (isEmpty()) {
         return identity;
     }
 
     char result = identity;
 
     for (int i = 0; i < size; i++) {
         result = accumulator.applyAsChar(result, elementData[i]);
    }
 
     return result;

Type Parameters:: E -
Parameters:: identity -; accumulator -
Returns:
Throws:: E - the e; E extends Exception

hasDuplicates
```
public boolean hasDuplicates()
```
Checks for duplicates.

Specified by:

hasDuplicates in class PrimitiveList<Character,char[],CharList>

Returns:

true, if successful

distinct
```
public CharList distinct(int fromIndex,
                         int toIndex)
```
Specified by:

distinct in class PrimitiveList<Character,char[],CharList>

Parameters:

fromIndex -

toIndex -

Returns:

sort
```
public void sort()
```
Sort.

Specified by:

sort in class PrimitiveList<Character,char[],CharList>

parallelSort
```
public void parallelSort()
```
Parallel sort.

reverseSort
```
public void reverseSort()
```
Reverse sort.

binarySearch
```
public int binarySearch(char key)
```
This List should be sorted first.

Parameters:

key -

Returns:

binarySearch

public int binarySearch(int fromIndex,
                        int toIndex,
                        char key)

This List should be sorted first.

Parameters:: fromIndex -; toIndex -; key -
Returns:

reverse
```
public void reverse()
```
Reverse.

Specified by:

reverse in class PrimitiveList<Character,char[],CharList>

reverse
```
public void reverse(int fromIndex,
                    int toIndex)
```
Specified by:

reverse in class PrimitiveList<Character,char[],CharList>

Parameters:

fromIndex -

toIndex -

rotate
```
public void rotate(int distance)
```
Specified by:

rotate in class PrimitiveList<Character,char[],CharList>

Parameters:

distance -

shuffle
```
public void shuffle()
```
Shuffle.

Specified by:

shuffle in class PrimitiveList<Character,char[],CharList>

shuffle
```
public void shuffle(Random rnd)
```
Specified by:

shuffle in class PrimitiveList<Character,char[],CharList>

Parameters:

rnd -

swap
```
public void swap(int i,
                 int j)
```
Specified by:

swap in class PrimitiveList<Character,char[],CharList>

Parameters:

i -

j -

copy
```
public CharList copy()
```
Specified by:

copy in class PrimitiveList<Character,char[],CharList>

Returns:

copy
```
public CharList copy(int fromIndex,
                     int toIndex)
```
Specified by:

copy in class PrimitiveList<Character,char[],CharList>

Parameters:

fromIndex -

toIndex -

Returns:

copy
```
public CharList copy(int from,
                     int to,
                     int step)
```
Specified by:

copy in class PrimitiveList<Character,char[],CharList>

Parameters:

from -

to -

step -

Returns:

See Also:

CommonUtil.copyOfRange(int[], int, int, int)

split
```
public List<CharList> split(int fromIndex,
                            int toIndex,
                            int chunkSize)
```
Returns List of CharList with consecutive sub sequences of the elements, each of the same size (the final sequence may be smaller).

Specified by:

split in class PrimitiveList<Character,char[],CharList>

Parameters:

fromIndex -

toIndex -

chunkSize - the desired size of each sub sequence (the last may be smaller).

Returns:

join
```
public String join(int fromIndex,
                   int toIndex,
                   char delimiter)
```
Specified by:

join in class PrimitiveList<Character,char[],CharList>

Parameters:

fromIndex -

toIndex -

delimiter -

Returns:

join

public String join(int fromIndex,
                   int toIndex,
                   String delimiter)

Specified by:: join in class PrimitiveList<Character,char[],CharList>
Parameters:: fromIndex -; toIndex -; delimiter -
Returns:

trimToSize
```
public CharList trimToSize()
```
Trim to size.

Specified by:

trimToSize in class PrimitiveList<Character,char[],CharList>

Returns:

clear
```
public void clear()
```
Clear.

Specified by:

clear in class PrimitiveList<Character,char[],CharList>

isEmpty
```
public boolean isEmpty()
```
Checks if is empty.

Specified by:

isEmpty in class PrimitiveList<Character,char[],CharList>

Returns:

true, if is empty

size
```
public int size()
```
Specified by:

size in class PrimitiveList<Character,char[],CharList>

Returns:

boxed
```
public List<Character> boxed()
```
Returns:

boxed

public List<Character> boxed(int fromIndex,
                             int toIndex)

Parameters:: fromIndex -; toIndex -
Returns:

toArray
```
public char[] toArray()
```
Specified by:

toArray in class PrimitiveList<Character,char[],CharList>

Returns:

toIntList
```
public IntList toIntList()
```
To int list.

Returns:

toCollection

public <C extends Collection<Character>> C toCollection(int fromIndex,
                                                        int toIndex,
                                                        IntFunction<? extends C> supplier)

Specified by:: toCollection in class PrimitiveList<Character,char[],CharList>
Type Parameters:: C -
Parameters:: fromIndex -; toIndex -; supplier -
Returns:

toMultiset

public Multiset<Character> toMultiset(int fromIndex,
                                      int toIndex,
                                      IntFunction<Multiset<Character>> supplier)

Specified by:: toMultiset in class PrimitiveList<Character,char[],CharList>
Parameters:: fromIndex -; toIndex -; supplier -
Returns:

toMap

public <K,V,E extends Exception,E2 extends Exception> Map<K,V> toMap(Try.CharFunction<? extends K,E> keyMapper,
                                                                     Try.CharFunction<? extends V,E2> valueMapper)
                                                              throws E extends Exception,
                                                                     E2 extends Exception

Type Parameters:: K - the key type; V - the value type; E -; E2 -
Parameters:: keyMapper -; valueMapper -
Returns:
Throws:: E - the e; E2 - the e2; E extends Exception

toMap

public <K,V,M extends Map<K,V>,E extends Exception,E2 extends Exception> M toMap(Try.CharFunction<? extends K,E> keyMapper,
                                                                                 Try.CharFunction<? extends V,E2> valueMapper,
                                                                                 IntFunction<? extends M> mapFactory)
                                                                          throws E extends Exception,
                                                                                 E2 extends Exception

Type Parameters:: K - the key type; V - the value type; M -; E -; E2 -
Parameters:: keyMapper -; valueMapper -; mapFactory -
Returns:
Throws:: E - the e; E2 - the e2; E extends Exception

toMap

public <K,V,E extends Exception,E2 extends Exception,E3 extends Exception> Map<K,V> toMap(Try.CharFunction<? extends K,E> keyMapper,
                                                                                          Try.CharFunction<? extends V,E2> valueMapper,
                                                                                          Try.BinaryOperator<V,E3> mergeFunction)
                                                                                   throws E extends Exception,
                                                                                          E2 extends Exception,
                                                                                          E3 extends Exception

Type Parameters:: K - the key type; V - the value type; E -; E2 -; E3 -
Parameters:: keyMapper -; valueMapper -; mergeFunction -
Returns:
Throws:: E - the e; E2 - the e2; E3 - the e3; E extends Exception

toMap

public <K,V,M extends Map<K,V>,E extends Exception,E2 extends Exception,E3 extends Exception> M toMap(Try.CharFunction<? extends K,E> keyMapper,
                                                                                                      Try.CharFunction<? extends V,E2> valueMapper,
                                                                                                      Try.BinaryOperator<V,E3> mergeFunction,
                                                                                                      IntFunction<? extends M> mapFactory)
                                                                                               throws E extends Exception,
                                                                                                      E2 extends Exception,
                                                                                                      E3 extends Exception

Type Parameters:: K - the key type; V - the value type; M -; E -; E2 -; E3 -
Parameters:: keyMapper -; valueMapper -; mergeFunction -; mapFactory -
Returns:
Throws:: E - the e; E2 - the e2; E3 - the e3; E extends Exception

toMap

public <K,A,D,E extends Exception> Map<K,D> toMap(Try.CharFunction<? extends K,E> keyMapper,
                                                  Collector<Character,A,D> downstream)
                                           throws E extends Exception

Type Parameters:: K - the key type; A -; D -; E -
Parameters:: keyMapper -; downstream -
Returns:
Throws:: E - the e; E extends Exception

toMap

public <K,A,D,M extends Map<K,D>,E extends Exception> M toMap(Try.CharFunction<? extends K,E> keyMapper,
                                                              Collector<Character,A,D> downstream,
                                                              IntFunction<? extends M> mapFactory)
                                                       throws E extends Exception

Type Parameters:: K - the key type; A -; D -; M -; E -
Parameters:: keyMapper -; downstream -; mapFactory -
Returns:
Throws:: E - the e; E extends Exception

iterator
```
public CharIterator iterator()
```
Returns:

stream
```
public CharStream stream()
```
Returns:

stream

public CharStream stream(int fromIndex,
                         int toIndex)

Parameters:: fromIndex -; toIndex -
Returns:

apply
```
public <R,E extends Exception> R apply(Try.Function<? super CharList,R,E> func)
                                throws E extends Exception
```
Specified by:

apply in class PrimitiveList<Character,char[],CharList>

Type Parameters:

R -

E -

Parameters:

func -

Returns:

Throws:

E - the e

E extends Exception

applyIfNotEmpty

public <R,E extends Exception> u.Optional<R> applyIfNotEmpty(Try.Function<? super CharList,R,E> func)
                                                      throws E extends Exception

Apply if not empty.

Specified by:: applyIfNotEmpty in class PrimitiveList<Character,char[],CharList>
Type Parameters:: R -; E -
Parameters:: func -
Returns:
Throws:: E - the e; E extends Exception

accept

public <E extends Exception> void accept(Try.Consumer<? super CharList,E> action)
                                  throws E extends Exception

Specified by:: accept in class PrimitiveList<Character,char[],CharList>
Type Parameters:: E -
Parameters:: action -
Throws:: E - the e; E extends Exception

acceptIfNotEmpty
```
public <E extends Exception> void acceptIfNotEmpty(Try.Consumer<? super CharList,E> action)
                                            throws E extends Exception
```
Accept if not empty.

Specified by:

acceptIfNotEmpty in class PrimitiveList<Character,char[],CharList>

Type Parameters:

E -

Parameters:

action -

Throws:

E - the e

E extends Exception

hashCode
```
public int hashCode()
```
Overrides:

hashCode in class Object

Returns:

equals
```
public boolean equals(Object obj)
```
Overrides:

equals in class Object

Parameters:

obj -

Returns:

true, if successful

toString
```
public String toString()
```
Overrides:

toString in class Object

Returns:

Class CharList

Constructor Summary

Method Summary

Methods inherited from class com.landawn.abacus.util.PrimitiveList

Methods inherited from class java.lang.Object

Constructor Detail

CharList

CharList

CharList

CharList

Method Detail

of

of

copyOf

copyOf

from

from

from

from

range

range

rangeClosed

rangeClosed

repeat

random

random

random

array

get

set

add

add

addAll

addAll

addAll

addAll

remove

removeAllOccurrences

removeAll

removeAll

removeIf

retainAll

retainAll

delete

deleteAll

deleteRange

replaceAll

replaceAll

replaceIf

fill

fill

contains

containsAll

containsAll

containsAny

containsAny

disjoint

disjoint

intersection

intersection

difference

difference

symmetricDifference

symmetricDifference

occurrencesOf

indexOf

indexOf

lastIndexOf

lastIndexOf

min

min

median

median

max

max

kthLargest

kthLargest

sum

sum

average