Spec-Zone.ru › OpenJDK 21

Класс LinkedHashMap<K,V>

java.lang.Object
java.util.AbstractMap<K,V>
java.util.HashMap<K,V>
java.util.LinkedHashMap<K,V>
Type Parameters:
K - тип ключей, поддерживаемых этой картой
V - тип сопоставленных значений
Все реализованные интерфейсы:
Serializable, Cloneable, Map<K,V>, SequencedMap<K,V>
public class LinkedHashMap<K,V> extends HashMap<K,V> implements SequencedMap<K,V>

Реализация таблицы хеширования и связанного списка интерфейса Map, с хорошо определённым порядком встречи элементов. Эта реализация отличается от HashMap тем, что она поддерживает двусвязный список, проходящий через все свои элементы. Этот список определяет порядок встречи (порядок итерации), который обычно совпадает с порядком вставки ключей в карту (порядок вставки). Элемент, добавленный последним (самый старый), находится первым, а самый молодой — последним. Обратите внимание, что порядок встречи не изменяется, если ключ перевставлен в карту с помощью метода put. (Ключ k перевставляется в карту m если m.put(k, v) вызывается, когда m.containsKey(k) вернул бы true непосредственно перед вызовом.) Обратный вид этой карты упорядочен в обратном порядке, при этом самый молодой элемент появляется первым, а самый старый — последним. Порядок встречи элементов, уже присутствующих в карте, может быть изменён с помощью методов putFirst и putLast.

Эта реализация избавляет клиентов от неопределённого, как правило, хаотичного порядка, предоставляемого классом HashMap (и Hashtable), не неся дополнительных затрат, связанных с использованием TreeMap. Её можно использовать для создания копии карты, имеющей тот же порядок, что и исходная карта, независимо от реализации исходной карты:


     void foo(Map<String, Integer> m) {
         Map<String, Integer> copy = new LinkedHashMap<>(m);
         ...
     }
 
Этот приём особенно полезен, если модуль принимает карту на вход, копирует её и позже возвращает результаты, порядок которых определяется порядком этой копии. (Клиенты, как правило, ценят получение результатов в том же порядке, в котором они были представлены.)

Предоставляется специальный конструктор constructor для создания связанной карты хеширования, порядок встречи элементов в которой соответствует порядку их последнего доступа — от наименее до наиболее часто используемого (порядок доступа). Этот тип карты подходит для построения кэшей LRU.

Вызов методов put, putIfAbsent, get, getOrDefault, compute, computeIfAbsent, computeIfPresent, или merge приводит к доступу к соответствующему элементу (если он существует после завершения вызова). Методы replace приводят к доступу к элементу только в случае замены значения. Метод putAll генерирует один доступ к элементу для каждой пары "ключ-значение" в указанной карте в порядке, определённом итератором набора элементов указанной карты. Никакие другие методы не генерируют доступ к элементам. Вызов этих методов на обратном представлении генерирует доступ к элементам в обратной карте. Обратите внимание, что при обратном представлении доступ к элементу перемещает его на первое место в порядке встречи. Явные методы позиционирования, такие как putFirst или lastEntry, независимо от того, применяются ли они к карте или её обратному представлению, выполняют операцию позиционирования и не генерируют доступ к элементам.

Операции над представлениями keySet, values, и entrySet или над их эквивалентами в виде последовательностей не влияют на порядок встречи элементов в исходной карте.

Метод removeEldestEntry(Map.Entry) может быть переопределён для наложения политики удаления устаревших сопоставлений автоматически при добавлении новых сопоставлений в карту. В качестве альтернативы, поскольку "самый старый" элемент является первым элементом в порядке встречи, программы могут проверять и удалять устаревшие сопоставления, используя методы firstEntry и pollFirstEntry.

