SequencedHashMap (Apache Directory LDAP API Utilities 2.1.5 API)

java.lang.Object
- org.apache.directory.api.util.SequencedHashMap

All Implemented Interfaces:

Externalizable, Serializable, Cloneable, Map

Direct Known Subclasses:

SynchronizedLRUMap
```
public class SequencedHashMap
extends Object
implements Map, Cloneable, Externalizable
```
A map of objects whose mapping entries are sequenced based on the order in which they were added. This data structure has fast O(1) search time, deletion time, and insertion time.
Although this map is sequenced, it cannot implement List because of incompatible interface definitions. The remove methods in List and Map have different return values (see: List.remove(Object) and Map.remove(Object)).
This class is not thread safe. When a thread safe implementation is required, use Collections.synchronizedMap(Map) as it is documented, or use explicit synchronization controls.

Since:

Commons Collections 2.0

Author:

Apache Directory Project

See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`private static class`	`SequencedHashMap.MapEntry` `Map.Entry` that doubles as a node in the linked list of sequenced mappings.
`private class`	`SequencedHashMap.OrderedIterator`

Nested classes/interfaces inherited from interface java.util.Map
Map.Entry<K,V>

Field Summary

Fields
Modifier and Type	Field and Description
`private HashMap`	`entries` Map of keys to entries
`private static int`	`ENTRY`
`private static int`	`KEY`
`private long`	`modCount` Holds the number of modifications that have occurred to the map, excluding modifications made through a collection view's iterator (e.g.
`private static int`	`REMOVED_MASK`
`private SequencedHashMap.MapEntry`	`sentinel` Sentinel used to hold the head and tail of the list of entries.
`private static long`	`serialVersionUID`
`private static int`	`VALUE`

Constructor Summary

Constructors
Constructor and Description
`SequencedHashMap()` Construct a new sequenced hash map with default initial size and load factor.
`SequencedHashMap(int initialSize)` Construct a new sequenced hash map with the specified initial size and default load factor.
`SequencedHashMap(int initialSize, float loadFactor)` Construct a new sequenced hash map with the specified initial size and load factor.
`SequencedHashMap(Map m)` Construct a new sequenced hash map and add all the elements in the specified map.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`clear()` Implements `Map.clear()`.
`Object`	`clone()` Creates a shallow copy of this object, preserving the internal structure by copying only references.
`boolean`	`containsKey(Object key)` Implements `Map.containsKey(Object)`.
`boolean`	`containsValue(Object value)` Implements `Map.containsValue(Object)`.
`private static SequencedHashMap.MapEntry`	`createSentinel()` Construct an empty sentinel used to hold the head (sentinel.next) and the tail (sentinel.prev) of the list.
`Set`	`entrySet()` Implements `Map.entrySet()`.
`boolean`	`equals(Object obj)` Implements `Map.equals(Object)`.
`Object`	`get(int index)` Gets the key at the specified index.
`Object`	`get(Object o)` Implements `Map.get(Object)`.
`private Map.Entry`	`getEntry(int index)` Returns the Map.Entry at the specified index
`Map.Entry`	`getFirst()` Return the entry for the "oldest" mapping.
`Object`	`getFirstKey()` Return the key for the "oldest" mapping.
`Object`	`getFirstValue()` Return the value for the "oldest" mapping.
`Map.Entry`	`getLast()` Return the entry for the "newest" mapping.
`Object`	`getLastKey()` Return the key for the "newest" mapping.
`Object`	`getLastValue()` Return the value for the "newest" mapping.
`Object`	`getValue(int index)` Gets the value at the specified index.
`int`	`hashCode()` Implements `Map.hashCode()`.
`int`	`indexOf(Object key)` Gets the index of the specified key.
`private void`	`insertEntry(SequencedHashMap.MapEntry entry)` Inserts a new internal entry to the tail of the linked list.
`boolean`	`isEmpty()` Implements `Map.isEmpty()`.
`Iterator`	`iterator()` Gets an iterator over the keys.
`Set`	`keySet()` Implements `Map.keySet()`.
`int`	`lastIndexOf(Object key)` Gets the last index of the specified key.
`Object`	`put(Object key, Object value)` Implements `Map.put(Object, Object)`.
`void`	`putAll(Map t)` Adds all the mappings in the specified map to this map, replacing any mappings that already exist (as per `Map.putAll(Map)`).
`void`	`readExternal(ObjectInput in)` Deserializes this map from the given stream.
`Object`	`remove(int index)` Removes the element at the specified index.
`Object`	`remove(Object key)` Implements `Map.remove(Object)`.
`private void`	`removeEntry(SequencedHashMap.MapEntry entry)` Removes an internal entry from the linked list.
`private SequencedHashMap.MapEntry`	`removeImpl(Object key)` Fully remove an entry from the map, returning the old entry or null if there was no such entry with the specified key.
`List`	`sequence()` Returns a List view of the keys rather than a set view.
`int`	`size()` Implements `Map.size()`.
`String`	`toString()` Provides a string representation of the entries within the map.
`Collection`	`values()` Implements `Map.values()`.
`void`	`writeExternal(ObjectOutput out)` Serializes this map to the given stream.

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

