ShortList (abacus-util 1.21.12 API)

java.lang.Object
- com.landawn.abacus.util.PrimitiveList<Short,short[],ShortList>
- - com.landawn.abacus.util.ShortList

All Implemented Interfaces:

Serializable, RandomAccess
```
public final class ShortList
extends PrimitiveList<Short,short[],ShortList>
```
Since:

0.8

Author:

Haiyang Li

See Also:

Serialized Form

Constructor Summary

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

Method Detail

of

@SafeVarargs
public static ShortList of(short... a)

Parameters:: a -
Returns:

of

public static ShortList of(short[] a,
                           int size)

Parameters:: a -; size -
Returns:

copyOf

public static ShortList copyOf(short[] a)

Parameters:: a -
Returns:

copyOf

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

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

from

public static ShortList from(Collection<Short> c)

Parameters:: c -
Returns:

from

public static ShortList from(Collection<Short> c,
                             short defaultForNull)

Parameters:: c -; defaultForNull -
Returns:

from

public static ShortList from(Collection<Short> c,
                             int fromIndex,
                             int toIndex)

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

from

public static ShortList from(Collection<Short> c,
                             int fromIndex,
                             int toIndex,
                             short defaultForNull)

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

range

public static ShortList range(short startInclusive,
                              short endExclusive)

Parameters:: startInclusive -; endExclusive -
Returns:

range

public static ShortList range(short startInclusive,
                              short endExclusive,
                              short by)

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

rangeClosed

public static ShortList rangeClosed(short startInclusive,
                                    short endInclusive)

Parameters:: startInclusive -; endInclusive -
Returns:

rangeClosed

public static ShortList rangeClosed(short startInclusive,
                                    short endInclusive,
                                    short by)

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

repeat

public static ShortList repeat(short element,
                               int len)

Parameters:: element -; len -
Returns:

random

public static ShortList random(int len)

Parameters:: len -
Returns:

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

Specified by:

array in class PrimitiveList<Short,short[],ShortList>

Returns:

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

index -

Returns:

set

public short set(int index,
                 short e)

Parameters:: index -; e -
Returns:

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

e -

add

public void add(int index,
                short e)

Parameters:: index -; e -

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

Parameters:

c -

Returns:

true, if successful

addAll

public boolean addAll(int index,
                      ShortList c)

Adds the all.

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

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

Specified by:

addAll in class PrimitiveList<Short,short[],ShortList>

Parameters:

a -

Returns:

true, if successful

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

Specified by:

addAll in class PrimitiveList<Short,short[],ShortList>

Parameters:

index -

a -

Returns:

true, if successful

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

e -

Returns:

true if this list contained the specified element

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

Parameters:

e -

Returns:

true if this list contained the specified element

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

Parameters:

c -

Returns:

true, if successful

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

Specified by:

removeAll in class PrimitiveList<Short,short[],ShortList>

Parameters:

a -

Returns:

true, if successful

removeIf

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

c -

Returns:

true, if successful

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

a -

Returns:

true, if successful

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

index -

Returns:

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

deleteAll in class PrimitiveList<Short,short[],ShortList>

Parameters:

indices -

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

deleteRange in class PrimitiveList<Short,short[],ShortList>

Parameters:

fromIndex -

toIndex -

replaceAll

public int replaceAll(short oldVal,
                      short newVal)

Parameters:: oldVal -; newVal -
Returns:

replaceAll

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

val -

fill

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

Parameters:: fromIndex -; toIndex -; val -

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

e -

Returns:

true, if successful

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

c -

Returns:

true, if successful

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

containsAll in class PrimitiveList<Short,short[],ShortList>

Parameters:

a -

Returns:

true, if successful

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

c -

Returns:

true, if successful

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

c -

Returns:

true, if successful

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

containsAny in class PrimitiveList<Short,short[],ShortList>

Parameters:

a -

Returns:

true, if successful

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

disjoint in class PrimitiveList<Short,short[],ShortList>

Parameters:

b -

Returns:

true, if successful

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

b -

Returns:

See Also:

IntList.intersection(IntList)

intersection

public ShortList intersection(short[] a)

Parameters:: a -
Returns:

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

b -

Returns:

See Also:

IntList.difference(IntList)

difference

public ShortList difference(short[] a)

Parameters:: a -
Returns:

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

b -

Returns:

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

See Also:

IntList.symmetricDifference(IntList)

symmetricDifference

public ShortList symmetricDifference(short[] a)

Parameters:: a -
Returns:

occurrencesOf

public int occurrencesOf(short objectToFind)

Parameters:: objectToFind -
Returns:

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

e -

Returns:

indexOf

public int indexOf(int fromIndex,
                   short e)

Parameters:: fromIndex -; e -
Returns:

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

Parameters:

e -

Returns:

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

Parameters:

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

e -

Returns:

min
```
public u.OptionalShort min()
```

min

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

Parameters:: fromIndex -; toIndex -
Returns:

median
```
public u.OptionalShort median()
```

median

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

Parameters:: fromIndex -; toIndex -
Returns:

max
```
public u.OptionalShort max()
```

max

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

Parameters:: fromIndex -; toIndex -
Returns:

kthLargest

public u.OptionalShort kthLargest(int k)

Parameters:: k -
Returns:

kthLargest

public u.OptionalShort 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.ShortConsumer<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.ShortConsumer<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.IndexedShortConsumer<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.IndexedShortConsumer<E> action)
                                          throws E extends Exception

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

first
```
public u.OptionalShort first()
```

last
```
public u.OptionalShort last()
```

findFirst