Этот класс предоставляет все необязательные операции Map и SequencedMap, а также позволяет использовать нулевые значения. Как и HashMap, он обеспечивает постоянную производительность основных операций (add, contains и remove) при условии, что функция хеширования должным образом распределяет элементы по корзинам. Вероятная производительность немного ниже, чем у HashMap, из-за дополнительных затрат на поддержание связанного списка, за исключением одного случая: итерация по представлениям коллекции класса LinkedHashMap требует времени, пропорционального размеру карты, независимо от её ёмкости. Итерация по представлению HashMap может быть более затратной, требуя времени, пропорционального её ёмкости.

Связанная карта хеширования имеет два параметра, влияющих на её производительность: начальную ёмкость и коэффициент заполнения. Они определяются точно так же, как и для HashMap. Однако штраф за выбор чрезмерно большого значения для начальной ёмкости для этого класса меньше, чем для HashMap, так как время итерации для этого класса не зависит от ёмкости.

Обратите внимание, что эта реализация не синхронизирована. Если несколько потоков одновременно обращаются к связанной карте хеширования, и по меньшей мере один из потоков изменяет карту структурно, она должна быть синхронизирована внешне. Это обычно достигается путём синхронизации на некотором объекте, естественным образом инкапсулирующем карту. Если такого объекта нет, карта должна быть «обёрнута» с помощью метода Collections.synchronizedMap. Лучше всего это сделать при создании, чтобы предотвратить случайный несинхронизированный доступ к карте:

   Map m = Collections.synchronizedMap(new LinkedHashMap(...));
Структурное изменение — это любая операция, добавляющая или удаляющая одно или несколько сопоставлений или, в случае связанных карт хеширования с порядком доступа, влияющая на порядок итерации. В связанных картах хеширования с порядком вставки простое изменение значения, связанного с ключом, уже присутствующим в карте, не является структурным изменением. В связанных картах хеширования с порядком доступа простое обращение к карте с помощью get является структурным изменением.)

Итераторы, возвращаемые методом iterator коллекций, возвращаемых всеми коллекционными представлениями этого класса, являются быстропроверяемыми: если карта изменяется структурно в любое время после создания итератора, любым способом, кроме метода собственного итератора remove, итератор выбросит исключение ConcurrentModificationException. Таким образом, при одновременном изменении итератор быстро и корректно завершает работу, вместо того чтобы рисковать произвольным, неопределённым поведением в неопределённое время в будущем.

Обратите внимание, что гарантировать быстрое обнаружение ошибки при одновременном изменении невозможно, так как это, как правило, невозможно гарантировать при одновременном изменении без синхронизации. Быстропроверяемые итераторы выбрасывают ConcurrentModificationException в режиме наилучшего усилия. Поэтому неправильно писать программу, зависящую от этого исключения для правильности: поведение быстропроверяемых итераторов должно использоваться только для обнаружения ошибок.

Разделители, возвращаемые методом splitator коллекций, возвращаемых всеми коллекционными представлениями этого класса, являются поздно-связанными, быстропроверяемыми и дополнительно сообщают о Spliterator.ORDERED.

Этот класс является членом Java Collections Framework.

Примечание реализации:
Разделители, возвращаемые методом spliterator коллекций, возвращаемых всеми коллекционными представлениями этого класса, создаются из итераторов соответствующих коллекций.
С тех пор:
1.4
См. также:
  • Object.hashCode()
  • Collection
  • Map
  • HashMap
  • TreeMap
  • Hashtable
  • Сериализованная форма

Краткое описание вложенных классов

Вложенные классы/интерфейсы, объявленные в классе java.util.AbstractMap

AbstractMap.SimpleEntry<K,V>, AbstractMap.SimpleImmutableEntry<K,V>

Краткое описание конструкторов

Конструктор Описание
LinkedHashMap()
Создаёт пустой упорядоченный по вставке LinkedHashMap экземпляр с начальной ёмкостью по умолчанию (16) и коэффициентом загрузки (0.75).
LinkedHashMap(int initialCapacity)
Создаёт пустой упорядоченный по вставке LinkedHashMap экземпляр с указанной начальной ёмкостью и коэффициентом загрузки по умолчанию (0.75).
LinkedHashMap(int initialCapacity, float loadFactor)
Создаёт пустой упорядоченный по вставке LinkedHashMap экземпляр с указанной начальной ёмкостью и коэффициентом загрузки.
LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder)
Создаёт пустой LinkedHashMap экземпляр с указанной начальной ёмкостью, коэффициентом загрузки и режимом упорядочивания.
LinkedHashMap(Map<? extends K,? extends V> m)
Создаёт упорядоченный по вставке LinkedHashMap экземпляр с теми же отображениями, что и у указанной карты.