Methods inherited from interface java.util.Map
compute, computeIfAbsent, computeIfPresent, forEach, getOrDefault, merge, putIfAbsent, remove, replace, replace, replaceAll

- Field Detail
  - serialVersionUID
```
private static final long serialVersionUID
```
    See Also:
    
    Constant Field Values
  - KEY
```
private static final int KEY
```
    See Also:
    
    Constant Field Values
  - VALUE
```
private static final int VALUE
```
    See Also:
    
    Constant Field Values
  - ENTRY
```
private static final int ENTRY
```
    See Also:
    
    Constant Field Values
  - REMOVED_MASK
```
private static final int REMOVED_MASK
```
    See Also:
    
    Constant Field Values
  - sentinel
```
private transient SequencedHashMap.MapEntry sentinel
```
    Sentinel used to hold the head and tail of the list of entries.
  - entries
```
private HashMap entries
```
    Map of keys to entries
  - modCount
```
private transient long modCount
```
    Holds the number of modifications that have occurred to the map, excluding modifications made through a collection view's iterator (e.g. entrySet().iterator().remove()). This is used to create a fail-fast behavior with the iterators.
- Constructor Detail
  - SequencedHashMap
```
public SequencedHashMap()
```
    Construct a new sequenced hash map with default initial size and load factor.
  - SequencedHashMap
```
public SequencedHashMap(int initialSize)
```
    Construct a new sequenced hash map with the specified initial size and default load factor.
    
    Parameters:
    
    initialSize - the initial size for the hash table
    
    See Also:
    
    HashMap(int)
  - SequencedHashMap
```
public SequencedHashMap(int initialSize,
                        float loadFactor)
```
    Construct a new sequenced hash map with the specified initial size and load factor.
    
    Parameters:
    
    initialSize - the initial size for the hash table
    
    loadFactor - the load factor for the hash table.
    
    See Also:
    
    HashMap(int,float)
  - SequencedHashMap
```
public SequencedHashMap(Map m)
```
    Construct a new sequenced hash map and add all the elements in the specified map. The order in which the mappings in the specified map are added is defined by putAll(Map).
    
    Parameters:
    
    m - The original map
- Method Detail
  - createSentinel
```
private static SequencedHashMap.MapEntry createSentinel()
```
    Construct an empty sentinel used to hold the head (sentinel.next) and the tail (sentinel.prev) of the list. The sentinel has a null key and value.
    
    Returns:
    
    The created sentinel
  - removeEntry
```
private void removeEntry(SequencedHashMap.MapEntry entry)
```
    Removes an internal entry from the linked list. This does not remove it from the underlying map.
    
    Parameters:
    
    entry - The entry to remove
  - insertEntry
```
private void insertEntry(SequencedHashMap.MapEntry entry)
```
    Inserts a new internal entry to the tail of the linked list. This does not add the entry to the underlying map.
    
    Parameters:
    
    entry - The entry to insert
  - size
```
public int size()
```
    Implements Map.size().
    
    Specified by:
    
    size in interface Map
  - isEmpty
```
public boolean isEmpty()
```
    Implements Map.isEmpty().
    
    Specified by:
    
    isEmpty in interface Map
  - containsKey
```
public boolean containsKey(Object key)
```
    Implements Map.containsKey(Object).
    
    Specified by:
    
    containsKey in interface Map
  - containsValue
```
public boolean containsValue(Object value)
```
    Implements Map.containsValue(Object).
    
    Specified by:
    
    containsValue in interface Map
  - get
