io.undertow.util

## Class AttachmentList<T>

- java.lang.Object
- - io.undertow.util.AttachmentList<T>

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

    public final class AttachmentList<T>
    extends Object
    implements List<T>, RandomAccess

Author:
  David M. Lloyd

### Constructor Summary

Constructors
Constructor and Description
`AttachmentList(Class<T> valueClass)`
`AttachmentList(Collection<? extends T> c, Class<T> valueClass)`
`AttachmentList(int initialCapacity, Class<T> valueClass)`

### Method Summary

All Methods Instance Methods Concrete Methods
`void` `add(int index, T element)`
`boolean` `add(T t)`
`boolean` `addAll(Collection<? extends T> c)`
`boolean` `addAll(int index, Collection<? extends T> c)`
`void` `clear()`
`boolean` `contains(Object o)`
`boolean` `containsAll(Collection<?> c)`
`boolean` `equals(Object o)`
`T` `get(int index)`
`Class<T>` `getValueClass()`
`int` `hashCode()`
`int` `indexOf(Object o)`
`boolean` `isEmpty()`
`Iterator<T>` `iterator()`
`int` `lastIndexOf(Object o)`
`ListIterator<T>` `listIterator()`
`ListIterator<T>` `listIterator(int index)`
`T` `remove(int index)`
`boolean` `remove(Object o)`
`boolean` `removeAll(Collection<?> c)`
`boolean` `retainAll(Collection<?> c)`
`T` `set(int index, T element)`
`int` `size()`
`List<T>` `subList(int fromIndex, int toIndex)`
`Object[]` `toArray()`
`<T> T[]` `toArray(T[] a)`

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

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

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

`replaceAll, sort, spliterator`

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

`parallelStream, removeIf, stream`

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

`forEach`

### Constructor Detail

#### AttachmentList

    public AttachmentList(int initialCapacity,
                          Class<T> valueClass)

#### AttachmentList

    public AttachmentList(Class<T> valueClass)

#### AttachmentList

    public AttachmentList(Collection<? extends T> c,
                          Class<T> valueClass)

### Method Detail

#### getValueClass

    public Class<T> getValueClass()

#### size

    public int size()

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

#### 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 `Iterable<T>`
Specified by:
  `iterator` in interface `Collection<T>`
Specified by:
  `iterator` in interface `List<T>`

#### toArray

    public Object[] toArray()

Specified by:
  `toArray` in interface `Collection<T>`
Specified by:
  `toArray` in interface `List<T>`

#### toArray

    public <T> T[] toArray(T[] a)

Specified by:
  `toArray` in interface `Collection<T>`
Specified by:
  `toArray` in interface `List<T>`

#### add

    public boolean add(T t)

Specified by:
  `add` in interface `Collection<T>`
Specified by:
  `add` 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>`

#### clear

    public void clear()

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

#### equals

    public boolean equals(Object o)

Specified by:
  `equals` in interface `Collection<T>`
Specified by:
  `equals` in interface `List<T>`
Overrides:
  `equals` in class `Object`

#### hashCode

    public int hashCode()

Specified by:
  `hashCode` in interface `Collection<T>`
Specified by:
  `hashCode` in interface `List<T>`
Overrides:
  `hashCode` in class `Object`

#### get

    public T get(int index)

Specified by:
  `get` 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>`