Краткое описание методов

Модификатор и тип Метод Описание
void clear()
Удаляет все отображения из этой карты.
boolean containsValue(Object value)
Возвращает true если эта карта сопоставляет одну или несколько ключей со значением.
Set<Map.Entry<K,V>> entrySet()
Возвращает представление типа Set отображений, содержащихся в этой карте.
V get(Object key)
Возвращает значение, которому соответствует указанный ключ, или null если эта карта не содержит отображения для ключа.
Set<K> keySet()
Возвращает представление типа Set ключей, содержащихся в этой карте.
static <K, V> LinkedHashMap<K,V> newLinkedHashMap(int numMappings)
Создаёт новую, пустую, упорядоченную по вставке LinkedHashMap, подходящую для ожидаемого количества отображений.
V putFirst(K k, V v)
Вставляет указанное отображение в карту, если оно ещё не присутствует, или заменяет значение отображения, если оно уже присутствует (необязательная операция).
V putLast(K k, V v)
Вставляет указанное отображение в карту, если оно ещё не присутствует, или заменяет значение отображения, если оно уже присутствует (необязательная операция).
protected boolean removeEldestEntry(Map.Entry<K,V> eldest)
Возвращает true если эта карта должна удалить свою самую старую запись.
SequencedMap<K,V> reversed()
Возвращает упорядоченное по убыванию представление представление этой карты.
SequencedSet<Map.Entry<K,V>> sequencedEntrySet()
Возвращает представление SequencedSet набора entrySet этой карты.
SequencedSet<K> sequencedKeySet()
Возвращает представление SequencedSet набора ключей keySet этой карты.
SequencedCollection<V> sequencedValues()
Возвращает представление SequencedCollection коллекции значений values этой карты.
Collection<V> values()
Возвращает представление Collection значений, содержащихся в этой карте.

Методы, объявленные в классе java.util.HashMap

clear, clone, compute, computeIfAbsent, computeIfPresent, containsKey, isEmpty, merge, newHashMap, put, putAll, remove, size

Методы, объявленные в классе java.util.AbstractMap

equals, hashCode, toString

Методы, объявленные в классе java.lang.Object

finalize, getClass, notify, notifyAll, wait, wait, wait

Методы, объявленные в интерфейсе java.util.Map

compute, computeIfAbsent, computeIfPresent, containsKey, equals, forEach, getOrDefault, hashCode, isEmpty, merge, put, putAll, putIfAbsent, remove, remove, replace, replace, replaceAll, size

Методы, объявленные в интерфейсе java.util.SequencedMap

firstEntry, lastEntry, pollFirstEntry, pollLastEntry

Подробное описание конструкторов

LinkedHashMap

public LinkedHashMap(int initialCapacity, float loadFactor)
Создаёт пустой экземпляр LinkedHashMap с указанной начальной ёмкостью и коэффициентом заполнения.
Примечание API:
Для создания LinkedHashMap с начальной ёмкостью, достаточной для ожидаемого числа отображений, используйте newLinkedHashMap.
Параметры:
initialCapacity - начальная ёмкость
loadFactor - коэффициент заполнения
Исключения:
IllegalArgumentException - если начальная ёмкость отрицательная или коэффициент заполнения не положительный

LinkedHashMap

public LinkedHashMap(int initialCapacity)
Создаёт пустой экземпляр LinkedHashMap с указанной начальной ёмкостью и значением коэффициента заполнения по умолчанию (0.75).
Примечание API:
Для создания LinkedHashMap с начальной ёмкостью, достаточной для ожидаемого числа отображений, используйте newLinkedHashMap.
Параметры:
initialCapacity - начальная ёмкость
Исключения:
IllegalArgumentException - если начальная ёмкость отрицательная

