com.jogamp.common.util

## Class ArrayHashSet<E>

- java.lang.Object
- - com.jogamp.common.util.ArrayHashSet<E>

- All Implemented Interfaces:
    Cloneable, Iterable<E>, Collection<E>, List<E>

      public class ArrayHashSet<E>
      extends Object
      implements Cloneable, Collection<E>, List<E>

  Hashed ArrayList implementation of the List and Collection interface. Implementation properties are:
  - Unique elements utilizing `Object.hashCode()` for O(1) operations, see below.
  - Provides `List` functionality, ie `List.indexOf(java.lang.Object)` and `List.get(int)`, hence object identity can be implemented.
  - Object identity via `get(java.lang.Object)`
  - Java 1.5 compatible
  O(1) operations:
  - adding new element(s)
  - test for containment
  - identity
  - trying to remove non existent elements
  O(n) operations:
  - removing existing elements
  For thread safety, the application shall decorate access to instances via `RecursiveLock`.

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `ArrayHashSet()`
    `ArrayHashSet(int initialCapacity)`
    `ArrayHashSet(int initialCapacity, float loadFactor)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | `add(E element)` Add element at the end of this list, if it is not contained yet.
    `void` | `add(int index, E element)` Add element at the given index in this list, if it is not contained yet.
    `boolean` | `addAll(Collection<? extends E> c)` Add all elements of given `Collection` at the end of this list.
    `boolean` | `addAll(int index, Collection<? extends E> c)`
    `void` | `clear()`
    `Object` | `clone()`
    `boolean` | `contains(Object element)` Test for containment This is an O(1) operation.
    `boolean` | `containsAll(Collection<?> c)` Test for containment of given `Collection` This is an O(n) operation, over the given Collection size.
    `boolean` | `containsSafe(Object element)` Test for containment This is an O(n) operation, using equals operation over the list.
    `boolean` | `equals(Object arrayHashSet)` This is an O(n) operation.
    `E` | `get(int index)`
    `E` | `get(Object key)` Identity method allowing to get the identical object, using the internal hash map.
    `ArrayList<E>` | `getData()` Returns this object ordered ArrayList.
    `HashMap<E,E>` | `getMap()` Returns this object hash map.
    `E` | `getOrAdd(E key)` Identity method allowing to get the identical object, using the internal hash map. If the `key` is not yet contained, add it.
    `int` | `hashCode()` This is an O(n) operation over the size of this list.
    `int` | `indexOf(Object element)`
    `boolean` | `isEmpty()`
    `Iterator<E>` | `iterator()`
    `int` | `lastIndexOf(Object o)` Since this list is unique, equivalent to `indexOf(java.lang.Object)`.
    `ListIterator<E>` | `listIterator()`
    `ListIterator<E>` | `listIterator(int index)`
    `E` | `remove(int index)` Remove element at given index from this list.
    `boolean` | `remove(Object element)` Remove element from this list.
    `boolean` | `removeAll(Collection<?> c)` Remove all elements of given `Collection` from this list.
    `boolean` | `retainAll(Collection<?> c)` Retain all elements of the given `Collection` c, ie remove all elements not contained by the given `Collection` c.
    `E` | `set(int index, E element)`
    `int` | `size()`
    `List<E>` | `subList(int fromIndex, int toIndex)`
    `Object[]` | `toArray()`
    `<T> T[]` | `toArray(T[] a)`
    `ArrayList<E>` | `toArrayList()`
    `String` | `toString()`

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

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

- - ### Constructor Detail

    - #### ArrayHashSet

          public ArrayHashSet()

    - #### ArrayHashSet

          public ArrayHashSet(int initialCapacity)

    - #### ArrayHashSet

          public ArrayHashSet(int initialCapacity,
                      float loadFactor)

  - ### Method Detail

    - #### clone

          public final Object clone()

      Overrides:
        `clone` in class `Object`
      Returns:
        a shallow copy of this ArrayHashSet, elements are not copied.

    - #### getData

          public final ArrayList<E> getData()

      Returns this object ordered ArrayList. Use w/ care, it's not a copy.

    - #### getMap

          public final HashMap<E,E> getMap()

      Returns this object hash map. Use w/ care, it's not a copy.

    - #### toString

          public final String toString()

      Overrides:
        `toString` in class `Object`

    - #### clear

          public final void clear()

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

    - #### add

          public final boolean add(E element)

      Add element at the end of this list, if it is not contained yet.
      This is an O(1) operation
      Specified by:
        `add` in interface `Collection<E>`
      Specified by:
        `add` in interface `List<E>`
      Returns:
        true if the element was added to this list, otherwise false (already contained).

    - #### remove

          public final boolean remove(Object element)

      Remove element from this list.
      This is an O(1) operation, in case it does not exist, otherwise O(n).
      Specified by:
        `remove` in interface `Collection<E>`
      Specified by:
        `remove` in interface `List<E>`
      Returns:
        true if the element was removed from this list, otherwise false (not contained).

    - #### addAll

          public final boolean addAll(Collection<? extends E> c)

      Add all elements of given `Collection` at the end of this list.
      This is an O(n) operation, over the given Collection size.
      Specified by:
        `addAll` in interface `Collection<E>`
      Specified by:
        `addAll` in interface `List<E>`
      Returns:
        true if at least one element was added to this list, otherwise false (completely container).

    - #### contains

          public final boolean contains(Object element)

      Test for containment
      This is an O(1) operation.
      Specified by:
        `contains` in interface `Collection<E>`
      Specified by:
        `contains` in interface `List<E>`
      Returns:
        true if the given element is contained by this list using fast hash map, otherwise false.

    - #### containsAll

          public final boolean containsAll(Collection<?> c)

      Test for containment of given `Collection`
      This is an O(n) operation, over the given Collection size.
      Specified by:
        `containsAll` in interface `Collection<E>`
      Specified by:
        `containsAll` in interface `List<E>`
      Returns:
        true if the given Collection is completly contained by this list using hash map, otherwise false.

    - #### removeAll

          public final boolean removeAll(Collection<?> c)

      Remove all elements of given `Collection` from this list.
      This is an O(n) operation.
      Specified by:
        `removeAll` in interface `Collection<E>`
      Specified by:
        `removeAll` in interface `List<E>`
      Returns:
        true if at least one element of this list was removed, otherwise false.

    - #### retainAll

          public final boolean retainAll(Collection<?> c)

      Retain all elements of the given `Collection` c, ie remove all elements not contained by the given `Collection` c.
      This is an O(n) operation.
      Specified by:
        `retainAll` in interface `Collection<E>`
      Specified by:
        `retainAll` in interface `List<E>`
      Returns:
        true if at least one element of this list was removed, otherwise false.

    - #### equals

          public final boolean equals(Object arrayHashSet)

      This is an O(n) operation.
      Specified by:
        `equals` in interface `Collection<E>`
      Specified by:
        `equals` in interface `List<E>`
      Overrides:
        `equals` in class `Object`
      Returns:
        true if arrayHashSet is of type ArrayHashSet and all entries are equal Performance: arrayHashSet(1)

    - #### hashCode

          public final int hashCode()

      This is an O(n) operation over the size of this list.
      Specified by:
        `hashCode` in interface `Collection<E>`
      Specified by:
        `hashCode` in interface `List<E>`
      Overrides:
        `hashCode` in class `Object`
      Returns:
        the hash code of this list as define in `List.hashCode()`, ie hashing all elements of this list.

    - #### isEmpty

          public final boolean isEmpty()

      Specified by:
        `isEmpty` in interface `Collection<E>`
      Specified by:
        `isEmpty` in interface `List<E>`

    - #### iterator

          public final Iterator<E> iterator()

      Specified by:
        `iterator` in interface `Iterable<E>`
      Specified by:
        `iterator` in interface `Collection<E>`
      Specified by:
        `iterator` in interface `List<E>`

    - #### size

          public final int size()

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

    - #### toArray

          public final Object[] toArray()

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

    - #### toArray

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

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

    - #### get

          public final E get(int index)

      Specified by:
        `get` in interface `List<E>`

    - #### indexOf

          public final int indexOf(Object element)

      Specified by:
        `indexOf` in interface `List<E>`

    - #### add

          public final void add(int index,
                 E element)

      Add element at the given index in this list, if it is not contained yet.
      This is an O(1) operation
      Specified by:
        `add` in interface `List<E>`
      Throws:
        `IllegalArgumentException` - if the given element was already contained

    - #### addAll

          public final boolean addAll(int index,
                       Collection<? extends E> c)

      Specified by:
        `addAll` in interface `List<E>`
      Throws:
        `UnsupportedOperationException`

    - #### set

          public final E set(int index,
              E element)

      Specified by:
        `set` in interface `List<E>`
      Throws:
        `UnsupportedOperationException`

    - #### remove

          public final E remove(int index)

      Remove element at given index from this list.
      This is an O(n) operation.
      Specified by:
        `remove` in interface `List<E>`
      Returns:
        the removed object

    - #### lastIndexOf

          public final int lastIndexOf(Object o)

      Since this list is unique, equivalent to `indexOf(java.lang.Object)`.
      This is an O(n) operation.
      Specified by:
        `lastIndexOf` in interface `List<E>`
      Returns:
        index of element, or -1 if not found

    - #### listIterator

          public final ListIterator<E> listIterator()

      Specified by:
        `listIterator` in interface `List<E>`

    - #### listIterator

          public final ListIterator<E> listIterator(int index)

      Specified by:
        `listIterator` in interface `List<E>`

    - #### subList

          public final List<E> subList(int fromIndex,
                        int toIndex)

      Specified by:
        `subList` in interface `List<E>`

    - #### toArrayList

          public final ArrayList<E> toArrayList()

      Returns:
        a shallow copy of this ArrayHashSet's ArrayList, elements are not copied.

    - #### get

          public final E get(Object key)

      Identity method allowing to get the identical object, using the internal hash map.
      This is an O(1) operation.
      Parameters:
        `key` - hash source to find the identical Object within this list
      Returns:
        object from this list, identical to the given `key` hash code, or null if not contained

    - #### getOrAdd

          public final E getOrAdd(E key)

      Identity method allowing to get the identical object, using the internal hash map.
      If the `key` is not yet contained, add it.
      This is an O(1) operation.
      Parameters:
        `key` - hash source to find the identical Object within this list
      Returns:
        object from this list, identical to the given `key` hash code, or add the given `key` and return it.

    - #### containsSafe

          public final boolean containsSafe(Object element)

      Test for containment
      This is an O(n) operation, using equals operation over the list.
      You may utilize this method to verify your hash values,
      ie `contains(java.lang.Object)` and `containsSafe(java.lang.Object)` shall have the same result.
      Returns:
        true if the given element is contained by this list using slow equals operation, otherwise false.