AbstractIntHashMap

java.lang.Object
- de.uni_hildesheim.sse.monitoring.runtime.utils.AbstractIntHashMap

Direct Known Subclasses:

IntHashMap
```
public abstract class AbstractIntHashMap
extends java.lang.Object
```
An abstract hash map for mapping int values. This class does not specify to which kind of objects to map to. Therefore, there is no real get method and no real put method. These methods need to be added by concrete implementing classes.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected static class`	`AbstractIntHashMap.DelegatingMapIterator<T>` Implements an abstract delegating element iterator.
`static class`	`AbstractIntHashMap.MapElement` Implements a map element storing the contents of the buckets.
`protected class`	`AbstractIntHashMap.MapIterator` Implements a map element iterator.

Field Summary

Fields
Modifier and Type	Field and Description
`private int`	`capacity` Stores the current capacity.
`private int`	`contents` Stores the number of elements.
`static int`	`DEFAULT_CAPACITY` The default capacity for hash map instances.
`static float`	`DEFAULT_LOADFACTOR` The default load factor for hash map instances.
`private float`	`loadFactor` Stores the load factor.
`private AbstractIntHashMap.MapElement[]`	`map` Stores the first bucket for each key.
`static int`	`MAXIMUM_CAPACITY` The maximum allowed capacity for hash map instances.
`private int`	`maxLoad` Stores the maximum load.
`private int`	`objectCounter` Stores the counter for objects created.
`private boolean`	`rehashing` Stores if rehashing is permitted.

Constructor Summary

Constructors
Constructor and Description
`AbstractIntHashMap()` Constructs an empty instance with the default initial capacity and the default load factor.
`AbstractIntHashMap(AbstractIntHashMap map)` Constructs a new IntHashMap with the same mappings as the specified Map.
`AbstractIntHashMap(int initialCapacity)` Constructs an empty instance with the given initial capacity and the default load factor.
`AbstractIntHashMap(int initialCapacity, float loadFactor)` Constructs an empty instance with the given initial capacity and the given load factor.

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`clear()` Removes all mappings from this map.
`private void`	`construct(int initialCapacity, float loadFactor)` Construction helper method.
`boolean`	`containsKey(int key)` Returns `true` if this map contains a mapping for the specified key.
`protected AbstractIntHashMap.MapElement`	`create(int key, java.lang.Object value)` Creates an element.
`java.lang.Iterable<AbstractIntHashMap.MapElement>`	`elements()` Returns an iterator over the entries stored in this map.
`int`	`getCapacity()` Return the current capacity of the instance.
`AbstractIntHashMap.MapElement`	`getElement(int key)` Returns the element matching the key, or null if no such element exists.
`float`	`getLoadFactor()` Return the load factor of the instance.
`int`	`getObjectCounter()` Return the number of objects created in / by this instance.
`boolean`	`isEmpty()` Returns `true` if this map contains no key-value mappings.
`int[]`	`keySet()` Return the keys in the hash map.
`abstract void`	`putAll(AbstractIntHashMap map)` Puts all the keys and values in the specified hash map into this hash map.
`protected java.lang.Object`	`putElement(int key, java.lang.Object value)` Associates the specified value with the specified key in this map.
`private void`	`rehash()` Increase the capacity of the map to improve performance.
`protected AbstractIntHashMap.MapElement`	`removeElement(int key)` Removes the mapping for this key from this map if present.
`void`	`removeNotIn(int[] keys)` Remove those elements which are not in `keys`.
`void`	`setRehash(boolean rehashing)` Enable/disable rehashing (defaults to `true`).
`int`	`size()` Return the current number of mappings in the hash map.

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

- Field Detail
  - DEFAULT_CAPACITY
```
public static final int DEFAULT_CAPACITY
```
    The default capacity for hash map instances.
    
    See Also:
    
    Constant Field Values
  - MAXIMUM_CAPACITY
```
public static final int MAXIMUM_CAPACITY
```
    The maximum allowed capacity for hash map instances.
    
    See Also:
    
    Constant Field Values
  - DEFAULT_LOADFACTOR
```
public static final float DEFAULT_LOADFACTOR
```
    The default load factor for hash map instances.
    
    See Also:
    
    Constant Field Values
  - map
```
private AbstractIntHashMap.MapElement[] map
```
    Stores the first bucket for each key.
  - contents
```
private int contents
```
    Stores the number of elements.
  - objectCounter
```
private int objectCounter
```
    Stores the counter for objects created.
  - capacity
```
private int capacity
```
    Stores the current capacity.
  - loadFactor
```
private float loadFactor
```
    Stores the load factor.
  - maxLoad
```
private int maxLoad
```
    Stores the maximum load.
  - rehashing
```
private boolean rehashing
```
    Stores if rehashing is permitted.
- Constructor Detail
  - AbstractIntHashMap
```
public AbstractIntHashMap()
```
    Constructs an empty instance with the default initial capacity and the default load factor.
  - AbstractIntHashMap
```
public AbstractIntHashMap(int initialCapacity)
```
    Constructs an empty instance with the given initial capacity and the default load factor.
    
    Parameters:
    
    initialCapacity - The initial capacity for this hash map.
  - AbstractIntHashMap
```
public AbstractIntHashMap(int initialCapacity,
                          float loadFactor)