LinkedHashMap

public LinkedHashMap()
Создаёт пустой экземпляр LinkedHashMap с начальной ёмкостью по умолчанию (16) и коэффициентом заполнения по умолчанию (0.75).

LinkedHashMap

public LinkedHashMap(Map<? extends K,? extends V> m)
Создаёт экземпляр LinkedHashMap с теми же отображениями, что и у указанной карты. Экземпляр LinkedHashMap создаётся с коэффициентом заполнения по умолчанию (0.75) и начальной ёмкостью, достаточной для размещения отображений в указанной карте.
Параметры:
m - карта, отображения которой должны быть помещены в эту карту
Исключения:
NullPointerException - если указанная карта равна null

LinkedHashMap

public LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder)
Создаёт пустой экземпляр LinkedHashMap с указанной начальной ёмкостью, коэффициентом заполнения и режимом упорядочивания.
Параметры:
initialCapacity - начальная ёмкость
loadFactor - коэффициент заполнения
accessOrder - режим упорядочивания - true для порядка доступа, false для порядка вставки
Исключения:
IllegalArgumentException - если начальная ёмкость отрицательная или коэффициент заполнения не положительный

Подробное описание методов

putFirst

public V putFirst(K k, V v)
Вставляет заданное отображение в карту, если оно ещё не присутствует, или заменяет значение отображения, если оно уже присутствует (необязательная операция). После нормального завершения этой операции заданное отображение будет присутствовать в этой карте, и оно будет первым отображением в порядке встречи этой карты.

Если эта карта уже содержит отображение для этого ключа, отображение перемещается, если необходимо, так, чтобы оно было первым в порядке встречи.

Определено в:
putFirst в интерфейсе SequencedMap<K,V>
Параметры:
k - ключ
v - значение
Возвращает:
предыдущее значение, связанное с k, или null, если нет
С:
21

putLast

public V putLast(K k, V v)
Вставляет заданное отображение в карту, если оно ещё не присутствует, или заменяет значение отображения, если оно уже присутствует (необязательная операция). После нормального завершения этой операции заданное отображение будет присутствовать в этой карте, и оно будет последним отображением в порядке встречи этой карты.

Если эта карта уже содержит отображение для этого ключа, отображение перемещается, если необходимо, так, чтобы оно было последним в порядке встречи.

Определено в:
putLast в интерфейсе SequencedMap<K,V>
Параметры:
k - ключ
v - значение
Возвращает:
предыдущее значение, связанное с k, или null, если нет
С:
21

containsValue

public boolean containsValue(Object value)
Возвращает true если эта карта сопоставляет один или несколько ключей указанному значению.
Определено в:
containsValue в интерфейсе Map<K,V>
Переопределяет:
containsValue в классе HashMap<K,V>
Параметры:
value - значение, чьё присутствие в этой карте нужно проверить
Возвращает:
true если эта карта сопоставляет один или несколько ключей указанному значению

get

public V get(Object key)
Возвращает значение, которому сопоставлен указанный ключ, или null если эта карта не содержит отображения для ключа.

Более формально, если эта карта содержит отображение из ключа k в значение v такое, что (key==null ? k==null : key.equals(k)), то этот метод возвращает v; в противном случае возвращает null. (Может быть не более одного такого отображения.)

Возвращаемое значение null не обязательно указывает, что карта не содержит отображения для ключа; также возможно, что карта явно сопоставляет ключ со значением null. Операция containsKey может быть использована для различения этих двух случаев.

Определено в:
get в интерфейсе Map<K,V>
Переопределяет:
get в классе HashMap<K,V>
Параметры:
key - ключ, чьё связанное значение должно быть возвращено
Возвращает:
значение, которому сопоставлен указанный ключ, или null если эта карта не содержит отображения для ключа
См. также:
  • HashMap.put(Object, Object)

clear

