CharCharMap (RegExodus 0.1.3)

java.lang.Object
- regexodus.ds.CharCharMap

All Implemented Interfaces:

Serializable, Cloneable
```
public class CharCharMap
extends Object
implements Serializable, Cloneable
```
A type-specific hash map with a fast, small-footprint implementation.

Instances of this class use a hash table to represent a map. The table is filled up to a specified load factor, and then doubled in size to accommodate new entries. If the table is emptied below one fourth of the load factor, it is halved in size. However, halving is not performed when deleting entries from an iterator, as it would interfere with the iteration process.

Note that clear() does not modify the hash table size. Rather, a family of trimming methods lets you control the size of the table; this is particularly useful if you reuse instances of this class.

See Also:

Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`protected boolean`	`containsNullKey` Whether this set contains the key zero.
`static int`	`DEFAULT_INITIAL_SIZE` The initial default size of a hash table.
`static float`	`DEFAULT_LOAD_FACTOR` The default load factor of a hash table.
`protected char`	`defRetValue` The default return value for `get()`, `put()` and `remove()`.
`protected float`	`f` The acceptable load factor.
`protected char[]`	`key` The array of keys.
`protected regexodus.ds.CharCharMap.KeySet`	`keys` Cached set of keys.
`protected int`	`mask` The mask for wrapping a position counter.
`protected int`	`maxFill` Threshold after which we rehash.
`protected int`	`n` The current table size.
`protected int`	`size` Number of entries in the set (including the key zero, if present).
`protected char[]`	`value` The array of values.

Constructor Summary

Constructors
Constructor and Description
`CharCharMap()` Creates a new hash map with initial expected 16 entries and 0.75f as load factor.
`CharCharMap(char[] k, char[] v)` Creates a new hash map with 0.75f as load factor using the elements of two parallel arrays.
`CharCharMap(char[] k, char[] v, float f)` Creates a new hash map using the elements of two parallel arrays.
`CharCharMap(int expected)` Creates a new hash map with 0.75f as load factor.
`CharCharMap(int expected, float f)` Creates a new hash map.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static int`	`arraySize(int expected, float f)` Returns the least power of two smaller than or equal to 2³⁰ and larger than or equal to `Math.ceil( expected / f )`.
`void`	`clear()`
`CharCharMap`	`clone()` Returns a deep copy of this map.
`boolean`	`containsKey(char k)`
`boolean`	`containsValue(char v)`
`char`	`defaultReturnValue()`
`void`	`defaultReturnValue(char rv)`
`char`	`get(char k)`
`int`	`growthFactor()` Deprecated. Since `fastutil` 6.1.0, hash tables are doubled when they are too full.
`void`	`growthFactor(int growthFactor)` Deprecated. Since `fastutil` 6.1.0, hash tables are doubled when they are too full.
`int`	`hashCode()` Returns a hash code for this map.
`boolean`	`isEmpty()`
`regexodus.ds.CharCharMap.KeySet`	`keySet()`
`static int`	`maxFill(int n, float f)` Returns the maximum number of entries that can be filled before rehashing.
`static long`	`maxFill(long n, float f)` Returns the maximum number of entries that can be filled before rehashing.
`char`	`put(char k, char v)`
`protected void`	`rehash(int newN)` Rehashes the map.
`char`	`remove(char k)`
`protected void`	`shiftKeys(int pos)` Shifts left entries with the specified hash code, starting at the specified position, and empties the resulting free entry.
`int`	`size()`
`boolean`	`trim()` Rehashes the map, making the table as small as possible.
`boolean`	`trim(int n)` Rehashes this map if the table is too large.

Methods inherited from class java.lang.Object
equals, finalize, getClass, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - key
```
protected transient char[] key
```
    The array of keys.
  - value
```
protected transient char[] value
```
    The array of values.
  - mask
```
protected transient int mask
```
    The mask for wrapping a position counter.
  - containsNullKey
```
protected transient boolean containsNullKey
```
    Whether this set contains the key zero.
  - n
```
protected transient int n
```
    The current table size.
  - maxFill
```
protected transient int maxFill
```
    Threshold after which we rehash. It must be the table size times f.
  - size
```
protected int size
```
    Number of entries in the set (including the key zero, if present).
  - f
```
protected final float f
```
    The acceptable load factor.
  - keys
```
protected transient volatile regexodus.ds.CharCharMap.KeySet keys
```
    Cached set of keys.
  - defRetValue
```
protected char defRetValue
```
    The default return value for get(), put() and remove().
  - DEFAULT_INITIAL_SIZE
```
public static final int DEFAULT_INITIAL_SIZE
```
    The initial default size of a hash table.
    
    See Also:
    
    Constant Field Values
  - DEFAULT_LOAD_FACTOR
```
public static final float DEFAULT_LOAD_FACTOR
```
    The default load factor of a hash table.
    
    See Also:
    
    Constant Field Values
- Constructor Detail
  - CharCharMap
```
public CharCharMap(int expected,
                   float f)
```
    Creates a new hash map.
    
    The actual table size will be the least power of two greater than expected/f.
    
    Parameters:
    
    expected - the expected number of elements in the hash set.
    
    f - the load factor.
  - CharCharMap
```
public CharCharMap(int expected)
```
    Creates a new hash map with 0.75f as load factor.
    
    Parameters:
    
    expected - the expected number of elements in the hash map.
  - CharCharMap
```
public CharCharMap()
```
    Creates a new hash map with initial expected 16 entries and 0.75f as load factor.
  - CharCharMap
```
public CharCharMap(char[] k,
                   char[] v,
                   float f)
