gnu.trove

## Class TByteHashSet

- java.lang.Object
- - gnu.trove.THash
  - - gnu.trove.TPrimitiveHash
    - - gnu.trove.TByteHash
      - - gnu.trove.TByteHashSet

All Implemented Interfaces:
  TByteHashingStrategy, java.io.Externalizable, java.io.Serializable, java.lang.Cloneable

    public class TByteHashSet
    extends TByteHash
    implements java.io.Externalizable

An open addressed set implementation for byte primitives.

Author:
  Eric D. Friedman, Rob Eden
See Also:
  Serialized Form

### Field Summary

### Fields inherited from class gnu.trove.TByteHash

`_hashingStrategy, _set`

### Fields inherited from class gnu.trove.TPrimitiveHash

`_states, FREE, FULL, REMOVED`

### Fields inherited from class gnu.trove.THash

`_autoCompactionFactor, _autoCompactRemovesRemaining, _free, _loadFactor, _maxSize, _size, DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR`

### Constructor Summary

Constructors
Constructor and Description
`TByteHashSet()` Creates a new `TByteHashSet` instance with the default capacity and load factor.
`TByteHashSet(byte[] array)` Creates a new `TByteHashSet` instance containing the elements of `array`.
`TByteHashSet(byte[] array, TByteHashingStrategy strategy)` Creates a new `TByteHashSet` instance containing the elements of `array`.
`TByteHashSet(int initialCapacity)` Creates a new `TByteHashSet` instance with a prime capacity equal to or greater than `initialCapacity` and with the default load factor.
`TByteHashSet(int initialCapacity, float loadFactor)` Creates a new `TByteHashSet` instance with a prime capacity equal to or greater than `initialCapacity` and with the specified load factor.
`TByteHashSet(int initialCapacity, float loadFactor, TByteHashingStrategy strategy)` Creates a new `TByteHash` instance with a prime value at or near the specified capacity and load factor.
`TByteHashSet(int initialCapacity, TByteHashingStrategy strategy)` Creates a new `TByteHash` instance whose capacity is the next highest prime above `initialCapacity + 1` unless that value is already prime.
`TByteHashSet(TByteHashingStrategy strategy)` Creates a new `TByteHash` instance with the default capacity and load factor.

### Method Summary

Methods
`boolean` `add(byte val)` Inserts a value into the set.
`boolean` `addAll(byte[] array)` Adds all of the elements in `array` to the set.
`void` `clear()` Empties the set.
`boolean` `containsAll(byte[] array)` Tests the set to determine if all of the elements in `array` are present.
`boolean` `equals(java.lang.Object other)` Compares this set with another set for equality of their stored entries.
`int` `hashCode()`
`TByteIterator` `iterator()`
`void` `readExternal(java.io.ObjectInput in)`
`protected void` `rehash(int newCapacity)` Expands the set to accommodate new values.
`boolean` `remove(byte val)` Removes `val` from the set.
`boolean` `removeAll(byte[] array)` Removes all of the elements in `array` from the set.
`boolean` `retainAll(byte[] array)` Removes any values in the set which are not contained in `array`.
`byte[]` `toArray()` Returns a new array containing the values in the set.
`void` `writeExternal(java.io.ObjectOutput out)`

### Methods inherited from class gnu.trove.TByteHash

`clone, computeHashCode, contains, forEach, index, insertionIndex, removeAt, setUp`

### Methods inherited from class gnu.trove.TPrimitiveHash

`capacity`

### Methods inherited from class gnu.trove.THash

`calculateGrownCapacity, compact, ensureCapacity, getAutoCompactionFactor, isEmpty, postInsertHook, reenableAutoCompaction, setAutoCompactionFactor, size, tempDisableAutoCompaction, trimToSize`

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

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

### Constructor Detail

#### TByteHashSet

    public TByteHashSet()

Creates a new `TByteHashSet` instance with the default capacity and load factor.

#### TByteHashSet

    public TByteHashSet(int initialCapacity)

Creates a new `TByteHashSet` instance with a prime capacity equal to or greater than `initialCapacity` and with the default load factor.

Parameters:
  `initialCapacity` - an `int` value

#### TByteHashSet

    public TByteHashSet(int initialCapacity,
                float loadFactor)

Creates a new `TByteHashSet` instance with a prime capacity equal to or greater than `initialCapacity` and with the specified load factor.

