IntList (abacus-util 1.21.8 API)

java.lang.Object
- com.landawn.abacus.util.PrimitiveList<Integer,int[],IntList>
- - com.landawn.abacus.util.IntList

All Implemented Interfaces:

Serializable, RandomAccess
```
public final class IntList
extends PrimitiveList<Integer,int[],IntList>
```
Since:

0.8

Author:

Haiyang Li

See Also:

Serialized Form

Constructor Summary

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

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`<E extends Exception> void`	`accept(Throwables.Consumer<? super IntList,E> action)`
`<E extends Exception> If.OrElse`	`acceptIfNotEmpty(Throwables.Consumer<? super IntList,E> action)` Accept if not empty.
`void`	`add(int e)`
`void`	`add(int index, int e)`
`boolean`	`addAll(int[] a)` Adds the all.
`boolean`	`addAll(int index, int[] a)` Adds the all.
`boolean`	`addAll(int index, IntList c)` Adds the all.
`boolean`	`addAll(IntList c)` Adds the all.
`<E extends Exception> boolean`	`allMatch(int fromIndex, int toIndex, Throwables.IntPredicate<E> filter)`
`<E extends Exception> boolean`	`allMatch(Throwables.IntPredicate<E> filter)` Returns whether all elements of this List match the provided predicate.
`<E extends Exception> boolean`	`anyMatch(int fromIndex, int toIndex, Throwables.IntPredicate<E> filter)`
`<E extends Exception> boolean`	`anyMatch(Throwables.IntPredicate<E> filter)` Returns whether any elements of this List match the provided predicate.
`<R,E extends Exception> R`	`apply(Throwables.Function<? super IntList,R,E> func)`
`<R,E extends Exception> u.Optional<R>`	`applyIfNotEmpty(Throwables.Function<? super IntList,R,E> func)` Apply if not empty.
`int[]`	`array()` Returns the original element array without copying.
`u.OptionalDouble`	`average()`
`u.OptionalDouble`	`average(int fromIndex, int toIndex)`
`int`	`binarySearch(int key)` This List should be sorted first.
`int`	`binarySearch(int fromIndex, int toIndex, int key)` This List should be sorted first.
`List<Integer>`	`boxed()`
`List<Integer>`	`boxed(int fromIndex, int toIndex)`
`void`	`clear()` Clear.
`boolean`	`contains(int e)`
`boolean`	`containsAll(int[] a)`
`boolean`	`containsAll(IntList c)`
`boolean`	`containsAny(int[] a)`
`boolean`	`containsAny(IntList c)`
`IntList`	`copy()`
`IntList`	`copy(int fromIndex, int toIndex)`
`IntList`	`copy(int from, int to, int step)`
`static IntList`	`copyOf(int[] a)`
`static IntList`	`copyOf(int[] a, int fromIndex, int toIndex)`
`<E extends Exception> int`	`count(int fromIndex, int toIndex, Throwables.IntPredicate<E> filter)`
`<E extends Exception> int`	`count(Throwables.IntPredicate<E> filter)`
`int`	`delete(int index)`
`void`	`deleteAll(int... indices)`
`void`	`deleteRange(int fromIndex, int toIndex)`
`IntList`	`difference(int[] a)`
`IntList`	`difference(IntList b)` Returns a new list with all the elements in `b` removed by occurrences.
`boolean`	`disjoint(int[] b)`
`boolean`	`disjoint(IntList c)`
`IntList`	`distinct(int fromIndex, int toIndex)`
`boolean`	`equals(Object obj)`
`void`	`fill(int val)`
`void`	`fill(int fromIndex, int toIndex, int val)`
`<E extends Exception> IntList`	`filter(int fromIndex, int toIndex, Throwables.IntPredicate<E> filter)`
`<E extends Exception> IntList`	`filter(int fromIndex, int toIndex, Throwables.IntPredicate<E> filter, int max)`
`<E extends Exception> IntList`	`filter(Throwables.IntPredicate<E> filter)`
`<E extends Exception> IntList`	`filter(Throwables.IntPredicate<E> filter, int max)`
`<E extends Exception> u.OptionalInt`	`findFirst(Throwables.IntPredicate<E> predicate)`
`<E extends Exception> u.OptionalInt`	`findFirstIndex(Throwables.IntPredicate<E> predicate)` Find first index.
`<E extends Exception> u.OptionalInt`	`findLast(Throwables.IntPredicate<E> predicate)`
`<E extends Exception> u.OptionalInt`	`findLastIndex(Throwables.IntPredicate<E> predicate)` Find last index.
`u.OptionalInt`	`first()`
`<E extends Exception> void`	`forEach(int fromIndex, int toIndex, Throwables.IntConsumer<E> action)`
`<E extends Exception> void`	`forEach(Throwables.IntConsumer<E> action)`
`<E extends Exception> void`	`forEachIndexed(int fromIndex, int toIndex, Throwables.IndexedIntConsumer<E> action)`
`<E extends Exception> void`	`forEachIndexed(Throwables.IndexedIntConsumer<E> action)`
`static IntList`	`from(Collection<Integer> c)`
`static IntList`	`from(Collection<Integer> c, int defaultForNull)`
`static IntList`	`from(Collection<Integer> c, int fromIndex, int toIndex)`
`static IntList`	`from(Collection<Integer> c, int fromIndex, int toIndex, int defaultForNull)`
`int`	`get(int index)`
`boolean`	`hasDuplicates()` Checks for duplicates.
`int`	`hashCode()`
`int`	`indexOf(int e)`
`int`	`indexOf(int fromIndex, int e)`
`IntList`	`intersection(int[] a)`
`IntList`	`intersection(IntList b)` Returns a new list with all the elements occurred in both `a` and `b` by occurrences.
`boolean`	`isEmpty()` Checks if is empty.
`IntIterator`	`iterator()`
`String`	`join(int fromIndex, int toIndex, char delimiter)`
`String`	`join(int fromIndex, int toIndex, String delimiter)`
`u.OptionalInt`	`kthLargest(int k)`
`u.OptionalInt`	`kthLargest(int fromIndex, int toIndex, int k)`
`u.OptionalInt`	`last()`
`int`	`lastIndexOf(int e)` Last index of.
`int`	`lastIndexOf(int fromIndex, int e)` Last index of.
`<E extends Exception> IntList`	`map(int fromIndex, int toIndex, Throwables.IntUnaryOperator<E> mapper)`
`<E extends Exception> IntList`	`map(Throwables.IntUnaryOperator<E> mapper)`
`<T,E extends Exception> List<T>`	`mapToObj(int fromIndex, int toIndex, Throwables.IntFunction<? extends T,E> mapper)` Map to obj.
`<T,E extends Exception> List<T>`	`mapToObj(Throwables.IntFunction<? extends T,E> mapper)` Map to obj.
`u.OptionalInt`	`max()`
`u.OptionalInt`	`max(int fromIndex, int toIndex)`
`u.OptionalInt`	`median()`
`u.OptionalInt`	`median(int fromIndex, int toIndex)`
`u.OptionalInt`	`min()`
`u.OptionalInt`	`min(int fromIndex, int toIndex)`
`<E extends Exception> boolean`	`noneMatch(int fromIndex, int toIndex, Throwables.IntPredicate<E> filter)`
`<E extends Exception> boolean`	`noneMatch(Throwables.IntPredicate<E> filter)` Returns whether no elements of this List match the provided predicate.
`int`	`occurrencesOf(int objectToFind)`
`static IntList`	`of(int... a)`
`static IntList`	`of(int[] a, int size)`
`void`	`parallelSort()` Parallel sort.
`static IntList`	`random(int len)`
`static IntList`	`random(int startInclusive, int endExclusive, int len)`
`static IntList`	`range(int startInclusive, int endExclusive)`
`static IntList`	`range(int startInclusive, int endExclusive, int by)`
`static IntList`	`rangeClosed(int startInclusive, int endInclusive)`
`static IntList`	`rangeClosed(int startInclusive, int endInclusive, int by)`
`<E extends Exception> int`	`reduce(int identity, Throwables.IntBinaryOperator<E> accumulator)` This is equivalent to:
`<E extends Exception> u.OptionalInt`	`reduce(Throwables.IntBinaryOperator<E> accumulator)` This is equivalent to:
`boolean`	`remove(int e)`
`boolean`	`removeAll(int[] a)` Removes the all.
`boolean`	`removeAll(IntList c)` Removes the all.
`boolean`	`removeAllOccurrences(int e)` Removes the all occurrences.
`<E extends Exception> boolean`	`removeIf(Throwables.IntPredicate<E> p)` Removes the if.
`static IntList`	`repeat(int element, int len)`
`int`	`replaceAll(int oldVal, int newVal)`
`<E extends Exception> void`	`replaceAll(Throwables.IntUnaryOperator<E> operator)`
`<E extends Exception> boolean`	`replaceIf(Throwables.IntPredicate<E> predicate, int newValue)`
`boolean`	`retainAll(int[] a)`
`boolean`	`retainAll(IntList c)`
`void`	`reverse()` Reverse.
`void`	`reverse(int fromIndex, int toIndex)`
`void`	`reverseSort()` Reverse sort.
`void`	`rotate(int distance)`
`int`	`set(int index, int e)`
`void`	`shuffle()` Shuffle.
`void`	`shuffle(Random rnd)`
`int`	`size()`
`void`	`sort()` Sort.
`List<IntList>`	`split(int fromIndex, int toIndex, int chunkSize)` Returns List of `IntList` with consecutive sub sequences of the elements, each of the same size (the final sequence may be smaller).
`IntStream`	`stream()`
`IntStream`	`stream(int fromIndex, int toIndex)`
`int`	`sum()`
`int`	`sum(int fromIndex, int toIndex)`
`void`	`swap(int i, int j)`
`IntList`	`symmetricDifference(int[] a)`
`IntList`	`symmetricDifference(IntList b)` IntList a = IntList.of(0, 1, 2, 2, 3); IntList b = IntList.of(2, 5, 1); IntList c = a.symmetricDifference(b); // The elements c in a will be: [0, 2, 3, 5].
`int[]`	`toArray()`
`<C extends Collection<Integer>> C`	`toCollection(int fromIndex, int toIndex, IntFunction<? extends C> supplier)`
`DoubleList`	`toDoubleList()` To double list.
`FloatList`	`toFloatList()` To float list.
`LongList`	`toLongList()` To long list.
`<K,A,D,E extends Exception> Map<K,D>`	`toMap(Throwables.IntFunction<? extends K,E> keyMapper, Collector<Integer,A,D> downstream)`
`<K,A,D,M extends Map<K,D>,E extends Exception> M`	`toMap(Throwables.IntFunction<? extends K,E> keyMapper, Collector<Integer,A,D> downstream, IntFunction<? extends M> mapFactory)`
`<K,V,E extends Exception,E2 extends Exception> Map<K,V>`	`toMap(Throwables.IntFunction<? extends K,E> keyMapper, Throwables.IntFunction<? extends V,E2> valueMapper)`
`<K,V,M extends Map<K,V>,E extends Exception,E2 extends Exception> M`	`toMap(Throwables.IntFunction<? extends K,E> keyMapper, Throwables.IntFunction<? extends V,E2> valueMapper, IntFunction<? extends M> mapFactory)`
`<K,V,E extends Exception,E2 extends Exception,E3 extends Exception> Map<K,V>`	`toMap(Throwables.IntFunction<? extends K,E> keyMapper, Throwables.IntFunction<? extends V,E2> valueMapper, Throwables.BinaryOperator<V,E3> mergeFunction)`
`<K,V,M extends Map<K,V>,E extends Exception,E2 extends Exception,E3 extends Exception> M`	`toMap(Throwables.IntFunction<? extends K,E> keyMapper, Throwables.IntFunction<? extends V,E2> valueMapper, Throwables.BinaryOperator<V,E3> mergeFunction, IntFunction<? extends M> mapFactory)`
`Multiset<Integer>`	`toMultiset(int fromIndex, int toIndex, IntFunction<Multiset<Integer>> supplier)`
`IntList`	`top(int n)`
`IntList`	`top(int n, Comparator<? super Integer> cmp)`
`IntList`	`top(int fromIndex, int toIndex, int n)`
`IntList`	`top(int fromIndex, int toIndex, int n, Comparator<? super Integer> cmp)`
`String`	`toString()`
`IntList`	`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
- IntList
```
public IntList()
```
- IntList
```
public IntList(int initialCapacity)
```
- IntList
```
public IntList(int[] a)
```
  The specified array is used as the element array for this list without copying action.
  
  Parameters:
  
  a -
- IntList
```
public IntList(int[] a,
               int size)