public void clear()
Удаляет все отображения из этой карты. Карта будет пустой после возврата этого вызова.
Определено в:
clear в интерфейсе Map<K,V>
Переопределяет:
clear в классе HashMap<K,V>

removeEldestEntry

protected boolean removeEldestEntry(Map.Entry<K,V> eldest)
Возвращает true если эта карта должна удалить своё самое старое отображение. Этот метод вызывается put и putAll после вставки нового отображения в карту. Он предоставляет реализатору возможность удалять самое старое отображение каждый раз, когда добавляется новое. Это полезно, если карта представляет собой кэш: это позволяет карте уменьшить потребление памяти, удаляя устаревшие записи.

Пример использования: это переопределение позволит карте расти до 100 записей, а затем удалять самое старое отображение каждый раз, когда добавляется новая запись, поддерживая стабильное состояние из 100 записей.

     private static final int MAX_ENTRIES = 100;

     protected boolean removeEldestEntry(Map.Entry eldest) {
        return size() > MAX_ENTRIES;
     }
 

Этот метод обычно не изменяет карту каким-либо образом, вместо этого позволяя карте изменить себя в соответствии с возвращаемым значением. Разрешается, чтобы этот метод непосредственно изменял карту, но если он это делает, он обязан вернуть false (указывающее, что карта не должна пытаться произвести дальнейшие изменения). Эффекты возвращения true после изменения карты внутри этого метода не определены.

Эта реализация просто возвращает false (чтобы эта карта вела себя как обычная карта - самое старое элемент никогда не удаляется).

Параметры:
eldest - самое недавно добавленное отображение в карте, или, если это карта с порядком доступа, самое последнее отображение. Это отображение, которое будет удалено, если этот метод возвращает true. Если карта была пустой до вызова put или putAll, приведшего к этому вызову, это будет отображение, которое только что было вставлено; другими словами, если карта содержит одну запись, самое старое отображение также является самым новым.
Возвращает:
true если самое старое отображение должно быть удалено из карты; false если оно должно быть сохранено.

keySet

public Set<K> keySet()
Возвращает вид Set ключей, содержащихся в этой карте. Порядок встречи ключей в представлении соответствует порядку встречи отображений этой карты. Множество подкрепляется картой, поэтому изменения в карте отражаются в множестве и наоборот. Если карта изменяется во время итерации по множеству (кроме операции собственного итератора remove ), результаты итерации не определены. Множество поддерживает удаление элементов, что удаляет соответствующее отображение из карты, через операции Iterator.remove, Set.remove, removeAll, retainAll, и clear. Оно не поддерживает операции add или addAll. Его Spliterator обычно обеспечивает более высокую последовательную производительность, но гораздо худшую параллельную производительность, чем у HashMap.
Определено в:
keySet в интерфейсе Map<K,V>
Переопределяет:
keySet в классе HashMap<K,V>
Возвращает:
вид множества ключей, содержащихся в этой карте

sequencedKeySet

public SequencedSet<K> sequencedKeySet()
Возвращает вид SequencedSet представления ключей этой карты keySet.

Возвращаемый вид имеет те же характеристики, что и указано для представления, возвращаемого методом keySet.

Определено в:
sequencedKeySet в интерфейсе SequencedMap<K,V>
Возвращает:
вид SequencedSet представления ключей этой карты keySet
С:
21

values

public Collection<V> values()
Возвращает представление Collection значений, содержащихся в этой карте. Порядок следования значений в представлении соответствует порядку следования записей в этой карте. Коллекция поддерживается картой, поэтому изменения в карте отражаются в коллекции, и наоборот. Если карта изменяется во время итерации по коллекции (кроме операций самого итератора remove), результаты итерации не определены. Коллекция поддерживает удаление элементов, что удаляет соответствующее отображение из карты, посредством операций Iterator.remove, Collection.remove, removeAll, retainAll и clear. Она не поддерживает операции add или addAll. Ее Spliterator обычно обеспечивает более высокую производительность при последовательной обработке, но значительно более низкую производительность при параллельной обработке, чем у HashMap.
Указано:
values в интерфейсе Map<K,V>
Переопределяет:
values в классе HashMap<K,V>
Возвращает:
представление значений, содержащихся в этой карте