```
public Object get(Object o)
```
    Implements Map.get(Object).
    
    Specified by:
    
    get in interface Map
  - getFirst
```
public Map.Entry getFirst()
```
    Return the entry for the "oldest" mapping. That is, return the Map.Entry for the key-value pair that was first put into the map when compared to all the other pairings in the map. This behavior is equivalent to using entrySet().iterator().next(), but this method provides an optimized implementation.
    
    Returns:
    
    The first entry in the sequence, or null if the map is empty.
  - getFirstKey
```
public Object getFirstKey()
```
    Return the key for the "oldest" mapping. That is, return the key for the mapping that was first put into the map when compared to all the other objects in the map. This behavior is equivalent to using getFirst().getKey(), but this method provides a slightly optimized implementation.
    
    Returns:
    
    The first key in the sequence, or null if the map is empty.
  - getFirstValue
```
public Object getFirstValue()
```
    Return the value for the "oldest" mapping. That is, return the value for the mapping that was first put into the map when compared to all the other objects in the map. This behavior is equivalent to using getFirst().getValue(), but this method provides a slightly optimized implementation.
    
    Returns:
    
    The first value in the sequence, or null if the map is empty.
  - getLast
```
public Map.Entry getLast()
```
    Return the entry for the "newest" mapping. That is, return the Map.Entry for the key-value pair that was first put into the map when compared to all the other pairings in the map. The behavior is equivalent to:
```
 Object obj = null;
 Iterator iter = entrySet().iterator();
 while ( iter.hasNext() )
 {
     obj = iter.next();
 }
 return ( Map.Entry ) obj;
 
```
    However, the implementation of this method ensures an O(1) lookup of the last key rather than O(n).
    Returns:
    
    The last entry in the sequence, or null if the map is empty.
  - getLastKey
```
public Object getLastKey()
```
    Return the key for the "newest" mapping. That is, return the key for the mapping that was last put into the map when compared to all the other objects in the map. This behavior is equivalent to using getLast().getKey(), but this method provides a slightly optimized implementation.
    
    Returns:
    
    The last key in the sequence, or null if the map is empty.
  - getLastValue
```
public Object getLastValue()
```
    Return the value for the "newest" mapping. That is, return the value for the mapping that was last put into the map when compared to all the other objects in the map. This behavior is equivalent to using getLast().getValue(), but this method provides a slightly optimized implementation.
    
    Returns:
    
    The last value in the sequence, or null if the map is empty.
  - put
```
public Object put(Object key,
                  Object value)
```
    Implements Map.put(Object, Object).
    
    Specified by:
    
    put in interface Map
  - remove
```
public Object remove(Object key)
```
    Implements Map.remove(Object).
    
    Specified by:
    
    remove in interface Map
  - removeImpl
```
private SequencedHashMap.MapEntry removeImpl(Object key)
```
    Fully remove an entry from the map, returning the old entry or null if there was no such entry with the specified key.
    
    Parameters:
    
    key - The key to retreive
    
    Returns:
    
    The removed entry
  - putAll
```
public void putAll(Map t)
```
    Adds all the mappings in the specified map to this map, replacing any mappings that already exist (as per Map.putAll(Map)). The order in which the entries are added is determined by the iterator returned from Map.entrySet() for the specified map.
    
    Specified by:
    
    putAll in interface Map
    
    Parameters:
    
    t - the mappings that should be added to this map.
    
    Throws:
    
    NullPointerException - if t is null
  - clear
```
public void clear()
```
    Implements Map.clear().
    
    Specified by:
    
    clear in interface Map
  - equals
```
public boolean equals(Object obj)
```
    Implements Map.equals(Object).
    
    Specified by:
    
    equals in interface Map
    
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Implements Map.hashCode().
    
    Specified by:
    
    hashCode in interface Map
    
    Overrides:
    
    hashCode in class Object
    
    Returns:
    
    the instance's hash code
  - toString
```
public String toString()
```
    Provides a string representation of the entries within the map. The format of the returned string may change with different releases, so this method is suitable for debugging purposes only. If a specific format is required, use entrySet().iterator() and iterate over the entries in the map formatting them as appropriate.
    
    Overrides:
    
    toString in class Object
  - keySet
```
public Set keySet()
```
    Implements Map.keySet().
    
    Specified by:
    
    keySet in interface Map
  - values