```
    Constructs an empty instance with the given initial capacity and the given load factor.
    
    Parameters:
    
    initialCapacity - The initial capacity for this hash map.
    
    loadFactor - The load factor for this hash map.
  - AbstractIntHashMap
```
public AbstractIntHashMap(AbstractIntHashMap map)
```
    Constructs a new IntHashMap with the same mappings as the specified Map. The IntHashMap is created with default load factor and an initial capacity sufficient to hold the mappings in the specified Map.
    
    Parameters:
    
    map - The map whose mappings are to be placed in this map.
    
    Throws:
    
    java.lang.NullPointerException - if the specified map is null.
- Method Detail
  - putAll
```
public abstract void putAll(AbstractIntHashMap map)
```
    Puts all the keys and values in the specified hash map into this hash map.
    
    Parameters:
    
    map - the source map
  - size
```
public int size()
```
    Return the current number of mappings in the hash map.
    
    Returns:
    
    The current number of mappings in the hash map.
  - isEmpty
```
public boolean isEmpty()
```
    Returns true if this map contains no key-value mappings.
    
    Returns:
    
    true if there are no mappings, false else
  - clear
```
public void clear()
```
    Removes all mappings from this map.
  - getObjectCounter
```
public int getObjectCounter()
```
    Return the number of objects created in / by this instance.
    
    Returns:
    
    The number of objects created
  - getCapacity
```
public int getCapacity()
```
    Return the current capacity of the instance. If rehashing is enabled (which it is per default), the capacity may have been increased as necessary from the initial value.
    
    Returns:
    
    The current capacity for this hash map.
  - getLoadFactor
```
public float getLoadFactor()
```
    Return the load factor of the instance.
    
    Returns:
    
    The load factor for this hash map.
  - keySet
```
public int[] keySet()
```
    Return the keys in the hash map.
    
    Returns:
    
    An array containing the keys for which mappings are stored in this hash map.
  - elements
```
public java.lang.Iterable<AbstractIntHashMap.MapElement> elements()
```
    Returns an iterator over the entries stored in this map.
    
    Returns:
    
    the iterator
    
    Since:
    
    1.00
  - setRehash
```
public void setRehash(boolean rehashing)
```
    Enable/disable rehashing (defaults to true).
    
    Parameters:
    
    rehashing - A boolean indicating the desired rehashing status.
  - putElement
```
protected java.lang.Object putElement(int key,
                                      java.lang.Object value)
```
    Associates the specified value with the specified key in this map. If the map previously contained a mapping for this key, the old value is replaced.
    
    Parameters:
    
    key - The key with which the specified value is to be associated.
    
    value - The value to be associated with the specified key.
    
    Returns:
    
    Previous value associated with specified key, or null if there was no mapping for key. A null return can also indicate that the IntHashMap previously associated null with the specified key.
  - containsKey
```
public boolean containsKey(int key)
```
    Returns true if this map contains a mapping for the specified key.
    
    Parameters:
    
    key - The key whose presence in this map is to be tested.
    
    Returns:
    
    true if this map contains a mapping for the specified key.
  - removeElement
```
protected AbstractIntHashMap.MapElement removeElement(int key)
```
    Removes the mapping for this key from this map if present. This method is declared protected in order to facilitate reuse of the map element instance. Please do not return the result of this method to the caller.
    
    Parameters:
    
    key - The key whose mapping is to be removed from the map.
    
    Returns:
    
    the map element used to store the mapping (do not return to caller)
  - getElement
```
public AbstractIntHashMap.MapElement getElement(int key)
```
    Returns the element matching the key, or null if no such element exists.
    
    Parameters:
    
    key - the key to look for
    
    Returns:
    
    the element matching the key or null
  - removeNotIn
```
public void removeNotIn(int[] keys)
```
    Remove those elements which are not in keys.
    
    Parameters:
    
    keys - the keys to check for
    
    Since:
    
    1.00
  - rehash
```
private void rehash()
```
    Increase the capacity of the map to improve performance.
  - create
```
protected AbstractIntHashMap.MapElement create(int key,
                                               java.lang.Object value)
```
    Creates an element.
    
    Parameters:
    
    key - the hash key of the element
    
    value - the generic value to be attached
    
    Returns:
    
    the new element
    
    Since:
    
    1.00
  - construct
```
private void construct(int initialCapacity,
                       float loadFactor)
```
    Construction helper method.
    
    Parameters:
    
    initialCapacity - The initial capacity for this hash map.
    
    loadFactor - The load factor for this hash map.

Class AbstractIntHashMap

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

DEFAULT_CAPACITY

MAXIMUM_CAPACITY

DEFAULT_LOADFACTOR

map

contents

objectCounter

capacity

loadFactor

maxLoad

rehashing

Constructor Detail

AbstractIntHashMap

AbstractIntHashMap

AbstractIntHashMap

AbstractIntHashMap

Method Detail

putAll

size

isEmpty

clear

getObjectCounter

getCapacity

getLoadFactor

keySet

elements

setRehash

putElement

containsKey

removeElement

getElement

removeNotIn

rehash

create

construct