```

Method Detail

of

@SafeVarargs
public static IntList of(int... a)

Parameters:: a -
Returns:

of

public static IntList of(int[] a,
                         int size)

Parameters:: a -; size -
Returns:

copyOf

public static IntList copyOf(int[] a)

Parameters:: a -
Returns:

copyOf

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

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

from

public static IntList from(Collection<Integer> c)

Parameters:: c -
Returns:

from

public static IntList from(Collection<Integer> c,
                           int defaultForNull)

Parameters:: c -; defaultForNull -
Returns:

from

public static IntList from(Collection<Integer> c,
                           int fromIndex,
                           int toIndex)

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

from

public static IntList from(Collection<Integer> c,
                           int fromIndex,
                           int toIndex,
                           int defaultForNull)

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

range

public static IntList range(int startInclusive,
                            int endExclusive)

Parameters:: startInclusive -; endExclusive -
Returns:

range

public static IntList range(int startInclusive,
                            int endExclusive,
                            int by)

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

rangeClosed

public static IntList rangeClosed(int startInclusive,
                                  int endInclusive)

Parameters:: startInclusive -; endInclusive -
Returns:

rangeClosed

public static IntList rangeClosed(int startInclusive,
                                  int endInclusive,
                                  int by)

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

repeat

public static IntList repeat(int element,
                             int len)

Parameters:: element -; len -
Returns:

random

public static IntList random(int len)

Parameters:: len -
Returns:

random

public static IntList random(int startInclusive,
                             int endExclusive,
                             int len)

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

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

Specified by:

array in class PrimitiveList<Integer,int[],IntList>

Returns:

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

index -

Returns:

set

public int set(int index,
               int e)

Parameters:: index -; e -
Returns:

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

e -

add

public void add(int index,
                int e)

Parameters:: index -; e -

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

Parameters:

c -

Returns:

true, if successful

addAll

public boolean addAll(int index,
                      IntList c)

Adds the all.

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

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

Specified by:

addAll in class PrimitiveList<Integer,int[],IntList>

Parameters:

a -

Returns:

true, if successful

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

Specified by:

addAll in class PrimitiveList<Integer,int[],IntList>

Parameters:

index -

a -

Returns:

true, if successful

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

e -

Returns:

true if this list contained the specified element

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

Parameters:

e -

Returns:

true if this list contained the specified element

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

Parameters:

c -

Returns:

true, if successful

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

Specified by:

removeAll in class PrimitiveList<Integer,int[],IntList>

Parameters:

a -

Returns:

true, if successful

removeIf

public <E extends Exception> boolean removeIf(Throwables.IntPredicate<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(IntList c)
```
Parameters:

c -

Returns:

true, if successful

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

a -

Returns:

true, if successful

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

index -

Returns:

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

deleteAll in class PrimitiveList<Integer,int[],IntList>

Parameters:

indices -

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

deleteRange in class PrimitiveList<Integer,int[],IntList>

Parameters:

fromIndex -

toIndex -

replaceAll

public int replaceAll(int oldVal,
                      int newVal)

Parameters:: oldVal -; newVal -
Returns:

replaceAll

public <E extends Exception> void replaceAll(Throwables.IntUnaryOperator<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(Throwables.IntPredicate<E> predicate,
                                               int 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(int val)
```
Parameters:

val -

fill

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

Parameters:: fromIndex -; toIndex -; val -

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

e -

Returns:

true, if successful

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

c -

Returns:

true, if successful

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

containsAll in class PrimitiveList<Integer,int[],IntList>

Parameters:

a -

Returns:

true, if successful

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

c -

Returns:

true, if successful

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

containsAny in class PrimitiveList<Integer,int[],IntList>

Parameters:

a -

Returns:

true, if successful

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

c -

Returns:

true, if successful

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

disjoint in class PrimitiveList<Integer,int[],IntList>

Parameters:

b -

Returns:

true, if successful

intersection

public IntList intersection(IntList b)

Returns a new list with all the elements occurred in both a and b by occurrences.

 IntList a = IntList.of(0, 1, 2, 2, 3);
 IntList b = IntList.of(2, 5, 1);
 a.retainAll(b); // The elements remained in a will be: [1, 2, 2].

 IntList a = IntList.of(0, 1, 2, 2, 3);
 IntList b = IntList.of(2, 5, 1);
 IntList c = a.intersection(b); // The elements c in a will be: [1, 2].

Parameters:: b -
Returns:

intersection
```
public IntList intersection(int[] a)
```
Parameters:

a -

Returns:

difference

public IntList difference(IntList b)

Returns a new list with all the elements in b removed by occurrences.

 IntList a = IntList.of(0, 1, 2, 2, 3);
 IntList b = IntList.of(2, 5, 1);
 a.removeAll(b); // The elements remained in a will be: [0, 3].

 IntList a = IntList.of(0, 1, 2, 2, 3);
 IntList b = IntList.of(2, 5, 1);
 IntList c = a.difference(b); // The elements c in a will be: [0, 2, 3].

Parameters:: b -
Returns:

difference
```
public IntList difference(int[] a)
```
Parameters:

a -

Returns:

symmetricDifference

public IntList symmetricDifference(IntList b)

 IntList a = IntList.of(0, 1, 2, 2, 3);
 IntList b = IntList.of(2, 5, 1);
 IntList c = a.symmetricDifference(b); // The elements c in a will be: [0, 2, 3, 5].

Parameters:: b -
Returns:: this.difference(b).addAll(b.difference(this))
See Also:: difference(IntList)

symmetricDifference

public IntList symmetricDifference(int[] a)

Parameters:: a -
Returns:

occurrencesOf

public int occurrencesOf(int objectToFind)

Parameters:: objectToFind -
Returns:

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

e -

Returns:

indexOf

public int indexOf(int fromIndex,
                   int e)

Parameters:: fromIndex -; e -
Returns:

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

Parameters:

e -

Returns:

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

Parameters:

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

e -

Returns:

min
```
public u.OptionalInt min()
```

min

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

Parameters:: fromIndex -; toIndex -
Returns:

median
```
public u.OptionalInt median()
```

median

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

Parameters:: fromIndex -; toIndex -
Returns:

max
```
public u.OptionalInt max()
```

max

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

Parameters:: fromIndex -; toIndex -
Returns:

kthLargest

public u.OptionalInt kthLargest(int k)

Parameters:: k -
Returns:

kthLargest

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

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

sum
```
public int sum()
```

sum

public int sum(int fromIndex,
               int toIndex)

Parameters:: fromIndex -; toIndex -
Returns:

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

average

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

Parameters:: fromIndex -; toIndex -
Returns:

forEach

public <E extends Exception> void forEach(Throwables.IntConsumer<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,
                                          Throwables.IntConsumer<E> action)
                                   throws E extends Exception

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

forEachIndexed

public <E extends Exception> void forEachIndexed(Throwables.IndexedIntConsumer<E> action)
                                          throws E extends Exception

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

forEachIndexed

public <E extends Exception> void forEachIndexed(int fromIndex,
                                                 int toIndex,
                                                 Throwables.IndexedIntConsumer<E> action)
                                          throws E extends Exception

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

first
```
public u.OptionalInt first()
```

last
```
public u.OptionalInt last()
```

findFirst

public <E extends Exception> u.OptionalInt findFirst(Throwables.IntPredicate<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.OptionalInt findLast(Throwables.IntPredicate<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(Throwables.IntPredicate<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(Throwables.IntPredicate<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(Throwables.IntPredicate<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,
                                              Throwables.IntPredicate<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(Throwables.IntPredicate<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,
                                              Throwables.IntPredicate<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(Throwables.IntPredicate<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,
                                               Throwables.IntPredicate<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(Throwables.IntPredicate<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,
                                       Throwables.IntPredicate<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> IntList filter(Throwables.IntPredicate<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> IntList filter(int fromIndex,
                                            int toIndex,
                                            Throwables.IntPredicate<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> IntList filter(Throwables.IntPredicate<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> IntList filter(int fromIndex,
                                            int toIndex,
                                            Throwables.IntPredicate<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> IntList map(Throwables.IntUnaryOperator<E> mapper)
                                  throws E extends Exception

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

map

public <E extends Exception> IntList map(int fromIndex,
                                         int toIndex,
                                         Throwables.IntUnaryOperator<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(Throwables.IntFunction<? 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,
                                                Throwables.IntFunction<? 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.OptionalInt reduce(Throwables.IntBinaryOperator<E> accumulator)
                                           throws E extends Exception

This is equivalent to:

 
    if (isEmpty()) {
        return OptionalInt.empty();
    }

    int result = elementData[0];

    for (int i = 1; i < size; i++) {
        result = accumulator.applyAsInt(result, elementData[i]);
    }

    return OptionalInt.of(result);

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

reduce

public <E extends Exception> int reduce(int identity,
                                        Throwables.IntBinaryOperator<E> accumulator)
                                 throws E extends Exception

This is equivalent to:

 
     if (isEmpty()) {
         return identity;
     }

     int result = identity;

     for (int i = 0; i < size; i++) {
         result = accumulator.applyAsInt(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<Integer,int[],IntList>

Returns:

true, if successful

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

distinct in class PrimitiveList<Integer,int[],IntList>

Parameters:

fromIndex -

toIndex -

Returns:

top
```
public IntList top(int n)
```
Parameters:

n -

Returns:

top

public IntList top(int fromIndex,
                   int toIndex,
                   int n)

Parameters:: fromIndex -; toIndex -; n -
Returns:

top

public IntList top(int n,
                   Comparator<? super Integer> cmp)

Parameters:: n -; cmp -
Returns:

top

public IntList top(int fromIndex,
                   int toIndex,
                   int n,
                   Comparator<? super Integer> cmp)

Parameters:: fromIndex -; toIndex -; n -; cmp -
Returns:

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

Specified by:

sort in class PrimitiveList<Integer,int[],IntList>

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

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

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

Parameters:

key -

Returns:

binarySearch

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

This List should be sorted first.

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

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

Specified by:

reverse in class PrimitiveList<Integer,int[],IntList>

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

reverse in class PrimitiveList<Integer,int[],IntList>

Parameters:

fromIndex -

toIndex -

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

rotate in class PrimitiveList<Integer,int[],IntList>

Parameters:

distance -

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

Specified by:

shuffle in class PrimitiveList<Integer,int[],IntList>

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

shuffle in class PrimitiveList<Integer,int[],IntList>

Parameters:

rnd -

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

swap in class PrimitiveList<Integer,int[],IntList>

Parameters:

i -

j -

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

copy in class PrimitiveList<Integer,int[],IntList>

Returns:

a copy of this List

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

copy in class PrimitiveList<Integer,int[],IntList>

Parameters:

fromIndex -

toIndex -

Returns:

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

copy in class PrimitiveList<Integer,int[],IntList>

Parameters:

from -

to -

step -

Returns:

See Also:

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

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

Specified by:

split in class PrimitiveList<Integer,int[],IntList>

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<Integer,int[],IntList>

Parameters:

fromIndex -

toIndex -

delimiter -

Returns:

join

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

Specified by:: join in class PrimitiveList<Integer,int[],IntList>
Parameters:: fromIndex -; toIndex -; delimiter -
Returns:

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

Specified by:

trimToSize in class PrimitiveList<Integer,int[],IntList>

Returns:

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

Specified by:

clear in class PrimitiveList<Integer,int[],IntList>

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

Specified by:

isEmpty in class PrimitiveList<Integer,int[],IntList>

Returns:

true, if is empty

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

size in class PrimitiveList<Integer,int[],IntList>

boxed
```
public List<Integer> boxed()
```

boxed

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

Parameters:: fromIndex -; toIndex -
Returns:

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

toArray in class PrimitiveList<Integer,int[],IntList>

toLongList
```
public LongList toLongList()
```
To long list.

Returns:

toFloatList
```
public FloatList toFloatList()
```
To float list.

Returns:

toDoubleList
```
public DoubleList toDoubleList()
```
To double list.

Returns:

toCollection

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

Specified by:: toCollection in class PrimitiveList<Integer,int[],IntList>
Type Parameters:: C -
Parameters:: fromIndex -; toIndex -; supplier -
Returns:

toMultiset

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

Specified by:: toMultiset in class PrimitiveList<Integer,int[],IntList>
Parameters:: fromIndex -; toIndex -; supplier -
Returns:

toMap

public <K,V,E extends Exception,E2 extends Exception> Map<K,V> toMap(Throwables.IntFunction<? extends K,E> keyMapper,
                                                                     Throwables.IntFunction<? 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(Throwables.IntFunction<? extends K,E> keyMapper,
                                                                                 Throwables.IntFunction<? 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(Throwables.IntFunction<? extends K,E> keyMapper,
                                                                                          Throwables.IntFunction<? extends V,E2> valueMapper,
                                                                                          Throwables.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(Throwables.IntFunction<? extends K,E> keyMapper,
                                                                                                      Throwables.IntFunction<? extends V,E2> valueMapper,
                                                                                                      Throwables.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(Throwables.IntFunction<? extends K,E> keyMapper,
                                                  Collector<Integer,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(Throwables.IntFunction<? extends K,E> keyMapper,
                                                              Collector<Integer,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 IntIterator iterator()
```

stream
```
public IntStream stream()
```

stream

public IntStream stream(int fromIndex,
                        int toIndex)

Parameters:: fromIndex -; toIndex -
Returns:

apply

public <R,E extends Exception> R apply(Throwables.Function<? super IntList,R,E> func)
                                throws E extends Exception

Specified by:: apply in class PrimitiveList<Integer,int[],IntList>
Type Parameters:: R -; E -
Parameters:: func -
Returns:
Throws:: E - the e; E extends Exception

applyIfNotEmpty

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

Apply if not empty.

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

accept

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

Specified by:: accept in class PrimitiveList<Integer,int[],IntList>
Type Parameters:: E -
Parameters:: action -
Throws:: E - the e; E extends Exception

acceptIfNotEmpty

public <E extends Exception> If.OrElse acceptIfNotEmpty(Throwables.Consumer<? super IntList,E> action)
                                                 throws E extends Exception

Accept if not empty.

Specified by:: acceptIfNotEmpty in class PrimitiveList<Integer,int[],IntList>
Type Parameters:: E -
Parameters:: action -
Throws:: E - the e; E extends Exception

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

hashCode in class Object

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

Class IntList

Constructor Summary

Method Summary

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

Methods inherited from class java.lang.Object

Constructor Detail

IntList

IntList

IntList

IntList

Method Detail

of

of

copyOf

copyOf

from

from

from

from

range

range

rangeClosed

rangeClosed

repeat

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

average