```
public Collection values()
```
    Implements Map.values().
    
    Specified by:
    
    values in interface Map
  - entrySet
```
public Set entrySet()
```
    Implements Map.entrySet().
    
    Specified by:
    
    entrySet in interface Map
  - clone
```
public Object clone()
             throws CloneNotSupportedException
```
    Creates a shallow copy of this object, preserving the internal structure by copying only references. The keys and values themselves are not clone()'d. The cloned object maintains the same sequence.
    
    Overrides:
    
    clone in class Object
    
    Returns:
    
    A clone of this instance.
    
    Throws:
    
    CloneNotSupportedException - if clone is not supported by a subclass.
  - getEntry
```
private Map.Entry getEntry(int index)
```
    Returns the Map.Entry at the specified index
    
    Parameters:
    
    index - The index we are looking for
    
    Returns:
    
    The found entry
    
    Throws:
    
    ArrayIndexOutOfBoundsException - if the specified index is < 0 or > the size of the map.
  - get
```
public Object get(int index)
```
    Gets the key at the specified index.
    
    Parameters:
    
    index - the index to retrieve
    
    Returns:
    
    the key at the specified index, or null
    
    Throws:
    
    ArrayIndexOutOfBoundsException - if the index is < 0 or > the size of the map.
  - getValue
```
public Object getValue(int index)
```
    Gets the value at the specified index.
    
    Parameters:
    
    index - the index to retrieve
    
    Returns:
    
    the value at the specified index, or null
    
    Throws:
    
    ArrayIndexOutOfBoundsException - if the index is < 0 or > the size of the map.
  - indexOf
```
public int indexOf(Object key)
```
    Gets the index of the specified key.
    
    Parameters:
    
    key - the key to find the index of
    
    Returns:
    
    the index, or -1 if not found
  - iterator
```
public Iterator iterator()
```
    Gets an iterator over the keys.
    
    Returns:
    
    an iterator over the keys
  - lastIndexOf
```
public int lastIndexOf(Object key)
```
    Gets the last index of the specified key.
    
    Parameters:
    
    key - the key to find the index of
    
    Returns:
    
    the index, or -1 if not found
  - sequence
```
public List sequence()
```
    Returns a List view of the keys rather than a set view. The returned list is unmodifiable. This is required because changes to the values of the list (using ListIterator.set(Object)) will effectively remove the value from the list and reinsert that value at the end of the list, which is an unexpected side effect of changing the value of a list. This occurs because changing the key, changes when the mapping is added to the map and thus where it appears in the list.
    An alternative to this method is to use keySet()
    
    Returns:
    
    The ordered list of keys.
    
    See Also:
    
    keySet()
  - remove
```
public Object remove(int index)
```
    Removes the element at the specified index.
    
    Parameters:
    
    index - The index of the object to remove.
    
    Returns:
    
    The previous value corresponding the key, or null if none existed.
    
    Throws:
    
    ArrayIndexOutOfBoundsException - if the index is < 0 or > the size of the map.
  - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
    Deserializes this map from the given stream.
    
    Specified by:
    
    readExternal in interface Externalizable
    
    Parameters:
    
    in - the stream to deserialize from
    
    Throws:
    
    IOException - if the stream raises it
    
    ClassNotFoundException - if the stream raises it
  - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
    Serializes this map to the given stream.
    
    Specified by:
    
    writeExternal in interface Externalizable
    
    Parameters:
    
    out - the stream to serialize to
    
    Throws:
    
    IOException - if the stream raises it

Class SequencedHashMap

Nested Class Summary

Nested classes/interfaces inherited from interface java.util.Map

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.Map

Field Detail

serialVersionUID

KEY

VALUE

ENTRY

REMOVED_MASK

sentinel

entries

modCount

Constructor Detail

SequencedHashMap

SequencedHashMap

SequencedHashMap

SequencedHashMap

Method Detail

createSentinel

removeEntry

insertEntry

size

isEmpty

containsKey

containsValue

get

getFirst

getFirstKey

getFirstValue

getLast

getLastKey

getLastValue

put

remove

removeImpl

putAll

clear

equals

hashCode

toString

keySet

values

entrySet

clone

getEntry

get

getValue

indexOf

iterator

lastIndexOf

sequence

remove

readExternal

writeExternal