```
    Creates a new hash map using the elements of two parallel arrays.
    
    Parameters:
    
    k - the array of keys of the new hash map.
    
    v - the array of corresponding values in the new hash map.
    
    f - the load factor.
    
    Throws:
    
    IllegalArgumentException - if k and v have different lengths.
  - CharCharMap
```
public CharCharMap(char[] k,
                   char[] v)
```
    Creates a new hash map with 0.75f as load factor using the elements of two parallel arrays.
    
    Parameters:
    
    k - the array of keys of the new hash map.
    
    v - the array of corresponding values in the new hash map.
    
    Throws:
    
    IllegalArgumentException - if k and v have different lengths.
- Method Detail
  - defaultReturnValue
```
public void defaultReturnValue(char rv)
```
  - defaultReturnValue
```
public char defaultReturnValue()
```
  - put
```
public char put(char k,
                char v)
```
  - shiftKeys
```
protected final void shiftKeys(int pos)
```
    Shifts left entries with the specified hash code, starting at the specified position, and empties the resulting free entry.
    
    Parameters:
    
    pos - a starting position.
  - remove
```
public char remove(char k)
```
  - get
```
public char get(char k)
```
  - containsKey
```
public boolean containsKey(char k)
```
  - containsValue
```
public boolean containsValue(char v)
```
  - clear
```
public void clear()
```
  - size
```
public int size()
```
  - isEmpty
```
public boolean isEmpty()
```
  - growthFactor
```
@Deprecated
public void growthFactor(int growthFactor)
```
    Deprecated. Since fastutil 6.1.0, hash tables are doubled when they are too full.
    
    A no-op for backward compatibility.
    
    Parameters:
    
    growthFactor - unused.
  - growthFactor
```
@Deprecated
public int growthFactor()
```
    Deprecated. Since fastutil 6.1.0, hash tables are doubled when they are too full.
    
    Gets the growth factor (2).
    
    Returns:
    
    the growth factor of this set, which is fixed (2).
    
    See Also:
    
    growthFactor(int)
  - keySet
```
public regexodus.ds.CharCharMap.KeySet keySet()
```
  - trim
```
public boolean trim()
```
    Rehashes the map, making the table as small as possible.
    
    This method rehashes the table to the smallest size satisfying the load factor. It can be used when the set will not be changed anymore, so to optimize access speed and size.
    
    If the table size is already the minimum possible, this method does nothing.
    
    Returns:
    
    true if there was enough memory to trim the map.
    
    See Also:
    
    trim(int)
  - trim
```
public boolean trim(int n)
```
    Rehashes this map if the table is too large.
    
    Let N be the smallest table size that can hold max(n,size()) entries, still satisfying the load factor. If the current table size is smaller than or equal to N, this method does nothing. Otherwise, it rehashes this map in a table of size N.
    
    This method is useful when reusing maps. Clearing a map leaves the table size untouched. If you are reusing a map many times, you can call this method with a typical size to avoid keeping around a very large table just because of a few large transient maps.
    
    Parameters:
    
    n - the threshold for the trimming.
    
    Returns:
    
    true if there was enough memory to trim the map.
    
    See Also:
    
    trim()
  - rehash
```
protected void rehash(int newN)
```
    Rehashes the map.
    
    This method implements the basic rehashing strategy, and may be overriden by subclasses implementing different rehashing strategies (e.g., disk-based rehashing). However, you should not override this method unless you understand the internal workings of this class.
    
    Parameters:
    
    newN - the new size
  - clone
```
public CharCharMap clone()
```
    Returns a deep copy of this map.
    This method performs a deep copy of this hash map, but with primitive keys and values it doesn't matter much.
    
    Overrides:
    
    clone in class Object
    
    Returns:
    
    a deep copy of this map.
  - hashCode
```
public int hashCode()
```
    Returns a hash code for this map.
    This method overrides the generic method provided by the superclass. Since equals() is not overriden, it is important that the value returned by this method is the same value as the one returned by the overriden method.
    
    Overrides:
    
    hashCode in class Object
    
    Returns:
    
    a hash code for this map.
  - maxFill
```
public static int maxFill(int n,
                          float f)
```
    Returns the maximum number of entries that can be filled before rehashing.
    
    Parameters:
    
    n - the size of the backing array.
    
    f - the load factor.
    
    Returns:
    
    the maximum number of entries before rehashing.
  - maxFill
```
public static long maxFill(long n,
                           float f)
```
    Returns the maximum number of entries that can be filled before rehashing.
    
    Parameters:
    
    n - the size of the backing array.
    
    f - the load factor.
    
    Returns:
    
    the maximum number of entries before rehashing.
  - arraySize
```
public static int arraySize(int expected,
                            float f)
```
    Returns the least power of two smaller than or equal to 2³⁰ and larger than or equal to Math.ceil( expected / f ).
    
    Parameters:
    
    expected - the expected number of elements in a hash table.
    
    f - the load factor.
    
    Returns:
    
    the minimum possible size for a backing array.
    
    Throws:
    
    IllegalArgumentException - if the necessary size is larger than 2³⁰.

Class CharCharMap

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

key

value

mask

containsNullKey

n

maxFill

size

f

keys

defRetValue

DEFAULT_INITIAL_SIZE

DEFAULT_LOAD_FACTOR

Constructor Detail

CharCharMap

CharCharMap

CharCharMap

CharCharMap

CharCharMap

Method Detail

defaultReturnValue

defaultReturnValue

put

shiftKeys

remove

get

containsKey

containsValue

clear

size

isEmpty

growthFactor

growthFactor

keySet

trim

trim

rehash

clone

hashCode

maxFill

maxFill

arraySize