Interface SequencedMap<K,V>

Type Parameters:
K - the type of keys maintained by this map
V - the type of mapped values
All Superinterfaces:
Map<K,V>
All Known Subinterfaces:
ConcurrentNavigableMap<K,V>, NavigableMap<K,V>, SortedMap<K,V>
All Known Implementing Classes:
ConcurrentSkipListMap, LinkedHashMap, TreeMap
public interface SequencedMap<K,V> extends Map<K,V>
A Map that has a well-defined encounter order, that supports operations at both ends, and that is reversible. The encounter order of a SequencedMap is similar to that of the elements of a SequencedCollection, but the ordering applies to mappings instead of individual elements.

The bulk operations on this map, including the forEach and the replaceAll methods, operate on this map's mappings in encounter order.

The view collections provided by the keySet, values, entrySet, sequencedKeySet, sequencedValues, and sequencedEntrySet methods all reflect the encounter order of this map. Even though the return values of the keySet, values, and entrySet methods are not sequenced types, the elements in those view collections do reflect the encounter order of this map. Thus, the iterators returned by the statements 

    var it1 = sequencedMap.entrySet().iterator();
    var it2 = sequencedMap.sequencedEntrySet().iterator();
both provide the mappings of sequencedMap in that map's encounter order.

This interface provides methods to add mappings, to retrieve mappings, and to remove mappings at either end of the map's encounter order.

This interface also defines the reversed() method, which provides a reverse-ordered view of this map. In the reverse-ordered view, the concepts of first and last are inverted, as are the concepts of successor and predecessor. The first mapping of this map is the last mapping of the reverse-ordered view, and vice-versa. The successor of some mapping in this map is its predecessor in the reversed view, and vice-versa. All methods that respect the encounter order of the map operate as if the encounter order is inverted. For instance, the forEach method of the reversed view reports the mappings in order from the last mapping of this map to the first. In addition, all of the view collections of the reversed view also reflect the inverse of this map's encounter order. For example, 

    var itr = sequencedMap.reversed().entrySet().iterator();
provides the mappings of this map in the inverse of the encounter order, that is, from the last mapping to the first mapping. The availability of the reversed method, and its impact on the ordering semantics of all applicable methods and views, allow convenient iteration, searching, copying, and streaming of this map's mappings in either forward order or reverse order.

A map's reverse-ordered view is generally not serializable, even if the original map is serializable.

The Map.Entry instances obtained by iterating the Map.entrySet() view, the sequencedEntrySet() view, and its reverse-ordered view, maintain a connection to the underlying map. This connection is guaranteed only during the iteration. It is unspecified whether the connection is maintained outside of the iteration. If the underlying map permits it, calling an Entry's setValue method will modify the value of the underlying mapping. It is, however, unspecified whether modifications to the value in the underlying mapping are visible in the Entry instance.

The methods firstEntry(), lastEntry(), pollFirstEntry(), and pollLastEntry() return Map.Entry instances that represent snapshots of mappings as of the time of the call. They do not support mutation of the underlying map via the optional setValue method.

Depending upon the implementation, the Entry instances returned by other means might or might not be connected to the underlying map. For example, consider an Entry obtained in the following manner: 

    var entry = sequencedMap.sequencedEntrySet().getFirst();
It is not specified by this interface whether the setValue method of the Entry thus obtained will update a mapping in the underlying map, or whether it will throw an exception, or whether changes to the underlying map are visible in that Entry.

This interface has the same requirements on the equals and hashCode methods as defined by Map.equals and Map.hashCode. Thus, a Map and a SequencedMap will compare equals if and only if they have equal mappings, irrespective of ordering.

This class is a member of the Java Collections Framework.

