Package com.xceptance.xlt.api.util

# Class SimpleArrayList<T>

java.lang.Object
com.xceptance.xlt.api.util.SimpleArrayList<T>

All Implemented Interfaces:
  `Iterable<T>`, `Collection<T>`, `List<T>`, `SequencedCollection<T>`

public class SimpleArrayList<T> extends Object implements List<T>
Inexpensive (partial) list implementation. Not fully implemented, just what is needed. As soon as iterators and other things are involved, the memory savings we wanted are gone.

Minimal checks for data correctness!! This is tuned for speed not elegance or safety.

Since:
  7.0.0

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `SimpleArrayList(int capacity)`
  Create a new list with a default capacity.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `void`
  `add(int index, T element)`
  `boolean`
  `add(T element)`
  Add an element to the end of the list
  `boolean`
  `addAll(int index, Collection<? extends T> c)`
  `boolean`
  `addAll(Collection<? extends T> c)`
  `void`
  `clear()`
  Clears the list by setting the size to zero.
  `boolean`
  `contains(Object o)`
  `boolean`
  `containsAll(Collection<?> c)`
  `T`
  `get(int index)`
  Return an element at index.
  `int`
  `indexOf(Object o)`
  `boolean`
  `isEmpty()`
  `Iterator<T>`
  `iterator()`
  `int`
  `lastIndexOf(Object o)`
  `ListIterator<T>`
  `listIterator()`
  `ListIterator<T>`
  `listIterator(int index)`
  `List<List<T>>`
  `partition(int count)`
  Returns view partitions on the underlying list.
  `T`
  `remove(int index)`
  `boolean`
  `remove(Object o)`
  `boolean`
  `removeAll(Collection<?> c)`
  `boolean`
  `retainAll(Collection<?> c)`
  `T`
  `set(int index, T element)`
  `int`
  `size()`
  Returns the size of this list
  `List<T>`
  `subList(int fromIndex, int toIndex)`
  `Object[]`
  `toArray()`
  Creates an array of the elements.
  `<T> T[]`
  `toArray(T[] array)`
  Creates an array of the elements.

  ### Methods inherited from class java.lang.Object

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

  ### Methods inherited from interface java.util.Collection

  `parallelStream, removeIf, stream, toArray`

  ### Methods inherited from interface java.lang.Iterable

  `forEach`

  ### Methods inherited from interface java.util.List

  `addFirst, addLast, equals, getFirst, getLast, hashCode, removeFirst, removeLast, replaceAll, reversed, sort, spliterator`

- ## Constructor Details

  - ### SimpleArrayList

    public SimpleArrayList(int capacity)
    Create a new list with a default capacity.
    Parameters:
      `capacity` - the capacity

- ## Method Details

  - ### add

    public boolean add(T element)
    Add an element to the end of the list
    Specified by:
      `add` in interface `Collection<T>`
    Specified by:
      `add` in interface `List<T>`
    Parameters:
      `element` - the element to add
    Returns:
      true if added and for this impl it is always true

  - ### get

    public T get(int index)
    Return an element at index. No range checks at all.
    Specified by:
      `get` in interface `List<T>`
    Parameters:
      `index` - the position
    Returns:
      the element at this position

  - ### size

    public int size()
    Returns the size of this list
    Specified by:
      `size` in interface `Collection<T>`
    Specified by:
      `size` in interface `List<T>`

  - ### toArray

    public Object[] toArray()
    Creates an array of the elements. This is a copy operation!
    Specified by:
      `toArray` in interface `Collection<T>`
    Specified by:
      `toArray` in interface `List<T>`
    Returns:
      an array of the elements

  - ### toArray

    public <T> T[] toArray(T[] array)
    Creates an array of the elements. This is a copy operation!
    Specified by:
      `toArray` in interface `Collection<T>`
    Specified by:
      `toArray` in interface `List<T>`
    Returns:
      an array of the elements

  - ### clear

    public void clear()
    Clears the list by setting the size to zero. It does not release any elements for performance purposes.
    Specified by:
      `clear` in interface `Collection<T>`
    Specified by:
      `clear` in interface `List<T>`

  - ### partition

    public List<List<T>> partition(int count)
    Returns view partitions on the underlying list. If the count is larger than size you get back the maximum possible list number with one element each. If count is 0 or smaller, we correct it to 1.
    Parameters:
      `count` - how many list do we want
    Returns:
      a list of lists

  - ### isEmpty

    public boolean isEmpty()
    Specified by:
      `isEmpty` in interface `Collection<T>`
    Specified by:
      `isEmpty` in interface `List<T>`

  - ### contains

    public boolean contains(Object o)
    Specified by:
      `contains` in interface `Collection<T>`
    Specified by:
      `contains` in interface `List<T>`

  - ### iterator

    public Iterator<T> iterator()
    Specified by:
      `iterator` in interface `Collection<T>`
    Specified by:
      `iterator` in interface `Iterable<T>`
    Specified by:
      `iterator` in interface `List<T>`

  - ### remove

    public boolean remove(Object o)
    Specified by:
      `remove` in interface `Collection<T>`
    Specified by:
      `remove` in interface `List<T>`

  - ### containsAll

    public boolean containsAll(Collection<?> c)
    Specified by:
      `containsAll` in interface `Collection<T>`
    Specified by:
      `containsAll` in interface `List<T>`

  - ### addAll

    public boolean addAll(Collection<? extends T> c)
    Specified by:
      `addAll` in interface `Collection<T>`
    Specified by:
      `addAll` in interface `List<T>`

  - ### addAll

    public boolean addAll(int index, Collection<? extends T> c)
    Specified by:
      `addAll` in interface `List<T>`

  - ### removeAll

    public boolean removeAll(Collection<?> c)
    Specified by:
      `removeAll` in interface `Collection<T>`
    Specified by:
      `removeAll` in interface `List<T>`

  - ### retainAll

    public boolean retainAll(Collection<?> c)
    Specified by:
      `retainAll` in interface `Collection<T>`
    Specified by:
      `retainAll` in interface `List<T>`

  - ### set

    public T set(int index, T element)
    Specified by:
      `set` in interface `List<T>`

  - ### add

    public void add(int index, T element)
    Specified by:
      `add` in interface `List<T>`

  - ### remove

    public T remove(int index)
    Specified by:
      `remove` in interface `List<T>`

  - ### indexOf

    public int indexOf(Object o)
    Specified by:
      `indexOf` in interface `List<T>`

  - ### lastIndexOf

    public int lastIndexOf(Object o)
    Specified by:
      `lastIndexOf` in interface `List<T>`

  - ### listIterator

    public ListIterator<T> listIterator()
    Specified by:
      `listIterator` in interface `List<T>`

  - ### listIterator

    public ListIterator<T> listIterator(int index)
    Specified by:
      `listIterator` in interface `List<T>`

  - ### subList

    public List<T> subList(int fromIndex, int toIndex)
    Specified by:
      `subList` in interface `List<T>`