public <E extends Exception> u.OptionalShort findFirst(Throwables.ShortPredicate<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.OptionalShort findLast(Throwables.ShortPredicate<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.ShortPredicate<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.ShortPredicate<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.ShortPredicate<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.ShortPredicate<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.ShortPredicate<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.ShortPredicate<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.ShortPredicate<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.ShortPredicate<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.ShortPredicate<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.ShortPredicate<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> ShortList filter(Throwables.ShortPredicate<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> ShortList filter(int fromIndex,
                                              int toIndex,
                                              Throwables.ShortPredicate<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> ShortList filter(Throwables.ShortPredicate<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> ShortList filter(int fromIndex,
                                              int toIndex,
                                              Throwables.ShortPredicate<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> ShortList map(Throwables.ShortUnaryOperator<E> mapper)
                                    throws E extends Exception

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

map

public <E extends Exception> ShortList map(int fromIndex,
                                           int toIndex,
                                           Throwables.ShortUnaryOperator<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.ShortFunction<? 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.ShortFunction<? 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.OptionalShort reduce(Throwables.ShortBinaryOperator<E> accumulator)
                                             throws E extends Exception

This is equivalent to:

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

    short result = elementData[0];

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

    return OptionalShort.of(result);

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

reduce

public <E extends Exception> short reduce(short identity,
                                          Throwables.ShortBinaryOperator<E> accumulator)
                                   throws E extends Exception

This is equivalent to:

 
     if (isEmpty()) {
         return identity;
     }

     short result = identity;

     for (int i = 0; i < size; i++) {
         result = accumulator.applyAsShort(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<Short,short[],ShortList>

Returns:

true, if successful

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

distinct in class PrimitiveList<Short,short[],ShortList>

Parameters:

fromIndex -

toIndex -

Returns:

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

n -

Returns:

top

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

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

top

public ShortList top(int n,
                     Comparator<? super Short> cmp)

Parameters:: n -; cmp -
Returns:

top

public ShortList top(int fromIndex,
                     int toIndex,
                     int n,
                     Comparator<? super Short> cmp)

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

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

Specified by:

sort in class PrimitiveList<Short,short[],ShortList>

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

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

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

Parameters:

key -

Returns:

binarySearch

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

This List should be sorted first.

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

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

Specified by:

reverse in class PrimitiveList<Short,short[],ShortList>

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

reverse in class PrimitiveList<Short,short[],ShortList>

Parameters:

fromIndex -

toIndex -

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

rotate in class PrimitiveList<Short,short[],ShortList>

Parameters:

distance -

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

Specified by:

shuffle in class PrimitiveList<Short,short[],ShortList>

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

shuffle in class PrimitiveList<Short,short[],ShortList>

Parameters:

rnd -

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

swap in class PrimitiveList<Short,short[],ShortList>

Parameters:

i -

j -

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

copy in class PrimitiveList<Short,short[],ShortList>

Returns:

a copy of this List

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

copy in class PrimitiveList<Short,short[],ShortList>

Parameters:

fromIndex -

toIndex -

Returns:

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

copy in class PrimitiveList<Short,short[],ShortList>

Parameters:

from -

to -

step -

Returns:

See Also:

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

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

Specified by:

split in class PrimitiveList<Short,short[],ShortList>

Parameters:

fromIndex -

toIndex -

size -

Returns:

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

join in class PrimitiveList<Short,short[],ShortList>

Parameters:

fromIndex -

toIndex -

delimiter -

Returns:

join

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

Specified by:: join in class PrimitiveList<Short,short[],ShortList>
Parameters:: fromIndex -; toIndex -; delimiter -
Returns:

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

Specified by:

trimToSize in class PrimitiveList<Short,short[],ShortList>

Returns:

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

Specified by:

clear in class PrimitiveList<Short,short[],ShortList>

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

Specified by:

isEmpty in class PrimitiveList<Short,short[],ShortList>

Returns:

true, if is empty

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

size in class PrimitiveList<Short,short[],ShortList>

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

boxed

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

Parameters:: fromIndex -; toIndex -
Returns:

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

toArray in class PrimitiveList<Short,short[],ShortList>

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

Returns:

toCollection

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

Specified by:: toCollection in class PrimitiveList<Short,short[],ShortList>
Type Parameters:: C -
Parameters:: fromIndex -; toIndex -; supplier -
Returns:

toMultiset

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

Specified by:: toMultiset in class PrimitiveList<Short,short[],ShortList>
Parameters:: fromIndex -; toIndex -; supplier -
Returns:

toMap

public <K,V,E extends Exception,E2 extends Exception> Map<K,V> toMap(Throwables.ShortFunction<? extends K,E> keyMapper,
                                                                     Throwables.ShortFunction<? 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.ShortFunction<? extends K,E> keyMapper,
                                                                                 Throwables.ShortFunction<? 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.ShortFunction<? extends K,E> keyMapper,
                                                                                          Throwables.ShortFunction<? 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.ShortFunction<? extends K,E> keyMapper,
                                                                                                      Throwables.ShortFunction<? 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.ShortFunction<? extends K,E> keyMapper,
                                                  Collector<Short,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.ShortFunction<? extends K,E> keyMapper,
                                                              Collector<Short,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 ShortIterator iterator()
```

stream
```
public ShortStream stream()
```

stream

public ShortStream stream(int fromIndex,
                          int toIndex)

Parameters:: fromIndex -; toIndex -
Returns:

apply

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

Specified by:: apply in class PrimitiveList<Short,short[],ShortList>
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 ShortList,R,E> func)
                                                      throws E extends Exception

Apply if not empty.

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

accept

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

Specified by:: accept in class PrimitiveList<Short,short[],ShortList>
Type Parameters:: E -
Parameters:: action -
Throws:: E - the e; E extends Exception

acceptIfNotEmpty

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

Accept if not empty.

Specified by:: acceptIfNotEmpty in class PrimitiveList<Short,short[],ShortList>
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 ShortList

Constructor Summary

Method Summary

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

Methods inherited from class java.lang.Object

Constructor Detail

ShortList

ShortList

ShortList

ShortList

Method Detail

of

of

copyOf

copyOf

from

from

from

from

range

range

rangeClosed

rangeClosed

repeat

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

disjoint

containsAny

containsAny

disjoint

intersection

intersection

difference

difference

symmetricDifference

symmetricDifference

occurrencesOf

indexOf

indexOf

lastIndexOf

lastIndexOf

min

min

median

median

max

max

kthLargest

kthLargest

sum

sum

average

average

forEach