Since:
21

  • Nested Class Summary

    Nested classes/interfaces declared in interface Map

    Map.Entry<K,V>
    Modifier and Type
    Interface
    Description
    static interface 
    Map.Entry<K,V>
    A map entry (key-value pair).

  • Method Summary

    Modifier and Type
    Method
    Description
    default Map.Entry<K,V>
    firstEntry()
    Returns the first key-value mapping in this map, or null if the map is empty.
    default Map.Entry<K,V>
    lastEntry()
    Returns the last key-value mapping in this map, or null if the map is empty.
    default Map.Entry<K,V>
    pollFirstEntry()
    Removes and returns the first key-value mapping in this map, or null if the map is empty (optional operation).
    default Map.Entry<K,V>
    pollLastEntry()
    Removes and returns the last key-value mapping in this map, or null if the map is empty (optional operation).
    default V
    putFirst(K k, V v)
    Inserts the given mapping into the map if it is not already present, or replaces the value of a mapping if it is already present (optional operation).
    default V
    putLast(K k, V v)
    Inserts the given mapping into the map if it is not already present, or replaces the value of a mapping if it is already present (optional operation).
    SequencedMap<K,V>
    reversed()
    Returns a reverse-ordered view of this map.
    default SequencedSet<Map.Entry<K,V>>
    sequencedEntrySet()
    Returns a SequencedSet view of this map's entrySet.
    default SequencedSet<K>
    sequencedKeySet()
    Returns a SequencedSet view of this map's keySet.
    default SequencedCollection<V>
    sequencedValues()
    Returns a SequencedCollection view of this map's values collection.

    Methods declared in interface Map

    clear, compute, computeIfAbsent, computeIfPresent, containsKey, containsValue, entrySet, equals, forEach, get, getOrDefault, hashCode, isEmpty, keySet, merge, put, putAll, putIfAbsent, remove, remove, replace, replace, replaceAll, size, values
    Modifier and Type
    Method
    Description
    void
    clear()
    Removes all of the mappings from this map (optional operation).
    default V
    compute(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction)
    Attempts to compute a mapping for the specified key and its current mapped value, or null if there is no current mapping (optional operation).
    default V
    computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction)
    If the specified key is not already associated with a value (or is mapped to null), attempts to compute its value using the given mapping function and enters it into this map unless null (optional operation).
    default V
    computeIfPresent(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction)
    If the value for the specified key is present and non-null, attempts to compute a new mapping given the key and its current mapped value (optional operation).
    boolean
    containsKey(Object key)
    Returns true if this map contains a mapping for the specified key.
    boolean
    containsValue(Object value)
    Returns true if this map maps one or more keys to the specified value.
    Set<Map.Entry<K,V>>
    entrySet()
    Returns a Set view of the mappings contained in this map.
    boolean
    equals(Object o)
    Compares the specified object with this map for equality.
    default void
    forEach(BiConsumer<? super K, ? super V> action)
    Performs the given action for each entry in this map until all entries have been processed or the action throws an exception.
    V
    get(Object key)
    Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key.
    default V
    getOrDefault(Object key, V defaultValue)
    Returns the value to which the specified key is mapped, or defaultValue if this map contains no mapping for the key.
    int
    hashCode()
    Returns the hash code value for this map.
    boolean
    isEmpty()
    Returns true if this map contains no key-value mappings.
    Set<K>
    keySet()
    Returns a Set view of the keys contained in this map.
    default V
    merge(K key, V value, BiFunction<? super V, ? super V, ? extends V> remappingFunction)
    If the specified key is not already associated with a value or is associated with null, associates it with the given non-null value (optional operation).
    V
    put(K key, V value)
    Associates the specified value with the specified key in this map (optional operation).
    void
    putAll(Map<? extends K, ? extends V> m)
    Copies all of the mappings from the specified map to this map (optional operation).
    default V
    putIfAbsent(K key, V value)
    If the specified key is not already associated with a value (or is mapped to null) associates it with the given value and returns null, else returns the current value (optional operation).
    V
    remove(Object key)
    Removes the mapping for a key from this map if it is present (optional operation).
    default boolean
    remove(Object key, Object value)
    Removes the entry for the specified key only if it is currently mapped to the specified value (optional operation).
    default V
    replace(K key, V value)
    Replaces the entry for the specified key only if it is currently mapped to some value (optional operation).
    default boolean
    replace(K key, V oldValue, V newValue)
    Replaces the entry for the specified key only if currently mapped to the specified value (optional operation).
    default void
    replaceAll(BiFunction<? super K, ? super V, ? extends V> function)
    Replaces each entry's value with the result of invoking the given function on that entry until all entries have been processed or the function throws an exception (optional operation).
    int
    size()
    Returns the number of key-value mappings in this map.
    Collection<V>
    values()
    Returns a Collection view of the values contained in this map.

  • Method Details

    • reversed

      SequencedMap<K,V> reversed()
      Returns a reverse-ordered view of this map. The encounter order of mappings in the returned view is the inverse of the encounter order of mappings in this map. The reverse ordering affects all order-sensitive operations, including those on the view collections of the returned view. If the implementation permits modifications to this view, the modifications "write through" to the underlying map. Changes to the underlying map might or might not be visible in this reversed view, depending upon the implementation.
      Returns:
      a reverse-ordered view of this map

    • firstEntry

      default Map.Entry<K,V> firstEntry()
      Returns the first key-value mapping in this map, or null if the map is empty.
      Implementation Requirements:
      The implementation in this interface obtains the iterator of this map's entrySet. If the iterator has an element, it returns an unmodifiable copy of that element. Otherwise, it returns null.
      Returns:
      the first key-value mapping, or null if this map is empty

    • lastEntry

      default Map.Entry<K,V> lastEntry()
      Returns the last key-value mapping in this map, or null if the map is empty.
      Implementation Requirements:
      The implementation in this interface obtains the iterator of the entrySet of this map's reversed view. If the iterator has an element, it returns an unmodifiable copy of that element. Otherwise, it returns null.
      Returns:
      the last key-value mapping, or null if this map is empty

    • pollFirstEntry

      default Map.Entry<K,V> pollFirstEntry()
      Removes and returns the first key-value mapping in this map, or null if the map is empty (optional operation).
      Implementation Requirements:
      The implementation in this interface obtains the iterator of this map's entrySet. If the iterator has an element, it calls remove on the iterator and then returns an unmodifiable copy of that element. Otherwise, it returns null.
      Returns:
      the removed first entry of this map, or null if this map is empty
      Throws:
      UnsupportedOperationException - if this collection implementation does not support this operation

    • pollLastEntry

      default Map.Entry<K,V> pollLastEntry()
      Removes and returns the last key-value mapping in this map, or null if the map is empty (optional operation).
      Implementation Requirements:
      The implementation in this interface obtains the iterator of the entrySet of this map's reversed view. If the iterator has an element, it calls remove on the iterator and then returns an unmodifiable copy of that element. Otherwise, it returns null.
      Returns:
      the removed last entry of this map, or null if this map is empty
      Throws:
      UnsupportedOperationException - if this collection implementation does not support this operation

    • putFirst

      default V putFirst(K k, V v)
      Inserts the given mapping into the map if it is not already present, or replaces the value of a mapping if it is already present (optional operation). After this operation completes normally, the given mapping will be present in this map, and it will be the first mapping in this map's encounter order.
      Implementation Requirements:
      The implementation in this interface always throws UnsupportedOperationException.
      Parameters:
      k - the key
      v - the value
      Returns:
      the value previously associated with k, or null if none
      Throws:
      UnsupportedOperationException - if this collection implementation does not support this operation

    • putLast

      default V putLast(K k, V v)
      Inserts the given mapping into the map if it is not already present, or replaces the value of a mapping if it is already present (optional operation). After this operation completes normally, the given mapping will be present in this map, and it will be the last mapping in this map's encounter order.
      Implementation Requirements:
      The implementation in this interface always throws UnsupportedOperationException.
      Parameters:
      k - the key
      v - the value
      Returns:
      the value previously associated with k, or null if none
      Throws:
      UnsupportedOperationException - if this collection implementation does not support this operation

    • sequencedKeySet

      default SequencedSet<K> sequencedKeySet()
      Returns a SequencedSet view of this map's keySet.
      Implementation Requirements:
      The implementation in this interface returns a SequencedSet instance that behaves as follows. Its add, addAll, addFirst, and addLast methods throw UnsupportedOperationException. Its getFirst and getLast methods are implemented in terms of the firstEntry and lastEntry methods of this interface, respectively. Its removeFirst and removeLast methods are implemented in terms of the pollFirstEntry and pollLastEntry methods of this interface, respectively. Its reversed method returns the sequencedKeySet view of the reversed view of this map. Each of its other methods calls the corresponding method of the keySet view of this map.
      Returns:
      a SequencedSet view of this map's keySet

    • sequencedValues

      default SequencedCollection<V> sequencedValues()
      Returns a SequencedCollection view of this map's values collection.
      Implementation Requirements:
      The implementation in this interface returns a SequencedCollection instance that behaves as follows. Its add, addAll, addFirst, and addLast methods throw UnsupportedOperationException. Its getFirst and getLast methods are implemented in terms of the firstEntry and lastEntry methods of this interface, respectively. Its removeFirst and removeLast methods are implemented in terms of the pollFirstEntry and pollLastEntry methods of this interface, respectively. Its reversed method returns the sequencedValues view of the reversed view of this map. Its equals and hashCode methods are inherited from Object. Each of its other methods calls the corresponding method of the values view of this map.
      Returns:
      a SequencedCollection view of this map's values collection

    • sequencedEntrySet

      default SequencedSet<Map.Entry<K,V>> sequencedEntrySet()
      Returns a SequencedSet view of this map's entrySet.
      Implementation Requirements:
      The implementation in this interface returns a SequencedSet instance that behaves as follows. Its add, addAll, addFirst, and addLast methods throw UnsupportedOperationException. Its getFirst and getLast methods are implemented in terms of the firstEntry and lastEntry methods of this interface, respectively. Its removeFirst and removeLast methods are implemented in terms of the pollFirstEntry and pollLastEntry methods of this interface, respectively. Its reversed method returns the sequencedEntrySet view of the reversed view of this map. Each of its other methods calls the corresponding method of the entrySet view of this map.
      Returns:
      a SequencedSet view of this map's entrySet