org.eclipse.jgit.util

## Class BlockList<T>

- java.lang.Object
- - java.util.AbstractCollection<E>
  - - java.util.AbstractList<T>
    - - org.eclipse.jgit.util.BlockList<T>

Type Parameters:
  `T` - type of list element.

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

    public class BlockList<T>
    extends AbstractList<T>

Random access list that allocates entries in blocks.

Unlike `ArrayList`, this type does not need to reallocate the internal array in order to expand the capacity of the list. Access to any element is constant time, but requires two array lookups instead of one.

To handle common usages, `add(Object)` and `iterator()` use internal code paths to amortize out the second array lookup, making addition and simple iteration closer to one array operation per element processed.

Similar to `ArrayList`, adding or removing from any position except the end of the list requires O(N) time to copy all elements between the modification point and the end of the list. Applications are strongly encouraged to not use this access pattern with this list implementation.

### Field Summary

### Fields inherited from class java.util.AbstractList

`modCount`

### Constructor Summary

Constructors
Constructor and Description
`BlockList()` Initialize an empty list.
`BlockList(int capacity)` Initialize an empty list with an expected capacity.

### Method Summary

Methods
`void` `add(int index, T element)`
`boolean` `add(T element)`
`void` `addAll(BlockList<T> src)` Quickly append all elements of another BlockList.
`void` `addAll(T[] src, int srcIdx, int srcCnt)` Quickly append all elements from an array.
`void` `clear()`
`T` `get(int index)`
`Iterator<T>` `iterator()`
`T` `remove(int index)`
`T` `set(int index, T element)`
`int` `size()`

### Methods inherited from class java.util.AbstractList

`addAll, equals, hashCode, indexOf, lastIndexOf, listIterator, listIterator, removeRange, subList`

### Methods inherited from class java.util.AbstractCollection

`addAll, contains, containsAll, isEmpty, remove, removeAll, retainAll, toArray, toArray, toString`

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

`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

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

`addAll, contains, containsAll, isEmpty, remove, removeAll, retainAll, toArray, toArray`

### Constructor Detail

#### BlockList

    public BlockList()

Initialize an empty list.

#### BlockList

    public BlockList(int capacity)

Initialize an empty list with an expected capacity.

Parameters:
  `capacity` - number of elements expected to be in the list.

### Method Detail

#### size

    public int size()

Specified by:
  `size` in interface `Collection<T>`
Specified by:
  `size` in interface `List<T>`
Specified by:
  `size` in class `AbstractCollection<T>`

#### clear

    public void clear()

Specified by:
  `clear` in interface `Collection<T>`
Specified by:
  `clear` in interface `List<T>`
Overrides:
  `clear` in class `AbstractList<T>`

#### get

    public T get(int index)

Specified by:
  `get` in interface `List<T>`
Specified by:
  `get` in class `AbstractList<T>`

#### set

    public T set(int index,
        T element)

Specified by:
  `set` in interface `List<T>`
Overrides:
  `set` in class `AbstractList<T>`

#### addAll

    public void addAll(BlockList<T> src)

Quickly append all elements of another BlockList.

Parameters:
  `src` - the list to copy elements from.

#### addAll

    public void addAll(T[] src,
              int srcIdx,
              int srcCnt)

Quickly append all elements from an array.

Parameters:
  `src` - the source array.
  `srcIdx` - first index to copy.
  `srcCnt` - number of elements to copy.

#### add

    public boolean add(T element)

Specified by:
  `add` in interface `Collection<T>`
Specified by:
  `add` in interface `List<T>`
Overrides:
  `add` in class `AbstractList<T>`

#### add

    public void add(int index,
           T element)

Specified by:
  `add` in interface `List<T>`
Overrides:
  `add` in class `AbstractList<T>`

#### remove

    public T remove(int index)

Specified by:
  `remove` in interface `List<T>`
Overrides:
  `remove` in class `AbstractList<T>`

#### iterator

    public Iterator<T> iterator()

Specified by:
  `iterator` in interface `Iterable<T>`
Specified by:
  `iterator` in interface `Collection<T>`
Specified by:
  `iterator` in interface `List<T>`
Overrides:
  `iterator` in class `AbstractList<T>`