Parameters:
  `initialCapacity` - an `int` value
  `loadFactor` - a `float` value

#### TByteHashSet

    public TByteHashSet(byte[] array)

Creates a new `TByteHashSet` instance containing the elements of `array`.

Parameters:
  `array` - an array of `byte` primitives

#### TByteHashSet

    public TByteHashSet(TByteHashingStrategy strategy)

Creates a new `TByteHash` instance with the default capacity and load factor.

Parameters:
  `strategy` - used to compute hash codes and to compare keys.

#### TByteHashSet

    public TByteHashSet(int initialCapacity,
                TByteHashingStrategy strategy)

Creates a new `TByteHash` instance whose capacity is the next highest prime above `initialCapacity + 1` unless that value is already prime.

Parameters:
  `initialCapacity` - an `int` value
  `strategy` - used to compute hash codes and to compare keys.

#### TByteHashSet

    public TByteHashSet(int initialCapacity,
                float loadFactor,
                TByteHashingStrategy strategy)

Creates a new `TByteHash` instance with a prime value at or near the specified capacity and load factor.

Parameters:
  `initialCapacity` - used to find a prime capacity for the table.
  `loadFactor` - used to calculate the threshold over which rehashing takes place.
  `strategy` - used to compute hash codes and to compare keys.

#### TByteHashSet

    public TByteHashSet(byte[] array,
                TByteHashingStrategy strategy)

Creates a new `TByteHashSet` instance containing the elements of `array`.

Parameters:
  `array` - an array of `byte` primitives
  `strategy` - used to compute hash codes and to compare keys.

### Method Detail

#### iterator

    public TByteIterator iterator()

Returns:
  a TByteIterator with access to the values in this set

#### add

    public boolean add(byte val)

Inserts a value into the set.

Parameters:
  `val` - an `byte` value
Returns:
  true if the set was modified by the add operation

#### rehash

    protected void rehash(int newCapacity)

Expands the set to accommodate new values.

Specified by:
  `rehash` in class `THash`
Parameters:
  `newCapacity` - an `int` value

#### toArray

    public byte[] toArray()

Returns a new array containing the values in the set.

Returns:
  an `byte[]` value

#### clear

    public void clear()

Empties the set.

Overrides:
  `clear` in class `THash`

#### equals

    public boolean equals(java.lang.Object other)

Compares this set with another set for equality of their stored entries.

Overrides:
  `equals` in class `java.lang.Object`
Parameters:
  `other` - an `Object` value
Returns:
  a `boolean` value

#### hashCode

    public int hashCode()

Overrides:
  `hashCode` in class `java.lang.Object`

#### remove

    public boolean remove(byte val)

Removes `val` from the set.

Parameters:
  `val` - an `byte` value
Returns:
  true if the set was modified by the remove operation.

#### containsAll

    public boolean containsAll(byte[] array)

Tests the set to determine if all of the elements in `array` are present.

Parameters:
  `array` - an `array` of byte primitives.
Returns:
  true if all elements were present in the set.

#### addAll

    public boolean addAll(byte[] array)

Adds all of the elements in `array` to the set.

Parameters:
  `array` - an `array` of byte primitives.
Returns:
  true if the set was modified by the add all operation.

#### removeAll

    public boolean removeAll(byte[] array)

Removes all of the elements in `array` from the set.

Parameters:
  `array` - an `array` of byte primitives.
Returns:
  true if the set was modified by the remove all operation.

#### retainAll

    public boolean retainAll(byte[] array)

Removes any values in the set which are not contained in `array`.

Parameters:
  `array` - an `array` of byte primitives.
Returns:
  true if the set was modified by the retain all operation

#### writeExternal

    public void writeExternal(java.io.ObjectOutput out)
                       throws java.io.IOException

Specified by:
  `writeExternal` in interface `java.io.Externalizable`
Overrides:
  `writeExternal` in class `THash`
Throws:
  `java.io.IOException`

#### readExternal

    public void readExternal(java.io.ObjectInput in)
                      throws java.io.IOException,
                             java.lang.ClassNotFoundException

Specified by:
  `readExternal` in interface `java.io.Externalizable`
Overrides:
  `readExternal` in class `THash`
Throws:
  `java.io.IOException`
  `java.lang.ClassNotFoundException`