sequencedValues

public SequencedCollection<V> sequencedValues()
Возвращает SequencedCollection представление коллекции values этой карты.

Возвращаемое представление обладает теми же характеристиками, что и указано для представления, возвращаемого методом values.

Указано:
sequencedValues в интерфейсе SequencedMap<K,V>
Возвращает:
SequencedCollection представление коллекции values этой карты
С:
21

entrySet

public Set<Map.Entry<K,V>> entrySet()
Возвращает Set представление отображений, содержащихся в этой карте. Порядок следования представления соответствует порядку следования записей в этой карте. Множество поддерживается картой, поэтому изменения в карте отражаются в множестве, и наоборот. Если карта изменяется во время итерации по множеству (кроме операций самого итератора remove, или операции setValue на элементе карты, возвращенном итератором), результаты итерации не определены. Множество поддерживает удаление элементов, что удаляет соответствующее отображение из карты, посредством операций Iterator.remove, Set.remove, removeAll, retainAll и clear. Оно не поддерживает операции add или addAll. Его Spliterator обычно обеспечивает более высокую производительность при последовательной обработке, но значительно более низкую производительность при параллельной обработке, чем у HashMap.
Указано:
entrySet в интерфейсе Map<K,V>
Переопределяет:
entrySet в классе HashMap<K,V>
Возвращает:
множество отображений, содержащихся в этой карте

sequencedEntrySet

public SequencedSet<Map.Entry<K,V>> sequencedEntrySet()
Возвращает SequencedSet представление множества отображений entrySet этой карты.

Возвращаемое представление обладает теми же характеристиками, что и указано для представления, возвращаемого методом entrySet.

Указано:
sequencedEntrySet в интерфейсе SequencedMap<K,V>
Возвращает:
SequencedSet представление множества отображений entrySet
С:
21

newLinkedHashMap

public static <K, V> LinkedHashMap<K,V> newLinkedHashMap(int numMappings)
Создает новую, пустую, упорядоченную по вставке LinkedHashMap, подходящую для ожидаемого количества отображений. Возвращаемая карта использует значение по умолчанию для коэффициента загрузки 0,75, и ее начальная емкость, как правило, достаточно велика, чтобы ожидаемое количество отображений можно было добавить без изменения размера карты.
Параметры типа:
K - тип ключей, поддерживаемых новой картой
V - тип сопоставленных значений
Параметры:
numMappings - ожидаемое количество отображений
Возвращает:
новую созданную карту
Исключения:
IllegalArgumentException - если numMappings отрицательно
С:
19

reversed

public SequencedMap<K,V> reversed()
Возвращает упорядоченное в обратном порядке представление этой карты. Порядок следования отображений в возвращаемом представлении является обратным порядку следования отображений в этой карте. Обратный порядок влияет на все операции, чувствительные к порядку, включая операции над коллекциями представлений возвращаемого представления. Если реализация допускает изменения в этом представлении, изменения "прописываются" в базовой карте. Изменения в базовой карте могут или не могут быть видны в этом обратном представлении, в зависимости от реализации.

Изменения в обратном представлении и его представлениях коллекций разрешены и будут распространяться на эту карту. Кроме того, изменения в этой карте будут видны в обратном представлении и его представлениях коллекций.

Указано:
reversed в интерфейсе SequencedMap<K,V>
Возвращает:
представление этой карты в обратном порядке
С:
21

© 1993, 2023, Oracle and/or its affiliates. All rights reserved.
Documentation extracted from Debian's OpenJDK Development Kit package.
Licensed under the GNU General Public License, version 2, with the Classpath Exception.
Various third party code in OpenJDK is licensed under different licenses (see Debian package).
Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.
https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/util/LinkedHashMap.html

Spec-Zone.ru

Настройки Оффлайн Что нового Помощь О нас
Spec-Zone .ru
спецификации, руководства, описания, API