From b22f9684326910c85512a3f8a828aeae342025c7 Mon Sep 17 00:00:00 2001 Subject: Add specialized hashmap version of the long type --- .../cpu/aarch64/vm_version_aarch64.hpp | 5 + src/hotspot/share/cds/filemap.cpp | 4 +- src/hotspot/share/cds/heapShared.hpp | 3 +- src/hotspot/share/cds/metaspaceShared.cpp | 7 +- src/hotspot/share/classfile/classLoader.cpp | 51 + src/hotspot/share/classfile/classLoader.hpp | 3 + .../classfile/systemDictionaryShared.cpp | 3 + src/hotspot/share/oops/symbol.hpp | 4 + src/hotspot/share/runtime/arguments.cpp | 7 + src/hotspot/share/runtime/globals.hpp | 6 + src/hotspot/share/runtime/java.cpp | 6 + src/hotspot/share/runtime/java.hpp | 2 + src/hotspot/share/runtime/vm_version.cpp | 8 + test/jdk/java/util/HashMap/HashMap.java | 3798 +++++++++++++++++ test/jdk/java/util/HashMap/LinkedHashMap.java | 798 ++++ 15 files changed, 4699 insertions(+), 6 deletions(-) create mode 100644 test/jdk/java/util/HashMap/HashMap.java create mode 100644 test/jdk/java/util/HashMap/LinkedHashMap.java diff --git a/src/hotspot/cpu/aarch64/vm_version_aarch64.hpp b/src/hotspot/cpu/aarch64/vm_version_aarch64.hpp index 46c77e48b..eac0db870 100644 --- a/src/hotspot/cpu/aarch64/vm_version_aarch64.hpp +++ b/src/hotspot/cpu/aarch64/vm_version_aarch64.hpp @@ -142,6 +142,11 @@ public: static int cpu_variant() { return _variant; } static int cpu_revision() { return _revision; } + static bool is_hisi_enabled() { + return (_cpu == CPU_HISILICON && + (_model == 0xd01 || _model == 0xd02 || _model == 0xd22 || _model == 0xd45)); + } + static bool model_is(int cpu_model) { return _model == cpu_model || _model2 == cpu_model; } diff --git a/src/hotspot/share/cds/filemap.cpp b/src/hotspot/share/cds/filemap.cpp index 76e078d12..13a9f22a9 100644 --- a/src/hotspot/share/cds/filemap.cpp +++ b/src/hotspot/share/cds/filemap.cpp @@ -1807,8 +1807,8 @@ MemRegion FileMapInfo::get_heap_regions_range_with_current_oop_encoding_mode() { // open archive objects. void FileMapInfo::map_heap_regions_impl() { if (!HeapShared::is_heap_object_archiving_allowed()) { - log_info(cds)("CDS heap data is being ignored. UseG1GC, " - "UseCompressedOops and UseCompressedClassPointers are required."); + log_info(cds)("CDS heap data is being ignored. UseG1GC, UseCompressedOops, " + "UseCompressedClassPointers and !UsePrimHashMap are required."); return; } diff --git a/src/hotspot/share/cds/heapShared.hpp b/src/hotspot/share/cds/heapShared.hpp index 74de74d6c..f7a1a004f 100644 --- a/src/hotspot/share/cds/heapShared.hpp +++ b/src/hotspot/share/cds/heapShared.hpp @@ -352,7 +352,8 @@ private: static void run_full_gc_in_vm_thread() NOT_CDS_JAVA_HEAP_RETURN; static bool is_heap_object_archiving_allowed() { - CDS_JAVA_HEAP_ONLY(return (UseG1GC && UseCompressedOops && UseCompressedClassPointers);) + CDS_JAVA_HEAP_ONLY(return (UseG1GC && UseCompressedOops && + UseCompressedClassPointers && !UsePrimHashMap);) NOT_CDS_JAVA_HEAP(return false;) } diff --git a/src/hotspot/share/cds/metaspaceShared.cpp b/src/hotspot/share/cds/metaspaceShared.cpp index f4c8d0f81..748166480 100644 --- a/src/hotspot/share/cds/metaspaceShared.cpp +++ b/src/hotspot/share/cds/metaspaceShared.cpp @@ -785,10 +785,11 @@ void VM_PopulateDumpSharedSpace::dump_java_heap_objects(GrowableArray* k if(!HeapShared::is_heap_object_archiving_allowed()) { log_info(cds)( "Archived java heap is not supported as UseG1GC, " - "UseCompressedOops and UseCompressedClassPointers are required." - "Current settings: UseG1GC=%s, UseCompressedOops=%s, UseCompressedClassPointers=%s.", + "UseCompressedOops, UseCompressedClassPointers and !UsePrimHashMap are required." + "Current settings: UseG1GC=%s, UseCompressedOops=%s, " + "UseCompressedClassPointers=%s, UsePrimHashMap=%s", BOOL_TO_STR(UseG1GC), BOOL_TO_STR(UseCompressedOops), - BOOL_TO_STR(UseCompressedClassPointers)); + BOOL_TO_STR(UseCompressedClassPointers), BOOL_TO_STR(UsePrimHashMap)); return; } // Find all the interned strings that should be dumped. diff --git a/src/hotspot/share/classfile/classLoader.cpp b/src/hotspot/share/classfile/classLoader.cpp index 6e9b9bcdf..6480cd6f6 100644 --- a/src/hotspot/share/classfile/classLoader.cpp +++ b/src/hotspot/share/classfile/classLoader.cpp @@ -142,6 +142,9 @@ ClassPathEntry* ClassLoader::_jrt_entry = NULL; ClassPathEntry* volatile ClassLoader::_first_append_entry_list = NULL; ClassPathEntry* volatile ClassLoader::_last_append_entry = NULL; + +ClassPathEntry* ClassLoader::_prim_collection_entry = NULL; + #if INCLUDE_CDS ClassPathEntry* ClassLoader::_app_classpath_entries = NULL; ClassPathEntry* ClassLoader::_last_app_classpath_entry = NULL; @@ -628,6 +631,36 @@ bool ClassLoader::is_in_patch_mod_entries(Symbol* module_name) { return false; } +// Set up the _prim_collection_entry if UsePrimHashMap +void ClassLoader::set_prim_collection_path(JavaThread *current) { + if (!UsePrimHashMap) { + return; + } + const char *prim_collection_jar = "primcollection.jar"; + char jvm_path[JVM_MAXPATHLEN]; + os::jvm_path(jvm_path, sizeof(jvm_path)); + const int trunc_times = 2; // set path/lib/server/libjvm.so to path/lib + for (int i = 0; i < trunc_times; ++i) { + char *end = strrchr(jvm_path, *os::file_separator()); + if (end != NULL) *end = '\0'; + } + + size_t jvm_path_len = strlen(jvm_path); + if (jvm_path_len < JVM_MAXPATHLEN - strlen(os::file_separator()) - strlen(prim_collection_jar)) { + jio_snprintf(jvm_path + jvm_path_len, + JVM_MAXPATHLEN - jvm_path_len, + "%s%s", os::file_separator(), prim_collection_jar); + } + char* error_msg = NULL; + jzfile* zip = open_zip_file(jvm_path, &error_msg, current); + if (zip != NULL && error_msg == NULL) { + _prim_collection_entry = new ClassPathZipEntry(zip, jvm_path, false, false); + log_info(class, load)("primcollection path: %s", jvm_path); + } else { + UsePrimHashMap = false; + } +} + // Set up the _jrt_entry if present and boot append path void ClassLoader::setup_bootstrap_search_path_impl(JavaThread* current, const char *class_path) { ResourceMark rm(current); @@ -677,6 +710,8 @@ void ClassLoader::setup_bootstrap_search_path_impl(JavaThread* current, const ch update_class_path_entry_list(current, path, false, true, false); } } + + set_prim_collection_path(current); } // During an exploded modules build, each module defined to the boot loader @@ -1183,6 +1218,22 @@ InstanceKlass* ClassLoader::load_class(Symbol* name, bool search_append_only, TR stream = search_module_entries(THREAD, _patch_mod_entries, class_name, file_name); } } + // Load Attempt: primcollection.jar for PrimHashMapRelatedClass + if (UsePrimHashMap && (NULL == stream) && name->is_primhashmap_related_class()) { + static bool is_first_loading = true; + static bool is_first_loading_succeeded = false; + stream = _prim_collection_entry->open_stream(THREAD, file_name); + if (!is_first_loading) { + // exit when some loads succeed while some fail + if ((is_first_loading_succeeded && stream == nullptr) || + (!is_first_loading_succeeded && stream != nullptr)) { + vm_exit_during_prim_collection_loading(); + } + } else { + is_first_loading = false; + is_first_loading_succeeded = (stream != nullptr); + } + } // Load Attempt #2: [jimage | exploded build] if (!search_append_only && (NULL == stream)) { diff --git a/src/hotspot/share/classfile/classLoader.hpp b/src/hotspot/share/classfile/classLoader.hpp index bac23a9dd..7c1c68317 100644 --- a/src/hotspot/share/classfile/classLoader.hpp +++ b/src/hotspot/share/classfile/classLoader.hpp @@ -216,6 +216,8 @@ class ClassLoader: AllStatic { // Last entry in linked list of appended ClassPathEntry instances static ClassPathEntry* volatile _last_append_entry; + static ClassPathEntry* _prim_collection_entry; + // Info used by CDS CDS_ONLY(static ClassPathEntry* _app_classpath_entries;) CDS_ONLY(static ClassPathEntry* _last_app_classpath_entry;) @@ -243,6 +245,7 @@ class ClassLoader: AllStatic { static void setup_bootstrap_search_path(JavaThread* current); static void setup_bootstrap_search_path_impl(JavaThread* current, const char *class_path); static void setup_patch_mod_entries(); + static void set_prim_collection_path(JavaThread *current); static void create_javabase(); static void* dll_lookup(void* lib, const char* name, const char* path); diff --git a/src/hotspot/share/classfile/systemDictionaryShared.cpp b/src/hotspot/share/classfile/systemDictionaryShared.cpp index c15e8f4df..8a6343fc3 100644 --- a/src/hotspot/share/classfile/systemDictionaryShared.cpp +++ b/src/hotspot/share/classfile/systemDictionaryShared.cpp @@ -2580,6 +2580,9 @@ SystemDictionaryShared::find_record(RunTimeSharedDictionary* static_dict, RunTim } InstanceKlass* SystemDictionaryShared::find_builtin_class(Symbol* name) { + if (UsePrimHashMap && name->is_primhashmap_related_class()) { + return NULL; + } const RunTimeSharedClassInfo* record = find_record(&_builtin_dictionary, &_dynamic_builtin_dictionary, name); if (record != NULL) { assert(!record->_klass->is_hidden(), "hidden class cannot be looked up by name"); diff --git a/src/hotspot/share/oops/symbol.hpp b/src/hotspot/share/oops/symbol.hpp index 96562d08a..003422ca1 100644 --- a/src/hotspot/share/oops/symbol.hpp +++ b/src/hotspot/share/oops/symbol.hpp @@ -194,6 +194,10 @@ class Symbol : public MetaspaceObj { } bool equals(const char* str) const { return equals(str, (int) strlen(str)); } + bool is_primhashmap_related_class() const { + return starts_with("java/util/HashMap") || starts_with("java/util/LinkedHashMap"); + } + // Tests if the symbol starts with the given prefix. bool starts_with(const char* prefix, int len) const { return contains_utf8_at(0, prefix, len); diff --git a/src/hotspot/share/runtime/arguments.cpp b/src/hotspot/share/runtime/arguments.cpp index f24cabb11..357ad4aca 100644 --- a/src/hotspot/share/runtime/arguments.cpp +++ b/src/hotspot/share/runtime/arguments.cpp @@ -2969,6 +2969,13 @@ jint Arguments::parse_each_vm_init_arg(const JavaVMInitArgs* args, bool* patch_m LogConfiguration::configure_stdout(LogLevel::Info, true, LOG_TAGS(class, path)); } + if (DumpSharedSpaces && UsePrimHashMap) { + warning("UsePrimHashMap is confilict with -Xshare:dump. ignoring UsePrimHashMap."); + if (FLAG_SET_CMDLINE(UsePrimHashMap, false) != JVMFlag::SUCCESS) { + return JNI_EINVAL; + } + } + fix_appclasspath(); return JNI_OK; diff --git a/src/hotspot/share/runtime/globals.hpp b/src/hotspot/share/runtime/globals.hpp index 680e78c04..4f02cb31a 100644 --- a/src/hotspot/share/runtime/globals.hpp +++ b/src/hotspot/share/runtime/globals.hpp @@ -2129,6 +2129,12 @@ const intx ObjectAlignmentInBytes = 8; JFR_ONLY(product(ccstr, StartFlightRecording, NULL, \ "Start flight recording with options")) \ \ + product(bool, UsePrimHashMap, false, EXPERIMENTAL, \ + "The Prim HashMap is a specialized version for long key. " \ + "Long-Key HashMap can benefit from this in most scenarios." \ + "Note: The debugging of HashMap.java is inaccurate" \ + " when UsePrimHashMap is enabled.") \ + \ product(bool, UseFastSerializer, false, EXPERIMENTAL, \ "Cache-based serialization.It is extremely fast, but it" \ "can only be effective in certain scenarios.") \ diff --git a/src/hotspot/share/runtime/java.cpp b/src/hotspot/share/runtime/java.cpp index a77f30b8c..ccfb0806d 100644 --- a/src/hotspot/share/runtime/java.cpp +++ b/src/hotspot/share/runtime/java.cpp @@ -690,6 +690,12 @@ void vm_exit_during_cds_dumping(const char* error, const char* message) { vm_abort(false); } +void vm_exit_during_prim_collection_loading() { + tty->print_cr("Error occurred during loading prim collection classes: must load all or none from primcollection.jar"); + // no need to dump core + vm_abort(false); +} + void vm_notify_during_shutdown(const char* error, const char* message) { if (error != NULL) { tty->print_cr("Error occurred during initialization of VM"); diff --git a/src/hotspot/share/runtime/java.hpp b/src/hotspot/share/runtime/java.hpp index ad179662f..e796fa84c 100644 --- a/src/hotspot/share/runtime/java.hpp +++ b/src/hotspot/share/runtime/java.hpp @@ -59,6 +59,8 @@ extern void vm_shutdown_during_initialization(const char* error, const char* mes extern void vm_exit_during_cds_dumping(const char* error, const char* message = NULL); +extern void vm_exit_during_prim_collection_loading(); + /** * With the integration of the changes to handle the version string * as defined by JEP-223, most of the code related to handle the version diff --git a/src/hotspot/share/runtime/vm_version.cpp b/src/hotspot/share/runtime/vm_version.cpp index 33a5c792c..1e6756aaa 100644 --- a/src/hotspot/share/runtime/vm_version.cpp +++ b/src/hotspot/share/runtime/vm_version.cpp @@ -31,6 +31,14 @@ void VM_Version_init() { VM_Version::initialize(); +#ifdef AARCH64 + if (!VM_Version::is_hisi_enabled()) { + UsePrimHashMap = false; + } +#else + UsePrimHashMap = false; +#endif + if (log_is_enabled(Info, os, cpu)) { char buf[1024]; ResourceMark rm; diff --git a/test/jdk/java/util/HashMap/HashMap.java b/test/jdk/java/util/HashMap/HashMap.java new file mode 100644 index 000000000..4880c2e8f --- /dev/null +++ b/test/jdk/java/util/HashMap/HashMap.java @@ -0,0 +1,3798 @@ +/* + * Copyright (c) 1997, 2021, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +package java.util; + +import java.io.IOException; +import java.io.InvalidObjectException; +import java.io.ObjectInputStream; +import java.io.Serializable; +import java.lang.reflect.ParameterizedType; +import java.lang.reflect.Type; +import java.util.function.BiConsumer; +import java.util.function.BiFunction; +import java.util.function.Consumer; +import java.util.function.Function; +import jdk.internal.access.SharedSecrets; + +/** + * Hash table based implementation of the {@code Map} interface. This + * implementation provides all of the optional map operations, and permits + * {@code null} values and the {@code null} key. (The {@code HashMap} + * class is roughly equivalent to {@code Hashtable}, except that it is + * unsynchronized and permits nulls.) This class makes no guarantees as to + * the order of the map; in particular, it does not guarantee that the order + * will remain constant over time. + * + *

This implementation provides constant-time performance for the basic + * operations ({@code get} and {@code put}), assuming the hash function + * disperses the elements properly among the buckets. Iteration over + * collection views requires time proportional to the "capacity" of the + * {@code HashMap} instance (the number of buckets) plus its size (the number + * of key-value mappings). Thus, it's very important not to set the initial + * capacity too high (or the load factor too low) if iteration performance is + * important. + * + *

An instance of {@code HashMap} has two parameters that affect its + * performance: initial capacity and load factor. The + * capacity is the number of buckets in the hash table, and the initial + * capacity is simply the capacity at the time the hash table is created. The + * load factor is a measure of how full the hash table is allowed to + * get before its capacity is automatically increased. When the number of + * entries in the hash table exceeds the product of the load factor and the + * current capacity, the hash table is rehashed (that is, internal data + * structures are rebuilt) so that the hash table has approximately twice the + * number of buckets. + * + *

As a general rule, the default load factor (.75) offers a good + * tradeoff between time and space costs. Higher values decrease the + * space overhead but increase the lookup cost (reflected in most of + * the operations of the {@code HashMap} class, including + * {@code get} and {@code put}). The expected number of entries in + * the map and its load factor should be taken into account when + * setting its initial capacity, so as to minimize the number of + * rehash operations. If the initial capacity is greater than the + * maximum number of entries divided by the load factor, no rehash + * operations will ever occur. + * + *

If many mappings are to be stored in a {@code HashMap} + * instance, creating it with a sufficiently large capacity will allow + * the mappings to be stored more efficiently than letting it perform + * automatic rehashing as needed to grow the table. Note that using + * many keys with the same {@code hashCode()} is a sure way to slow + * down performance of any hash table. To ameliorate impact, when keys + * are {@link Comparable}, this class may use comparison order among + * keys to help break ties. + * + *

Note that this implementation is not synchronized. + * If multiple threads access a hash map concurrently, and at least one of + * the threads modifies the map structurally, it must be + * synchronized externally. (A structural modification is any operation + * that adds or deletes one or more mappings; merely changing the value + * associated with a key that an instance already contains is not a + * structural modification.) This is typically accomplished by + * synchronizing on some object that naturally encapsulates the map. + * + * If no such object exists, the map should be "wrapped" using the + * {@link Collections#synchronizedMap Collections.synchronizedMap} + * method. This is best done at creation time, to prevent accidental + * unsynchronized access to the map:

+ *   Map m = Collections.synchronizedMap(new HashMap(...));
+ * + *

The iterators returned by all of this class's "collection view methods" + * are fail-fast: if the map is structurally modified at any time after + * the iterator is created, in any way except through the iterator's own + * {@code remove} method, the iterator will throw a + * {@link ConcurrentModificationException}. Thus, in the face of concurrent + * modification, the iterator fails quickly and cleanly, rather than risking + * arbitrary, non-deterministic behavior at an undetermined time in the + * future. + * + *

Note that the fail-fast behavior of an iterator cannot be guaranteed + * as it is, generally speaking, impossible to make any hard guarantees in the + * presence of unsynchronized concurrent modification. Fail-fast iterators + * throw {@code ConcurrentModificationException} on a best-effort basis. + * Therefore, it would be wrong to write a program that depended on this + * exception for its correctness: the fail-fast behavior of iterators + * should be used only to detect bugs. + * + *

This class is a member of the + * + * Java Collections Framework. + * + * @param the type of keys maintained by this map + * @param the type of mapped values + * + * @author Doug Lea + * @author Josh Bloch + * @author Arthur van Hoff + * @author Neal Gafter + * @see Object#hashCode() + * @see Collection + * @see Map + * @see TreeMap + * @see Hashtable + * @since 1.2 + */ +public class HashMap extends AbstractMap + implements Map, Cloneable, Serializable { + + @java.io.Serial + private static final long serialVersionUID = 362498820763181265L; + + /* + * Implementation notes. + * + * This map usually acts as a binned (bucketed) hash table, but + * when bins get too large, they are transformed into bins of + * TreeNodes, each structured similarly to those in + * java.util.TreeMap. Most methods try to use normal bins, but + * relay to TreeNode methods when applicable (simply by checking + * instanceof a node). Bins of TreeNodes may be traversed and + * used like any others, but additionally support faster lookup + * when overpopulated. However, since the vast majority of bins in + * normal use are not overpopulated, checking for existence of + * tree bins may be delayed in the course of table methods. + * + * Tree bins (i.e., bins whose elements are all TreeNodes) are + * ordered primarily by hashCode, but in the case of ties, if two + * elements are of the same "class C implements Comparable", + * type then their compareTo method is used for ordering. (We + * conservatively check generic types via reflection to validate + * this -- see method comparableClassFor). The added complexity + * of tree bins is worthwhile in providing worst-case O(log n) + * operations when keys either have distinct hashes or are + * orderable, Thus, performance degrades gracefully under + * accidental or malicious usages in which hashCode() methods + * return values that are poorly distributed, as well as those in + * which many keys share a hashCode, so long as they are also + * Comparable. (If neither of these apply, we may waste about a + * factor of two in time and space compared to taking no + * precautions. But the only known cases stem from poor user + * programming practices that are already so slow that this makes + * little difference.) + * + * Because TreeNodes are about twice the size of regular nodes, we + * use them only when bins contain enough nodes to warrant use + * (see TREEIFY_THRESHOLD). And when they become too small (due to + * removal or resizing) they are converted back to plain bins. In + * usages with well-distributed user hashCodes, tree bins are + * rarely used. Ideally, under random hashCodes, the frequency of + * nodes in bins follows a Poisson distribution + * (http://en.wikipedia.org/wiki/Poisson_distribution) with a + * parameter of about 0.5 on average for the default resizing + * threshold of 0.75, although with a large variance because of + * resizing granularity. Ignoring variance, the expected + * occurrences of list size k are (exp(-0.5) * pow(0.5, k) / + * factorial(k)). The first values are: + * + * 0: 0.60653066 + * 1: 0.30326533 + * 2: 0.07581633 + * 3: 0.01263606 + * 4: 0.00157952 + * 5: 0.00015795 + * 6: 0.00001316 + * 7: 0.00000094 + * 8: 0.00000006 + * more: less than 1 in ten million + * + * The root of a tree bin is normally its first node. However, + * sometimes (currently only upon Iterator.remove), the root might + * be elsewhere, but can be recovered following parent links + * (method TreeNode.root()). + * + * All applicable internal methods accept a hash code as an + * argument (as normally supplied from a public method), allowing + * them to call each other without recomputing user hashCodes. + * Most internal methods also accept a "tab" argument, that is + * normally the current table, but may be a new or old one when + * resizing or converting. + * + * When bin lists are treeified, split, or untreeified, we keep + * them in the same relative access/traversal order (i.e., field + * Node.next) to better preserve locality, and to slightly + * simplify handling of splits and traversals that invoke + * iterator.remove. When using comparators on insertion, to keep a + * total ordering (or as close as is required here) across + * rebalancings, we compare classes and identityHashCodes as + * tie-breakers. + * + * The use and transitions among plain vs tree modes is + * complicated by the existence of subclass LinkedHashMap. See + * below for hook methods defined to be invoked upon insertion, + * removal and access that allow LinkedHashMap internals to + * otherwise remain independent of these mechanics. (This also + * requires that a map instance be passed to some utility methods + * that may create new nodes.) + * + * The concurrent-programming-like SSA-based coding style helps + * avoid aliasing errors amid all of the twisty pointer operations. + */ + + /** + * The default initial capacity - MUST be a power of two. + */ + static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16 + + /** + * The maximum capacity, used if a higher value is implicitly specified + * by either of the constructors with arguments. + * MUST be a power of two <= 1<<30. + */ + static final int MAXIMUM_CAPACITY = 1 << 30; + + /** + * The load factor used when none specified in constructor. + */ + static final float DEFAULT_LOAD_FACTOR = 0.75f; + + /** + * The bin count threshold for using a tree rather than list for a + * bin. Bins are converted to trees when adding an element to a + * bin with at least this many nodes. The value must be greater + * than 2 and should be at least 8 to mesh with assumptions in + * tree removal about conversion back to plain bins upon + * shrinkage. + */ + static final int TREEIFY_THRESHOLD = 8; + + /** + * The bin count threshold for untreeifying a (split) bin during a + * resize operation. Should be less than TREEIFY_THRESHOLD, and at + * most 6 to mesh with shrinkage detection under removal. + */ + static final int UNTREEIFY_THRESHOLD = 6; + + /** + * The smallest table capacity for which bins may be treeified. + * (Otherwise the table is resized if too many nodes in a bin.) + * Should be at least 4 * TREEIFY_THRESHOLD to avoid conflicts + * between resizing and treeification thresholds. + */ + static final int MIN_TREEIFY_CAPACITY = 64; + + /** + * The max load factor used for prim long hashmap. The performance of + * prim long hashmap will decrease sharply when the value exceeds 0.8f. + */ + static final float MAX_LOAD_FACTOR_FOR_PRIM_MAP = 0.8f; + + static final int NULL_KEY_INDEX_FOR_RPIM_MAP = -1; + static final int KEY_NO_EXIST_FOR_PRIM_MAP = -2; + + /** + * Basic hash bin node, used for most entries. (See below for + * TreeNode subclass, and in LinkedHashMap for its Entry subclass.) + */ + static class Node implements Map.Entry { + final int hash; + final K key; + V value; + Node next; + + Node(int hash, K key, V value, Node next) { + this.hash = hash; + this.key = key; + this.value = value; + this.next = next; + } + + public final K getKey() { return key; } + public final V getValue() { return value; } + public final String toString() { return key + "=" + value; } + + public final int hashCode() { + return Objects.hashCode(key) ^ Objects.hashCode(value); + } + + public final V setValue(V newValue) { + V oldValue = value; + value = newValue; + return oldValue; + } + + public final boolean equals(Object o) { + if (o == this) + return true; + + return o instanceof Map.Entry e + && Objects.equals(key, e.getKey()) + && Objects.equals(value, e.getValue()); + } + } + + /* ---------------- Static utilities -------------- */ + + /** + * Computes key.hashCode() and spreads (XORs) higher bits of hash + * to lower. Because the table uses power-of-two masking, sets of + * hashes that vary only in bits above the current mask will + * always collide. (Among known examples are sets of Float keys + * holding consecutive whole numbers in small tables.) So we + * apply a transform that spreads the impact of higher bits + * downward. There is a tradeoff between speed, utility, and + * quality of bit-spreading. Because many common sets of hashes + * are already reasonably distributed (so don't benefit from + * spreading), and because we use trees to handle large sets of + * collisions in bins, we just XOR some shifted bits in the + * cheapest possible way to reduce systematic lossage, as well as + * to incorporate impact of the highest bits that would otherwise + * never be used in index calculations because of table bounds. + */ + static final int hash(Object key) { + int h; + return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); + } + + /** + * Returns x's Class if it is of the form "class C implements + * Comparable", else null. + */ + static Class comparableClassFor(Object x) { + if (x instanceof Comparable) { + Class c; Type[] ts, as; ParameterizedType p; + if ((c = x.getClass()) == String.class) // bypass checks + return c; + if ((ts = c.getGenericInterfaces()) != null) { + for (Type t : ts) { + if ((t instanceof ParameterizedType) && + ((p = (ParameterizedType) t).getRawType() == + Comparable.class) && + (as = p.getActualTypeArguments()) != null && + as.length == 1 && as[0] == c) // type arg is c + return c; + } + } + } + return null; + } + + /** + * Returns k.compareTo(x) if x matches kc (k's screened comparable + * class), else 0. + */ + @SuppressWarnings({"rawtypes","unchecked"}) // for cast to Comparable + static int compareComparables(Class kc, Object k, Object x) { + return (x == null || x.getClass() != kc ? 0 : + ((Comparable)k).compareTo(x)); + } + + /** + * Returns a power of two size for the given target capacity. + */ + static final int tableSizeFor(int cap) { + int n = -1 >>> Integer.numberOfLeadingZeros(cap - 1); + return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1; + } + + /* ---------------- Fields -------------- */ + + /** + * The table, initialized on first use, and resized as + * necessary. When allocated, length is always a power of two. + * (We also tolerate length zero in some operations to allow + * bootstrapping mechanics that are currently not needed.) + */ + transient Node[] table; + + /** + * Holds cached entrySet(). Note that AbstractMap fields are used + * for keySet() and values(). + */ + transient Set> entrySet; + + /** + * The number of key-value mappings contained in this map. + */ + transient int size; + + /** + * The number of times this HashMap has been structurally modified + * Structural modifications are those that change the number of mappings in + * the HashMap or otherwise modify its internal structure (e.g., + * rehash). This field is used to make iterators on Collection-views of + * the HashMap fail-fast. (See ConcurrentModificationException). + */ + transient int modCount; + + /** + * The next size value at which to resize (capacity * load factor). + * + * @serial + */ + // (The javadoc description is true upon serialization. + // Additionally, if the table array has not been allocated, this + // field holds the initial array capacity, or zero signifying + // DEFAULT_INITIAL_CAPACITY.) + int threshold; + + /** + * The load factor for the hash table. + * + * @serial + */ + final float loadFactor; + + /** + * The keys in prim long hashmap. + */ + transient Long[] primMapKeys; + + /** + * The values in prim long hashmap. + */ + transient V[] primMapValues; + + /** + * Indicates whether the element is valid in prim long hashmap. + */ + transient boolean[] primMapValids; + + /** + * The value of null key in prim long hashmap. + */ + transient V primMapValOfNullKey; + + /** + * Indicates whether null key exist in prim long hashmap. + */ + transient boolean primMapNullKeyValid; + + /** + * Indicates whether the current state is in prim long map. + */ + transient boolean usingPrimHashMap; + + /* ---------------- Public operations -------------- */ + + /** + * Constructs an empty {@code HashMap} with the specified initial + * capacity and load factor. + * + * @param initialCapacity the initial capacity + * @param loadFactor the load factor + * @throws IllegalArgumentException if the initial capacity is negative + * or the load factor is nonpositive + */ + public HashMap(int initialCapacity, float loadFactor) { + if (initialCapacity < 0) + throw new IllegalArgumentException("Illegal initial capacity: " + + initialCapacity); + if (initialCapacity > MAXIMUM_CAPACITY) + initialCapacity = MAXIMUM_CAPACITY; + if (loadFactor <= 0 || Float.isNaN(loadFactor)) + throw new IllegalArgumentException("Illegal load factor: " + + loadFactor); + this.loadFactor = loadFactor; + this.threshold = tableSizeFor(initialCapacity); + if (this.loadFactor > MAX_LOAD_FACTOR_FOR_PRIM_MAP) { + disablePrimHashMap(); + } else { + initUsingPrimHashMap(); + } + } + + /** + * Constructs an empty {@code HashMap} with the specified initial + * capacity and the default load factor (0.75). + * + * @param initialCapacity the initial capacity. + * @throws IllegalArgumentException if the initial capacity is negative. + */ + public HashMap(int initialCapacity) { + this(initialCapacity, DEFAULT_LOAD_FACTOR); + } + + /** + * Constructs an empty {@code HashMap} with the default initial capacity + * (16) and the default load factor (0.75). + */ + public HashMap() { + initUsingPrimHashMap(); + this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted + } + + /** + * Constructs a new {@code HashMap} with the same mappings as the + * specified {@code Map}. The {@code HashMap} is created with + * default load factor (0.75) and an initial capacity sufficient to + * hold the mappings in the specified {@code Map}. + * + * @param m the map whose mappings are to be placed in this map + * @throws NullPointerException if the specified map is null + */ + public HashMap(Map m) { + initUsingPrimHashMap(); + this.loadFactor = DEFAULT_LOAD_FACTOR; + putMapEntries(m, false); + } + + /** + * Implements Map.putAll and Map constructor. + * + * @param m the map + * @param evict false when initially constructing this map, else + * true (relayed to method afterNodeInsertion). + */ + final void putMapEntries(Map m, boolean evict) { + int s = m.size(); + if (s > 0) { + if ((!usePrimHashMap() && table == null) || + (usePrimHashMap() && primMapValids == null)) { // pre-size + float ft = ((float)s / loadFactor) + 1.0F; + int t = ((ft < (float)MAXIMUM_CAPACITY) ? + (int)ft : MAXIMUM_CAPACITY); + if (t > threshold) + threshold = tableSizeFor(t); + } else { + if (!usePrimHashMap()) { + // Because of linked-list bucket constraints, we cannot + // expand all at once, but can reduce total resize + // effort by repeated doubling now vs later + while (s > threshold && table.length < MAXIMUM_CAPACITY) + resize(); + } else { + while (s > threshold && primMapValids.length < MAXIMUM_CAPACITY) + primHashMapResize(); + } + } + + for (Map.Entry e : m.entrySet()) { + K key = e.getKey(); + V value = e.getValue(); + if (!usePrimHashMap(key)) { + putVal(key, value, false, evict, true); + } else { + primHashMapPutVal((Long)key, value, false); + } + } + } + } + + /** + * Returns the number of key-value mappings in this map. + * + * @return the number of key-value mappings in this map + */ + public int size() { + return size; + } + + /** + * Returns {@code true} if this map contains no key-value mappings. + * + * @return {@code true} if this map contains no key-value mappings + */ + public boolean isEmpty() { + return size == 0; + } + + /** + * Returns the value to which the specified key is mapped, + * or {@code null} if this map contains no mapping for the key. + * + *

More formally, if this map contains a mapping from a key + * {@code k} to a value {@code v} such that {@code (key==null ? k==null : + * key.equals(k))}, then this method returns {@code v}; otherwise + * it returns {@code null}. (There can be at most one such mapping.) + * + *

A return value of {@code null} does not necessarily + * indicate that the map contains no mapping for the key; it's also + * possible that the map explicitly maps the key to {@code null}. + * The {@link #containsKey containsKey} operation may be used to + * distinguish these two cases. + * + * @see #put(Object, Object) + */ + public V get(Object key) { + if (usePrimHashMap()) { + return primHashMapGet(key); + } + Node e; + return (e = getNode(key)) == null ? null : e.value; + } + + /** + * Implements Map.get and related methods. + * + * @param key the key + * @return the node, or null if none + */ + final Node getNode(Object key) { + Node[] tab; Node first, e; int n, hash; K k; + if ((tab = table) != null && (n = tab.length) > 0 && + (first = tab[(n - 1) & (hash = hash(key))]) != null) { + if (first.hash == hash && // always check first node + ((k = first.key) == key || (key != null && key.equals(k)))) + return first; + if ((e = first.next) != null) { + if (first instanceof TreeNode) + return ((TreeNode)first).getTreeNode(hash, key); + do { + if (e.hash == hash && + ((k = e.key) == key || (key != null && key.equals(k)))) + return e; + } while ((e = e.next) != null); + } + } + return null; + } + + /** + * Returns {@code true} if this map contains a mapping for the + * specified key. + * + * @param key The key whose presence in this map is to be tested + * @return {@code true} if this map contains a mapping for the specified + * key. + */ + public boolean containsKey(Object key) { + if (usePrimHashMap()) { + return (primHashGetIndexByKey(key) != KEY_NO_EXIST_FOR_PRIM_MAP); + } + return getNode(key) != null; + } + + /** + * Associates the specified value with the specified key in this map. + * If the map previously contained a mapping for the key, the old + * value is replaced. + * + * @param key key with which the specified value is to be associated + * @param value value to be associated with the specified key + * @return the previous value associated with {@code key}, or + * {@code null} if there was no mapping for {@code key}. + * (A {@code null} return can also indicate that the map + * previously associated {@code null} with {@code key}.) + */ + public V put(K key, V value) { + if (usePrimHashMap(key)) { + return primHashMapPutVal((Long)key, value, false); + } + return putVal(key, value, false, true, true); + } + + /** + * Implements Map.put and related methods. + * + * @param key the key + * @param value the value to put + * @param onlyIfAbsent if true, don't change existing value + * @param evict if false, the table is in creation mode. + * @param update if false(in rollback state), don't update size and modcount + * @return previous value, or null if none + */ + final V putVal(K key, V value, boolean onlyIfAbsent, + boolean evict, boolean update) { + int hash = hash(key); + Node[] tab; Node p; int n, i; + if ((tab = table) == null || (n = tab.length) == 0) + n = (tab = resize()).length; + if ((p = tab[i = (n - 1) & hash]) == null) + tab[i] = newNode(hash, key, value, null); + else { + Node e; K k; + if (p.hash == hash && + ((k = p.key) == key || (key != null && key.equals(k)))) + e = p; + else if (p instanceof TreeNode) + e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value); + else { + for (int binCount = 0; ; ++binCount) { + if ((e = p.next) == null) { + p.next = newNode(hash, key, value, null); + if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st + treeifyBin(tab, hash); + break; + } + if (e.hash == hash && + ((k = e.key) == key || (key != null && key.equals(k)))) + break; + p = e; + } + } + if (e != null) { // existing mapping for key + V oldValue = e.value; + if (!onlyIfAbsent || oldValue == null) + e.value = value; + afterNodeAccess(e); + return oldValue; + } + } + if (update) { + ++modCount; + if (++size > threshold) + resize(); + } + afterNodeInsertion(evict); + return null; + } + + /** + * Calculate the new capacity based on the old capacity. + * If the old value is 0, the new capacity is set to the + * initial capacity saved in the threshold field. + * Otherwise, set the new capacity to double the old capacity. + * This method update threshold at the same time. + * + * @return the new capacity. 0 if oldCap reaches the max capacity. + */ + private int calNewCapAndUpdateThreshold(int oldCap) { + int oldThr = threshold; + int newCap, newThr = 0; + if (oldCap > 0) { + if (oldCap >= MAXIMUM_CAPACITY) { + threshold = Integer.MAX_VALUE; + return 0; + } + else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && + oldCap >= DEFAULT_INITIAL_CAPACITY) + newThr = oldThr << 1; // double threshold + } + else if (oldThr > 0) // initial capacity was placed in threshold + newCap = oldThr; + else { // zero initial threshold signifies using defaults + newCap = DEFAULT_INITIAL_CAPACITY; + newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); + } + if (newThr == 0) { + float ft = (float)newCap * loadFactor; + newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? + (int)ft : Integer.MAX_VALUE); + } + threshold = newThr; + return newCap; + } + + /** + * Initializes or doubles table size. If null, allocates in + * accord with initial capacity target held in field threshold. + * Otherwise, because we are using power-of-two expansion, the + * elements from each bin must either stay at same index, or move + * with a power of two offset in the new table. + * + * @return the table + */ + final Node[] resize() { + Node[] oldTab = table; + final int oldCap = (oldTab == null) ? 0 : oldTab.length; + int newCap = calNewCapAndUpdateThreshold(oldCap); + // 0 means oldCap reaches the MAXIMUM_CAPACITY + if (newCap == 0) { + return oldTab; + } + @SuppressWarnings({"rawtypes","unchecked"}) + Node[] newTab = (Node[])new Node[newCap]; + table = newTab; + if (oldTab != null) { + for (int j = 0; j < oldCap; ++j) { + Node e; + if ((e = oldTab[j]) != null) { + oldTab[j] = null; + if (e.next == null) + newTab[e.hash & (newCap - 1)] = e; + else if (e instanceof TreeNode) + ((TreeNode)e).split(this, newTab, j, oldCap); + else { // preserve order + Node loHead = null, loTail = null; + Node hiHead = null, hiTail = null; + Node next; + do { + next = e.next; + if ((e.hash & oldCap) == 0) { + if (loTail == null) + loHead = e; + else + loTail.next = e; + loTail = e; + } + else { + if (hiTail == null) + hiHead = e; + else + hiTail.next = e; + hiTail = e; + } + } while ((e = next) != null); + if (loTail != null) { + loTail.next = null; + newTab[j] = loHead; + } + if (hiTail != null) { + hiTail.next = null; + newTab[j + oldCap] = hiHead; + } + } + } + } + } + return newTab; + } + + /** + * Replaces all linked nodes in bin at index for given hash unless + * table is too small, in which case resizes instead. + */ + final void treeifyBin(Node[] tab, int hash) { + int n, index; Node e; + if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY) + resize(); + else if ((e = tab[index = (n - 1) & hash]) != null) { + TreeNode hd = null, tl = null; + do { + TreeNode p = replacementTreeNode(e, null); + if (tl == null) + hd = p; + else { + p.prev = tl; + tl.next = p; + } + tl = p; + } while ((e = e.next) != null); + if ((tab[index] = hd) != null) + hd.treeify(tab); + } + } + + /** + * Copies all of the mappings from the specified map to this map. + * These mappings will replace any mappings that this map had for + * any of the keys currently in the specified map. + * + * @param m mappings to be stored in this map + * @throws NullPointerException if the specified map is null + */ + public void putAll(Map m) { + putMapEntries(m, true); + } + + /** + * Removes the mapping for the specified key from this map if present. + * + * @param key key whose mapping is to be removed from the map + * @return the previous value associated with {@code key}, or + * {@code null} if there was no mapping for {@code key}. + * (A {@code null} return can also indicate that the map + * previously associated {@code null} with {@code key}.) + */ + public V remove(Object key) { + if (usePrimHashMap(key)) { + return primHashMapRemoveByKey(key); + } + Node e; + return (e = removeNode(hash(key), key, null, false, true)) == null ? + null : e.value; + } + + /** + * Implements Map.remove and related methods. + * + * @param hash hash for key + * @param key the key + * @param value the value to match if matchValue, else ignored + * @param matchValue if true only remove if value is equal + * @param movable if false do not move other nodes while removing + * @return the node, or null if none + */ + final Node removeNode(int hash, Object key, Object value, + boolean matchValue, boolean movable) { + Node[] tab; Node p; int n, index; + if ((tab = table) != null && (n = tab.length) > 0 && + (p = tab[index = (n - 1) & hash]) != null) { + Node node = null, e; K k; V v; + if (p.hash == hash && + ((k = p.key) == key || (key != null && key.equals(k)))) + node = p; + else if ((e = p.next) != null) { + if (p instanceof TreeNode) + node = ((TreeNode)p).getTreeNode(hash, key); + else { + do { + if (e.hash == hash && + ((k = e.key) == key || + (key != null && key.equals(k)))) { + node = e; + break; + } + p = e; + } while ((e = e.next) != null); + } + } + if (node != null && (!matchValue || (v = node.value) == value || + (value != null && value.equals(v)))) { + if (node instanceof TreeNode) + ((TreeNode)node).removeTreeNode(this, tab, movable); + else if (node == p) + tab[index] = node.next; + else + p.next = node.next; + ++modCount; + --size; + afterNodeRemoval(node); + return node; + } + } + return null; + } + + /** + * Removes all of the mappings from this map. + * The map will be empty after this call returns. + */ + public void clear() { + modCount++; + if (usePrimHashMap()) { + if (size > 0) { + size = 0; + if (primMapValids != null && primMapValids.length != 0) { + Arrays.fill(primMapValids, false); + Arrays.fill(primMapValues, null); + } + primMapNullKeyValid = false; + primMapValOfNullKey = null; + } + } else { + Node[] tab; + if ((tab = table) != null && size > 0) { + size = 0; + for (int i = 0; i < tab.length; ++i) + tab[i] = null; + } + } + } + + /** + * Returns {@code true} if this map maps one or more keys to the + * specified value. + * + * @param value value whose presence in this map is to be tested + * @return {@code true} if this map maps one or more keys to the + * specified value + */ + public boolean containsValue(Object value) { + if (usePrimHashMap()) { + return primHashMapContainsValue(value); + } + Node[] tab; V v; + if ((tab = table) != null && size > 0) { + for (Node e : tab) { + for (; e != null; e = e.next) { + if ((v = e.value) == value || + (value != null && value.equals(v))) + return true; + } + } + } + return false; + } + + /** + * Returns a {@link Set} view of the keys contained in this map. + * The set is backed by the map, so changes to the map are + * reflected in the set, and vice-versa. If the map is modified + * while an iteration over the set is in progress (except through + * the iterator's own {@code remove} operation), the results of + * the iteration are undefined. The set supports element removal, + * which removes the corresponding mapping from the map, via the + * {@code Iterator.remove}, {@code Set.remove}, + * {@code removeAll}, {@code retainAll}, and {@code clear} + * operations. It does not support the {@code add} or {@code addAll} + * operations. + * + * @return a set view of the keys contained in this map + */ + public Set keySet() { + Set ks = keySet; + if (ks == null) { + ks = new KeySet(); + keySet = ks; + } + return ks; + } + + /** + * Prepares the array for {@link Collection#toArray(Object[])} implementation. + * If supplied array is smaller than this map size, a new array is allocated. + * If supplied array is bigger than this map size, a null is written at size index. + * + * @param a an original array passed to {@code toArray()} method + * @param type of array elements + * @return an array ready to be filled and returned from {@code toArray()} method. + */ + @SuppressWarnings("unchecked") + final T[] prepareArray(T[] a) { + int size = this.size; + if (a.length < size) { + return (T[]) java.lang.reflect.Array + .newInstance(a.getClass().getComponentType(), size); + } + if (a.length > size) { + a[size] = null; + } + return a; + } + + /** + * Fills an array with this map keys and returns it. This method assumes + * that input array is big enough to fit all the keys. Use + * {@link #prepareArray(Object[])} to ensure this. + * + * @param a an array to fill + * @param type of array elements + * @return supplied array + */ + T[] keysToArray(T[] a) { + Object[] r = a; + int idx = 0; + if (usePrimHashMap()) { + int remaining = size; + if (primMapNullKeyValid) { + r[idx++] = null; + --remaining; + } + if (remaining > 0) { + boolean[] valids = primMapValids; + Long[] keys = primMapKeys; + int length = valids.length; + for (int i = 0; remaining > 0 && i < length; ++i) { + if (valids[i]) { + r[idx++] = keys[i]; + --remaining; + } + } + } + } else { + Node[] tab; + if (size > 0 && (tab = table) != null) { + for (Node e : tab) { + for (; e != null; e = e.next) { + r[idx++] = e.key; + } + } + } + } + return a; + } + + /** + * Fills an array with this map values and returns it. This method assumes + * that input array is big enough to fit all the values. Use + * {@link #prepareArray(Object[])} to ensure this. + * + * @param a an array to fill + * @param type of array elements + * @return supplied array + */ + T[] valuesToArray(T[] a) { + Object[] r = a; + int idx = 0; + if (usePrimHashMap()) { + int remaining = size; + if (primMapNullKeyValid) { + r[idx++] = primMapValOfNullKey; + --remaining; + } + if (remaining > 0) { + boolean[] valids = primMapValids; + V[] values = primMapValues; + int length = valids.length; + for (int i = 0; remaining > 0 && i < length; ++i) { + if (valids[i]) { + r[idx++] = values[i]; + --remaining; + } + } + } + } else { + Node[] tab; + if (size > 0 && (tab = table) != null) { + for (Node e : tab) { + for (; e != null; e = e.next) { + r[idx++] = e.value; + } + } + } + } + return a; + } + + final class KeySet extends AbstractSet { + public final int size() { return size; } + public final void clear() { HashMap.this.clear(); } + public final Iterator iterator() { + if (usePrimHashMap()) { + return new primHashMapKeyIterator(); + } + return new KeyIterator(); + } + public final boolean contains(Object o) { return containsKey(o); } + public final boolean remove(Object key) { + if (usePrimHashMap(key)) { + int index = primHashGetIndexByKey(key); + if (index == KEY_NO_EXIST_FOR_PRIM_MAP) { + return false; + } + primHashMapRemoveByIndex(index); + return true; + } + return removeNode(hash(key), key, null, false, true) != null; + } + public final Spliterator spliterator() { + if (usePrimHashMap()) { + return new primHashMapKeySpliterator(0, -1, 0, 0, primMapNullKeyValid); + } + return new KeySpliterator<>(HashMap.this, 0, -1, 0, 0); + } + + public Object[] toArray() { + return keysToArray(new Object[size]); + } + + public T[] toArray(T[] a) { + return keysToArray(prepareArray(a)); + } + + public final void forEach(Consumer action) { + int mc = modCount; + if (action == null) + throw new NullPointerException(); + if (usePrimHashMap()) { + int remaining = size; + if (primMapNullKeyValid) { + action.accept(null); + --remaining; + } + if (remaining > 0) { + boolean[] valids = primMapValids; + Long[] keys = primMapKeys; + int length = valids.length; + for (int i = 0; remaining > 0 && i < length; ++i) { + if (valids[i]) { + action.accept(castKeyToGenericType(keys[i])); + --remaining; + } + } + } + } else { + Node[] tab; + if (size > 0 && (tab = table) != null) { + for (Node e : tab) { + for (; e != null; e = e.next) + action.accept(e.key); + } + } + } + if (modCount != mc) + throw new ConcurrentModificationException(); + } + } + + /** + * Returns a {@link Collection} view of the values contained in this map. + * The collection is backed by the map, so changes to the map are + * reflected in the collection, and vice-versa. If the map is + * modified while an iteration over the collection is in progress + * (except through the iterator's own {@code remove} operation), + * the results of the iteration are undefined. The collection + * supports element removal, which removes the corresponding + * mapping from the map, via the {@code Iterator.remove}, + * {@code Collection.remove}, {@code removeAll}, + * {@code retainAll} and {@code clear} operations. It does not + * support the {@code add} or {@code addAll} operations. + * + * @return a view of the values contained in this map + */ + public Collection values() { + Collection vs = values; + if (vs == null) { + vs = new Values(); + values = vs; + } + return vs; + } + + final class Values extends AbstractCollection { + public final int size() { return size; } + public final void clear() { HashMap.this.clear(); } + public final Iterator iterator() { + if (usePrimHashMap()) { + return new primHashMapValueIterator(); + } + return new ValueIterator(); + } + public final boolean contains(Object o) { return containsValue(o); } + public final Spliterator spliterator() { + if (usePrimHashMap()) { + return new primHashMapValueSpliterator(0, -1, 0, 0, primMapNullKeyValid); + } + return new ValueSpliterator<>(HashMap.this, 0, -1, 0, 0); + } + + public Object[] toArray() { + return valuesToArray(new Object[size]); + } + + public T[] toArray(T[] a) { + return valuesToArray(prepareArray(a)); + } + + public final void forEach(Consumer action) { + if (action == null) + throw new NullPointerException(); + int mc = modCount; + if (usePrimHashMap()) { + int remaining = size; + if (primMapNullKeyValid) { + action.accept(primMapValOfNullKey); + --remaining; + } + if (remaining > 0) { + boolean[] valids = primMapValids; + V[] values = primMapValues; + int length = valids.length; + for (int i = 0; remaining > 0 && i < length; ++i) { + if (valids[i]) { + action.accept(values[i]); + --remaining; + } + } + } + } else { + Node[] tab; + if (size > 0 && (tab = table) != null) { + for (Node e : tab) { + for (; e != null; e = e.next) + action.accept(e.value); + } + } + } + if (modCount != mc) + throw new ConcurrentModificationException(); + } + } + + /** + * Returns a {@link Set} view of the mappings contained in this map. + * The set is backed by the map, so changes to the map are + * reflected in the set, and vice-versa. If the map is modified + * while an iteration over the set is in progress (except through + * the iterator's own {@code remove} operation, or through the + * {@code setValue} operation on a map entry returned by the + * iterator) the results of the iteration are undefined. The set + * supports element removal, which removes the corresponding + * mapping from the map, via the {@code Iterator.remove}, + * {@code Set.remove}, {@code removeAll}, {@code retainAll} and + * {@code clear} operations. It does not support the + * {@code add} or {@code addAll} operations. + * + * @return a set view of the mappings contained in this map + */ + public Set> entrySet() { + Set> es; + return (es = entrySet) == null ? (entrySet = new EntrySet()) : es; + } + + final class EntrySet extends AbstractSet> { + public final int size() { return size; } + public final void clear() { HashMap.this.clear(); } + public final Iterator> iterator() { + if (usePrimHashMap()) { + return new primHashMapEntryIterator(); + } + return new EntryIterator(); + } + public final boolean contains(Object o) { + if (!(o instanceof Map.Entry e)) + return false; + Object key = e.getKey(); + if (usePrimHashMap()) { + int index = primHashGetIndexByKey(key); + if (index == KEY_NO_EXIST_FOR_PRIM_MAP) { + return false; + } + Object value = e.getValue(); + return (index == NULL_KEY_INDEX_FOR_RPIM_MAP) ? + Objects.equals(value, primMapValOfNullKey) : + Objects.equals(value, primMapValues[index]); + } else { + Node candidate = getNode(key); + return candidate != null && candidate.equals(e); + } + } + public final boolean remove(Object o) { + if (o instanceof Map.Entry e) { + Object key = e.getKey(); + Object value = e.getValue(); + return HashMap.this.remove(key, value); + } + return false; + } + public final Spliterator> spliterator() { + if (usePrimHashMap()) { + return new primHashMapEntrySpliterator(0, -1, 0, 0, primMapNullKeyValid); + } + return new EntrySpliterator<>(HashMap.this, 0, -1, 0, 0); + } + public final void forEach(Consumer> action) { + if (action == null) + throw new NullPointerException(); + if (usePrimHashMap()) { + Iterator> iter = iterator(); + int mc = modCount; + while (iter.hasNext()) { + Map.Entry e = iter.next(); + action.accept(e); + } + if (modCount != mc) + throw new ConcurrentModificationException(); + } + else { + Node[] tab; + if (size > 0 && (tab = table) != null) { + int mc = modCount; + for (Node e : tab) { + for (; e != null; e = e.next) + action.accept(e); + } + if (modCount != mc) + throw new ConcurrentModificationException(); + } + } + } + } + + // Overrides of JDK8 Map extension methods + + @Override + public V getOrDefault(Object key, V defaultValue) { + if (usePrimHashMap()) { + int index = primHashGetIndexByKey(key); + if (index == KEY_NO_EXIST_FOR_PRIM_MAP) { + return defaultValue; + } + return primHashMapGetValByIndex(index); + } + Node e; + return (e = getNode(key)) == null ? defaultValue : e.value; + } + + @Override + public V putIfAbsent(K key, V value) { + if (usePrimHashMap(key)) { + return primHashMapPutVal((Long)key, value, true); + } + return putVal(key, value, true, true, true); + } + + @Override + public boolean remove(Object key, Object value) { + if (usePrimHashMap(key)) { + int index = primHashGetIndexByKey(key); + if (index == KEY_NO_EXIST_FOR_PRIM_MAP) { + return false; + } + Object val = primHashMapGetValByIndex(index); + if (Objects.equals(value, val)) { + primHashMapRemoveByIndex(index); + return true; + } + return false; + } + return removeNode(hash(key), key, value, true, true) != null; + } + + @Override + public boolean replace(K key, V oldValue, V newValue) { + if (usePrimHashMap(key)) { + int index = primHashGetIndexByKey(key); + if (index == KEY_NO_EXIST_FOR_PRIM_MAP) { + return false; + } + if (index == NULL_KEY_INDEX_FOR_RPIM_MAP) { + if (Objects.equals(oldValue, primMapValOfNullKey)) { + primMapValOfNullKey = newValue; + return true; + } + } else { + if (Objects.equals(oldValue, primMapValues[index])) { + primMapValues[index] = newValue; + return true; + } + } + return false; + } + Node e; V v; + if ((e = getNode(key)) != null && + ((v = e.value) == oldValue || (v != null && v.equals(oldValue)))) { + e.value = newValue; + afterNodeAccess(e); + return true; + } + return false; + } + + @Override + public V replace(K key, V value) { + if (usePrimHashMap(key)) { + int index = primHashGetIndexByKey(key); + if (index == KEY_NO_EXIST_FOR_PRIM_MAP) { + return null; + } + V oldValue; + if (index == NULL_KEY_INDEX_FOR_RPIM_MAP) { + oldValue = primMapValOfNullKey; + primMapValOfNullKey = value; + } else { + oldValue = primMapValues[index]; + primMapValues[index] = value; + } + return oldValue; + } + Node e; + if ((e = getNode(key)) != null) { + V oldValue = e.value; + e.value = value; + afterNodeAccess(e); + return oldValue; + } + return null; + } + + /** + * {@inheritDoc} + * + *

This method will, on a best-effort basis, throw a + * {@link ConcurrentModificationException} if it is detected that the + * mapping function modifies this map during computation. + * + * @throws ConcurrentModificationException if it is detected that the + * mapping function modified this map + */ + @Override + public V computeIfAbsent(K key, + Function mappingFunction) { + if (mappingFunction == null) + throw new NullPointerException(); + if (usePrimHashMap(key)) { + return primHashMapComputeIfAbsent(key, mappingFunction); + } + int hash = hash(key); + Node[] tab; Node first; int n, i; + int binCount = 0; + TreeNode t = null; + Node old = null; + if (size > threshold || (tab = table) == null || + (n = tab.length) == 0) + n = (tab = resize()).length; + if ((first = tab[i = (n - 1) & hash]) != null) { + if (first instanceof TreeNode) + old = (t = (TreeNode)first).getTreeNode(hash, key); + else { + Node e = first; K k; + do { + if (e.hash == hash && + ((k = e.key) == key || (key != null && key.equals(k)))) { + old = e; + break; + } + ++binCount; + } while ((e = e.next) != null); + } + V oldValue; + if (old != null && (oldValue = old.value) != null) { + afterNodeAccess(old); + return oldValue; + } + } + int mc = modCount; + V v = mappingFunction.apply(key); + if (mc != modCount) { throw new ConcurrentModificationException(); } + if (v == null) { + return null; + } else if (old != null) { + old.value = v; + afterNodeAccess(old); + return v; + } + else if (t != null) + t.putTreeVal(this, tab, hash, key, v); + else { + tab[i] = newNode(hash, key, v, first); + if (binCount >= TREEIFY_THRESHOLD - 1) + treeifyBin(tab, hash); + } + modCount = mc + 1; + ++size; + afterNodeInsertion(true); + return v; + } + + /** + * {@inheritDoc} + * + *

This method will, on a best-effort basis, throw a + * {@link ConcurrentModificationException} if it is detected that the + * remapping function modifies this map during computation. + * + * @throws ConcurrentModificationException if it is detected that the + * remapping function modified this map + */ + @Override + public V computeIfPresent(K key, + BiFunction remappingFunction) { + if (remappingFunction == null) + throw new NullPointerException(); + if (usePrimHashMap(key)) { + return primHashMapComputeIfPresent(key, remappingFunction); + } + Node e; V oldValue; + if ((e = getNode(key)) != null && + (oldValue = e.value) != null) { + int mc = modCount; + V v = remappingFunction.apply(key, oldValue); + if (mc != modCount) { throw new ConcurrentModificationException(); } + if (v != null) { + e.value = v; + afterNodeAccess(e); + return v; + } + else { + int hash = hash(key); + removeNode(hash, key, null, false, true); + } + } + return null; + } + + /** + * {@inheritDoc} + * + *

This method will, on a best-effort basis, throw a + * {@link ConcurrentModificationException} if it is detected that the + * remapping function modifies this map during computation. + * + * @throws ConcurrentModificationException if it is detected that the + * remapping function modified this map + */ + @Override + public V compute(K key, + BiFunction remappingFunction) { + if (remappingFunction == null) + throw new NullPointerException(); + if (usePrimHashMap(key)) { + return primHashMapCompute(key, remappingFunction); + } + int hash = hash(key); + Node[] tab; Node first; int n, i; + int binCount = 0; + TreeNode t = null; + Node old = null; + if (size > threshold || (tab = table) == null || + (n = tab.length) == 0) + n = (tab = resize()).length; + if ((first = tab[i = (n - 1) & hash]) != null) { + if (first instanceof TreeNode) + old = (t = (TreeNode)first).getTreeNode(hash, key); + else { + Node e = first; K k; + do { + if (e.hash == hash && + ((k = e.key) == key || (key != null && key.equals(k)))) { + old = e; + break; + } + ++binCount; + } while ((e = e.next) != null); + } + } + V oldValue = (old == null) ? null : old.value; + int mc = modCount; + V v = remappingFunction.apply(key, oldValue); + if (mc != modCount) { throw new ConcurrentModificationException(); } + if (old != null) { + if (v != null) { + old.value = v; + afterNodeAccess(old); + } + else + removeNode(hash, key, null, false, true); + } + else if (v != null) { + if (t != null) + t.putTreeVal(this, tab, hash, key, v); + else { + tab[i] = newNode(hash, key, v, first); + if (binCount >= TREEIFY_THRESHOLD - 1) + treeifyBin(tab, hash); + } + modCount = mc + 1; + ++size; + afterNodeInsertion(true); + } + return v; + } + + /** + * {@inheritDoc} + * + *

This method will, on a best-effort basis, throw a + * {@link ConcurrentModificationException} if it is detected that the + * remapping function modifies this map during computation. + * + * @throws ConcurrentModificationException if it is detected that the + * remapping function modified this map + */ + @Override + public V merge(K key, V value, + BiFunction remappingFunction) { + if (value == null || remappingFunction == null) + throw new NullPointerException(); + if (usePrimHashMap(key)) { + return primHashMapMerge(key, value, remappingFunction); + } + int hash = hash(key); + Node[] tab; Node first; int n, i; + int binCount = 0; + TreeNode t = null; + Node old = null; + if (size > threshold || (tab = table) == null || + (n = tab.length) == 0) + n = (tab = resize()).length; + if ((first = tab[i = (n - 1) & hash]) != null) { + if (first instanceof TreeNode) + old = (t = (TreeNode)first).getTreeNode(hash, key); + else { + Node e = first; K k; + do { + if (e.hash == hash && + ((k = e.key) == key || (key != null && key.equals(k)))) { + old = e; + break; + } + ++binCount; + } while ((e = e.next) != null); + } + } + if (old != null) { + V v; + if (old.value != null) { + int mc = modCount; + v = remappingFunction.apply(old.value, value); + if (mc != modCount) { + throw new ConcurrentModificationException(); + } + } else { + v = value; + } + if (v != null) { + old.value = v; + afterNodeAccess(old); + } + else + removeNode(hash, key, null, false, true); + return v; + } else { + if (t != null) + t.putTreeVal(this, tab, hash, key, value); + else { + tab[i] = newNode(hash, key, value, first); + if (binCount >= TREEIFY_THRESHOLD - 1) + treeifyBin(tab, hash); + } + ++modCount; + ++size; + afterNodeInsertion(true); + return value; + } + } + + @Override + public void forEach(BiConsumer action) { + if (action == null) + throw new NullPointerException(); + int mc = modCount; + if (usePrimHashMap()) { + int remaining = size; + if (primMapNullKeyValid) { + action.accept(null, primMapValOfNullKey); + --remaining; + } + if (remaining > 0) { + boolean[] valids = primMapValids; + Long[] keys = primMapKeys; + V[] values = primMapValues; + int length = valids.length; + for (int i = 0; remaining > 0 && i < length; ++i) { + if (valids[i]) { + action.accept(castKeyToGenericType(keys[i]), values[i]); + --remaining; + } + } + } + if (remaining != 0) { + throw new ConcurrentModificationException(); + } + } else { + Node[] tab; + if (size > 0 && (tab = table) != null) { + for (Node e : tab) { + for (; e != null; e = e.next) + action.accept(e.key, e.value); + } + } + } + if (modCount != mc) + throw new ConcurrentModificationException(); + } + + @Override + public void replaceAll(BiFunction function) { + if (function == null) + throw new NullPointerException(); + if (usePrimHashMap()) { + int mc = modCount; + int remaining = size; + if (primMapNullKeyValid) { + primMapValOfNullKey = function.apply(null, primMapValOfNullKey); + --remaining; + } + if (remaining > 0) { + boolean[] valids = primMapValids; + Long[] keys = primMapKeys; + V[] values = primMapValues; + int length = valids.length; + for (int i = 0; remaining > 0 && i < length; ++i) { + if (valids[i]) { + values[i] = function.apply(castKeyToGenericType(keys[i]), values[i]); + --remaining; + } + } + } + if (remaining != 0) { + throw new ConcurrentModificationException(); + } + if (modCount != mc) + throw new ConcurrentModificationException(); + } else { + Node[] tab; + if (size > 0 && (tab = table) != null) { + int mc = modCount; + for (Node e : tab) { + for (; e != null; e = e.next) { + e.value = function.apply(e.key, e.value); + } + } + if (modCount != mc) + throw new ConcurrentModificationException(); + } + } + } + + /* ------------------------------------------------------------ */ + // Cloning and serialization + + /** + * Returns a shallow copy of this {@code HashMap} instance: the keys and + * values themselves are not cloned. + * + * @return a shallow copy of this map + */ + @SuppressWarnings("unchecked") + @Override + public Object clone() { + HashMap result; + try { + result = (HashMap)super.clone(); + } catch (CloneNotSupportedException e) { + // this shouldn't happen, since we are Cloneable + throw new InternalError(e); + } + result.reinitialize(); + result.putMapEntries(this, false); + return result; + } + + // These methods are also used when serializing HashSets + final float loadFactor() { return loadFactor; } + final int capacity() { + if (usePrimHashMap()) { + return (primMapValids != null) ? primMapValids.length : + (threshold > 0) ? threshold : + DEFAULT_INITIAL_CAPACITY; + } + return (table != null) ? table.length : + (threshold > 0) ? threshold : + DEFAULT_INITIAL_CAPACITY; + } + + /** + * Saves this map to a stream (that is, serializes it). + * + * @param s the stream + * @throws IOException if an I/O error occurs + * @serialData The capacity of the HashMap (the length of the + * bucket array) is emitted (int), followed by the + * size (an int, the number of key-value + * mappings), followed by the key (Object) and value (Object) + * for each key-value mapping. The key-value mappings are + * emitted in no particular order. + */ + @java.io.Serial + private void writeObject(java.io.ObjectOutputStream s) + throws IOException { + int buckets = capacity(); + // Write out the threshold, loadfactor, and any hidden stuff + s.defaultWriteObject(); + s.writeInt(buckets); + s.writeInt(size); + internalWriteEntries(s); + } + + /** + * Reconstitutes this map from a stream (that is, deserializes it). + * @param s the stream + * @throws ClassNotFoundException if the class of a serialized object + * could not be found + * @throws IOException if an I/O error occurs + */ + @java.io.Serial + private void readObject(ObjectInputStream s) + throws IOException, ClassNotFoundException { + + ObjectInputStream.GetField fields = s.readFields(); + + // Read loadFactor (ignore threshold) + float lf = fields.get("loadFactor", 0.75f); + if (lf <= 0 || Float.isNaN(lf)) + throw new InvalidObjectException("Illegal load factor: " + lf); + + lf = Math.min(Math.max(0.25f, lf), 4.0f); + HashMap.UnsafeHolder.putLoadFactor(this, lf); + + reinitialize(); + + s.readInt(); // Read and ignore number of buckets + int mappings = s.readInt(); // Read number of mappings (size) + if (mappings < 0) { + throw new InvalidObjectException("Illegal mappings count: " + mappings); + } else if (mappings == 0) { + // use defaults + } else if (mappings > 0) { + float fc = (float)mappings / lf + 1.0f; + int cap = ((fc < DEFAULT_INITIAL_CAPACITY) ? + DEFAULT_INITIAL_CAPACITY : + (fc >= MAXIMUM_CAPACITY) ? + MAXIMUM_CAPACITY : + tableSizeFor((int)fc)); + // null table will use threshold as initial size. + // set threshold to cap here to make sure that table.size is power of 2 + threshold = cap; + + // Check Map.Entry[].class since it's the nearest public type to + // what we're actually creating. + SharedSecrets.getJavaObjectInputStreamAccess().checkArray(s, Map.Entry[].class, cap); + + // Read the keys and values, and put the mappings in the HashMap + for (int i = 0; i < mappings; i++) { + @SuppressWarnings("unchecked") + K key = (K) s.readObject(); + @SuppressWarnings("unchecked") + V value = (V) s.readObject(); + if (usePrimHashMap(key)) { + primHashMapPutVal((Long)key, value,false); + } else { + putVal(key, value, false, false, true); + } + } + } + } + + // Support for resetting final field during deserializing + private static final class UnsafeHolder { + private UnsafeHolder() { throw new InternalError(); } + private static final jdk.internal.misc.Unsafe unsafe + = jdk.internal.misc.Unsafe.getUnsafe(); + private static final long LF_OFFSET + = unsafe.objectFieldOffset(HashMap.class, "loadFactor"); + static void putLoadFactor(HashMap map, float lf) { + unsafe.putFloat(map, LF_OFFSET, lf); + } + } + + /* ------------------------------------------------------------ */ + // iterators + + abstract class HashIterator { + Node next; // next entry to return + Node current; // current entry + int expectedModCount; // for fast-fail + int index; // current slot + + HashIterator() { + expectedModCount = modCount; + Node[] t = table; + current = next = null; + index = 0; + if (t != null && size > 0) { // advance to first entry + do {} while (index < t.length && (next = t[index++]) == null); + } + } + + public final boolean hasNext() { + return next != null; + } + + final Node nextNode() { + Node[] t; + Node e = next; + if (modCount != expectedModCount) + throw new ConcurrentModificationException(); + if (e == null) + throw new NoSuchElementException(); + if ((next = (current = e).next) == null && (t = table) != null) { + do {} while (index < t.length && (next = t[index++]) == null); + } + return e; + } + + public final void remove() { + Node p = current; + if (p == null) + throw new IllegalStateException(); + if (modCount != expectedModCount) + throw new ConcurrentModificationException(); + current = null; + removeNode(p.hash, p.key, null, false, false); + expectedModCount = modCount; + } + } + + final class KeyIterator extends HashIterator + implements Iterator { + public final K next() { return nextNode().key; } + } + + final class ValueIterator extends HashIterator + implements Iterator { + public final V next() { return nextNode().value; } + } + + final class EntryIterator extends HashIterator + implements Iterator> { + public final Map.Entry next() { return nextNode(); } + } + + /* ------------------------------------------------------------ */ + // spliterators + + static class HashMapSpliterator { + final HashMap map; + Node current; // current node + int index; // current index, modified on advance/split + int fence; // one past last index + int est; // size estimate + int expectedModCount; // for comodification checks + + HashMapSpliterator(HashMap m, int origin, + int fence, int est, + int expectedModCount) { + // rollback to genericMap if this static class is created directly + // e.g. HashSet.spliterator + m.rollbackToGenericMap(); + this.map = m; + this.index = origin; + this.fence = fence; + this.est = est; + this.expectedModCount = expectedModCount; + } + + final int getFence() { // initialize fence and size on first use + int hi; + if ((hi = fence) < 0) { + HashMap m = map; + est = m.size; + expectedModCount = m.modCount; + Node[] tab = m.table; + hi = fence = (tab == null) ? 0 : tab.length; + } + return hi; + } + + public final long estimateSize() { + getFence(); // force init + return (long) est; + } + } + + static final class KeySpliterator + extends HashMapSpliterator + implements Spliterator { + KeySpliterator(HashMap m, int origin, int fence, int est, + int expectedModCount) { + super(m, origin, fence, est, expectedModCount); + } + + public KeySpliterator trySplit() { + int hi = getFence(), lo = index, mid = (lo + hi) >>> 1; + return (lo >= mid || current != null) ? null : + new KeySpliterator<>(map, lo, index = mid, est >>>= 1, + expectedModCount); + } + + public void forEachRemaining(Consumer action) { + int i, hi, mc; + if (action == null) + throw new NullPointerException(); + HashMap m = map; + Node[] tab = m.table; + if ((hi = fence) < 0) { + mc = expectedModCount = m.modCount; + hi = fence = (tab == null) ? 0 : tab.length; + } + else + mc = expectedModCount; + if (tab != null && tab.length >= hi && + (i = index) >= 0 && (i < (index = hi) || current != null)) { + Node p = current; + current = null; + do { + if (p == null) + p = tab[i++]; + else { + action.accept(p.key); + p = p.next; + } + } while (p != null || i < hi); + if (m.modCount != mc) + throw new ConcurrentModificationException(); + } + } + + public boolean tryAdvance(Consumer action) { + int hi; + if (action == null) + throw new NullPointerException(); + Node[] tab = map.table; + if (tab != null && tab.length >= (hi = getFence()) && index >= 0) { + while (current != null || index < hi) { + if (current == null) + current = tab[index++]; + else { + K k = current.key; + current = current.next; + action.accept(k); + if (map.modCount != expectedModCount) + throw new ConcurrentModificationException(); + return true; + } + } + } + return false; + } + + public int characteristics() { + return (fence < 0 || est == map.size ? Spliterator.SIZED : 0) | + Spliterator.DISTINCT; + } + } + + static final class ValueSpliterator + extends HashMapSpliterator + implements Spliterator { + ValueSpliterator(HashMap m, int origin, int fence, int est, + int expectedModCount) { + super(m, origin, fence, est, expectedModCount); + } + + public ValueSpliterator trySplit() { + int hi = getFence(), lo = index, mid = (lo + hi) >>> 1; + return (lo >= mid || current != null) ? null : + new ValueSpliterator<>(map, lo, index = mid, est >>>= 1, + expectedModCount); + } + + public void forEachRemaining(Consumer action) { + int i, hi, mc; + if (action == null) + throw new NullPointerException(); + HashMap m = map; + Node[] tab = m.table; + if ((hi = fence) < 0) { + mc = expectedModCount = m.modCount; + hi = fence = (tab == null) ? 0 : tab.length; + } + else + mc = expectedModCount; + if (tab != null && tab.length >= hi && + (i = index) >= 0 && (i < (index = hi) || current != null)) { + Node p = current; + current = null; + do { + if (p == null) + p = tab[i++]; + else { + action.accept(p.value); + p = p.next; + } + } while (p != null || i < hi); + if (m.modCount != mc) + throw new ConcurrentModificationException(); + } + } + + public boolean tryAdvance(Consumer action) { + int hi; + if (action == null) + throw new NullPointerException(); + Node[] tab = map.table; + if (tab != null && tab.length >= (hi = getFence()) && index >= 0) { + while (current != null || index < hi) { + if (current == null) + current = tab[index++]; + else { + V v = current.value; + current = current.next; + action.accept(v); + if (map.modCount != expectedModCount) + throw new ConcurrentModificationException(); + return true; + } + } + } + return false; + } + + public int characteristics() { + return (fence < 0 || est == map.size ? Spliterator.SIZED : 0); + } + } + + static final class EntrySpliterator + extends HashMapSpliterator + implements Spliterator> { + EntrySpliterator(HashMap m, int origin, int fence, int est, + int expectedModCount) { + super(m, origin, fence, est, expectedModCount); + } + + public EntrySpliterator trySplit() { + int hi = getFence(), lo = index, mid = (lo + hi) >>> 1; + return (lo >= mid || current != null) ? null : + new EntrySpliterator<>(map, lo, index = mid, est >>>= 1, + expectedModCount); + } + + public void forEachRemaining(Consumer> action) { + int i, hi, mc; + if (action == null) + throw new NullPointerException(); + HashMap m = map; + Node[] tab = m.table; + if ((hi = fence) < 0) { + mc = expectedModCount = m.modCount; + hi = fence = (tab == null) ? 0 : tab.length; + } + else + mc = expectedModCount; + if (tab != null && tab.length >= hi && + (i = index) >= 0 && (i < (index = hi) || current != null)) { + Node p = current; + current = null; + do { + if (p == null) + p = tab[i++]; + else { + action.accept(p); + p = p.next; + } + } while (p != null || i < hi); + if (m.modCount != mc) + throw new ConcurrentModificationException(); + } + } + + public boolean tryAdvance(Consumer> action) { + int hi; + if (action == null) + throw new NullPointerException(); + Node[] tab = map.table; + if (tab != null && tab.length >= (hi = getFence()) && index >= 0) { + while (current != null || index < hi) { + if (current == null) + current = tab[index++]; + else { + Node e = current; + current = current.next; + action.accept(e); + if (map.modCount != expectedModCount) + throw new ConcurrentModificationException(); + return true; + } + } + } + return false; + } + + public int characteristics() { + return (fence < 0 || est == map.size ? Spliterator.SIZED : 0) | + Spliterator.DISTINCT; + } + } + + /* ------------------------------------------------------------ */ + // LinkedHashMap support + + + /* + * The following package-protected methods are designed to be + * overridden by LinkedHashMap, but not by any other subclass. + * Nearly all other internal methods are also package-protected + * but are declared final, so can be used by LinkedHashMap, view + * classes, and HashSet. + */ + + // Create a regular (non-tree) node + Node newNode(int hash, K key, V value, Node next) { + return new Node<>(hash, key, value, next); + } + + // For conversion from TreeNodes to plain nodes + Node replacementNode(Node p, Node next) { + return new Node<>(p.hash, p.key, p.value, next); + } + + // Create a tree bin node + TreeNode newTreeNode(int hash, K key, V value, Node next) { + return new TreeNode<>(hash, key, value, next); + } + + // For treeifyBin + TreeNode replacementTreeNode(Node p, Node next) { + return new TreeNode<>(p.hash, p.key, p.value, next); + } + + /** + * Reset to initial default state. Called by clone and readObject. + */ + void reinitialize() { + table = null; + entrySet = null; + keySet = null; + values = null; + modCount = 0; + threshold = 0; + size = 0; + primMapValids = null; + primMapKeys = null; + primMapValues = null; + primMapNullKeyValid = false; + primMapValOfNullKey = null; + // loadFactor should be le than 0.8f to make sure there is at least one empty slot for prim raw array + if (loadFactor > MAX_LOAD_FACTOR_FOR_PRIM_MAP) { + disablePrimHashMap(); + } else { + initUsingPrimHashMap(); + } + } + + // Callbacks to allow LinkedHashMap post-actions + void afterNodeAccess(Node p) { } + void afterNodeInsertion(boolean evict) { } + void afterNodeRemoval(Node p) { } + + // Called only from writeObject, to ensure compatible ordering. + void internalWriteEntries(java.io.ObjectOutputStream s) throws IOException { + int remaining = size; + if (usePrimHashMap()) { + if (primMapNullKeyValid) { + s.writeObject(null); + s.writeObject(primMapValOfNullKey); + --remaining; + } + if (remaining > 0) { + boolean[] valids = primMapValids; + Long[] keys = primMapKeys; + V[] values = primMapValues; + int length = valids.length; + for (int i = 0; remaining > 0 && i < length; ++i) { + if (valids[i]) { + s.writeObject(castKeyToGenericType(keys[i])); + s.writeObject(values[i]); + --remaining; + } + } + } + } else { + Node[] tab; + if (size > 0 && (tab = table) != null) { + for (Node e : tab) { + for (; e != null; e = e.next) { + s.writeObject(e.key); + s.writeObject(e.value); + --remaining; + } + } + } + } + + if (remaining != 0) { + throw new ConcurrentModificationException(); + } + } + + /* ------------------------------------------------------------ */ + // Tree bins + + /** + * Entry for Tree bins. Extends LinkedHashMap.Entry (which in turn + * extends Node) so can be used as extension of either regular or + * linked node. + */ + static final class TreeNode extends LinkedHashMap.Entry { + TreeNode parent; // red-black tree links + TreeNode left; + TreeNode right; + TreeNode prev; // needed to unlink next upon deletion + boolean red; + TreeNode(int hash, K key, V val, Node next) { + super(hash, key, val, next); + } + + /** + * Returns root of tree containing this node. + */ + final TreeNode root() { + for (TreeNode r = this, p;;) { + if ((p = r.parent) == null) + return r; + r = p; + } + } + + /** + * Ensures that the given root is the first node of its bin. + */ + static void moveRootToFront(Node[] tab, TreeNode root) { + int n; + if (root != null && tab != null && (n = tab.length) > 0) { + int index = (n - 1) & root.hash; + TreeNode first = (TreeNode)tab[index]; + if (root != first) { + Node rn; + tab[index] = root; + TreeNode rp = root.prev; + if ((rn = root.next) != null) + ((TreeNode)rn).prev = rp; + if (rp != null) + rp.next = rn; + if (first != null) + first.prev = root; + root.next = first; + root.prev = null; + } + assert checkInvariants(root); + } + } + + /** + * Finds the node starting at root p with the given hash and key. + * The kc argument caches comparableClassFor(key) upon first use + * comparing keys. + */ + final TreeNode find(int h, Object k, Class kc) { + TreeNode p = this; + do { + int ph, dir; K pk; + TreeNode pl = p.left, pr = p.right, q; + if ((ph = p.hash) > h) + p = pl; + else if (ph < h) + p = pr; + else if ((pk = p.key) == k || (k != null && k.equals(pk))) + return p; + else if (pl == null) + p = pr; + else if (pr == null) + p = pl; + else if ((kc != null || + (kc = comparableClassFor(k)) != null) && + (dir = compareComparables(kc, k, pk)) != 0) + p = (dir < 0) ? pl : pr; + else if ((q = pr.find(h, k, kc)) != null) + return q; + else + p = pl; + } while (p != null); + return null; + } + + /** + * Calls find for root node. + */ + final TreeNode getTreeNode(int h, Object k) { + return ((parent != null) ? root() : this).find(h, k, null); + } + + /** + * Tie-breaking utility for ordering insertions when equal + * hashCodes and non-comparable. We don't require a total + * order, just a consistent insertion rule to maintain + * equivalence across rebalancings. Tie-breaking further than + * necessary simplifies testing a bit. + */ + static int tieBreakOrder(Object a, Object b) { + int d; + if (a == null || b == null || + (d = a.getClass().getName(). + compareTo(b.getClass().getName())) == 0) + d = (System.identityHashCode(a) <= System.identityHashCode(b) ? + -1 : 1); + return d; + } + + /** + * Forms tree of the nodes linked from this node. + */ + final void treeify(Node[] tab) { + TreeNode root = null; + for (TreeNode x = this, next; x != null; x = next) { + next = (TreeNode)x.next; + x.left = x.right = null; + if (root == null) { + x.parent = null; + x.red = false; + root = x; + } + else { + K k = x.key; + int h = x.hash; + Class kc = null; + for (TreeNode p = root;;) { + int dir, ph; + K pk = p.key; + if ((ph = p.hash) > h) + dir = -1; + else if (ph < h) + dir = 1; + else if ((kc == null && + (kc = comparableClassFor(k)) == null) || + (dir = compareComparables(kc, k, pk)) == 0) + dir = tieBreakOrder(k, pk); + + TreeNode xp = p; + if ((p = (dir <= 0) ? p.left : p.right) == null) { + x.parent = xp; + if (dir <= 0) + xp.left = x; + else + xp.right = x; + root = balanceInsertion(root, x); + break; + } + } + } + } + moveRootToFront(tab, root); + } + + /** + * Returns a list of non-TreeNodes replacing those linked from + * this node. + */ + final Node untreeify(HashMap map) { + Node hd = null, tl = null; + for (Node q = this; q != null; q = q.next) { + Node p = map.replacementNode(q, null); + if (tl == null) + hd = p; + else + tl.next = p; + tl = p; + } + return hd; + } + + /** + * Tree version of putVal. + */ + final TreeNode putTreeVal(HashMap map, Node[] tab, + int h, K k, V v) { + Class kc = null; + boolean searched = false; + TreeNode root = (parent != null) ? root() : this; + for (TreeNode p = root;;) { + int dir, ph; K pk; + if ((ph = p.hash) > h) + dir = -1; + else if (ph < h) + dir = 1; + else if ((pk = p.key) == k || (k != null && k.equals(pk))) + return p; + else if ((kc == null && + (kc = comparableClassFor(k)) == null) || + (dir = compareComparables(kc, k, pk)) == 0) { + if (!searched) { + TreeNode q, ch; + searched = true; + if (((ch = p.left) != null && + (q = ch.find(h, k, kc)) != null) || + ((ch = p.right) != null && + (q = ch.find(h, k, kc)) != null)) + return q; + } + dir = tieBreakOrder(k, pk); + } + + TreeNode xp = p; + if ((p = (dir <= 0) ? p.left : p.right) == null) { + Node xpn = xp.next; + TreeNode x = map.newTreeNode(h, k, v, xpn); + if (dir <= 0) + xp.left = x; + else + xp.right = x; + xp.next = x; + x.parent = x.prev = xp; + if (xpn != null) + ((TreeNode)xpn).prev = x; + moveRootToFront(tab, balanceInsertion(root, x)); + return null; + } + } + } + + /** + * Removes the given node, that must be present before this call. + * This is messier than typical red-black deletion code because we + * cannot swap the contents of an interior node with a leaf + * successor that is pinned by "next" pointers that are accessible + * independently during traversal. So instead we swap the tree + * linkages. If the current tree appears to have too few nodes, + * the bin is converted back to a plain bin. (The test triggers + * somewhere between 2 and 6 nodes, depending on tree structure). + */ + final void removeTreeNode(HashMap map, Node[] tab, + boolean movable) { + int n; + if (tab == null || (n = tab.length) == 0) + return; + int index = (n - 1) & hash; + TreeNode first = (TreeNode)tab[index], root = first, rl; + TreeNode succ = (TreeNode)next, pred = prev; + if (pred == null) + tab[index] = first = succ; + else + pred.next = succ; + if (succ != null) + succ.prev = pred; + if (first == null) + return; + if (root.parent != null) + root = root.root(); + if (root == null + || (movable + && (root.right == null + || (rl = root.left) == null + || rl.left == null))) { + tab[index] = first.untreeify(map); // too small + return; + } + TreeNode p = this, pl = left, pr = right, replacement; + if (pl != null && pr != null) { + TreeNode s = pr, sl; + while ((sl = s.left) != null) // find successor + s = sl; + boolean c = s.red; s.red = p.red; p.red = c; // swap colors + TreeNode sr = s.right; + TreeNode pp = p.parent; + if (s == pr) { // p was s's direct parent + p.parent = s; + s.right = p; + } + else { + TreeNode sp = s.parent; + if ((p.parent = sp) != null) { + if (s == sp.left) + sp.left = p; + else + sp.right = p; + } + if ((s.right = pr) != null) + pr.parent = s; + } + p.left = null; + if ((p.right = sr) != null) + sr.parent = p; + if ((s.left = pl) != null) + pl.parent = s; + if ((s.parent = pp) == null) + root = s; + else if (p == pp.left) + pp.left = s; + else + pp.right = s; + if (sr != null) + replacement = sr; + else + replacement = p; + } + else if (pl != null) + replacement = pl; + else if (pr != null) + replacement = pr; + else + replacement = p; + if (replacement != p) { + TreeNode pp = replacement.parent = p.parent; + if (pp == null) + (root = replacement).red = false; + else if (p == pp.left) + pp.left = replacement; + else + pp.right = replacement; + p.left = p.right = p.parent = null; + } + + TreeNode r = p.red ? root : balanceDeletion(root, replacement); + + if (replacement == p) { // detach + TreeNode pp = p.parent; + p.parent = null; + if (pp != null) { + if (p == pp.left) + pp.left = null; + else if (p == pp.right) + pp.right = null; + } + } + if (movable) + moveRootToFront(tab, r); + } + + /** + * Splits nodes in a tree bin into lower and upper tree bins, + * or untreeifies if now too small. Called only from resize; + * see above discussion about split bits and indices. + * + * @param map the map + * @param tab the table for recording bin heads + * @param index the index of the table being split + * @param bit the bit of hash to split on + */ + final void split(HashMap map, Node[] tab, int index, int bit) { + TreeNode b = this; + // Relink into lo and hi lists, preserving order + TreeNode loHead = null, loTail = null; + TreeNode hiHead = null, hiTail = null; + int lc = 0, hc = 0; + for (TreeNode e = b, next; e != null; e = next) { + next = (TreeNode)e.next; + e.next = null; + if ((e.hash & bit) == 0) { + if ((e.prev = loTail) == null) + loHead = e; + else + loTail.next = e; + loTail = e; + ++lc; + } + else { + if ((e.prev = hiTail) == null) + hiHead = e; + else + hiTail.next = e; + hiTail = e; + ++hc; + } + } + + if (loHead != null) { + if (lc <= UNTREEIFY_THRESHOLD) + tab[index] = loHead.untreeify(map); + else { + tab[index] = loHead; + if (hiHead != null) // (else is already treeified) + loHead.treeify(tab); + } + } + if (hiHead != null) { + if (hc <= UNTREEIFY_THRESHOLD) + tab[index + bit] = hiHead.untreeify(map); + else { + tab[index + bit] = hiHead; + if (loHead != null) + hiHead.treeify(tab); + } + } + } + + /* ------------------------------------------------------------ */ + // Red-black tree methods, all adapted from CLR + + static TreeNode rotateLeft(TreeNode root, + TreeNode p) { + TreeNode r, pp, rl; + if (p != null && (r = p.right) != null) { + if ((rl = p.right = r.left) != null) + rl.parent = p; + if ((pp = r.parent = p.parent) == null) + (root = r).red = false; + else if (pp.left == p) + pp.left = r; + else + pp.right = r; + r.left = p; + p.parent = r; + } + return root; + } + + static TreeNode rotateRight(TreeNode root, + TreeNode p) { + TreeNode l, pp, lr; + if (p != null && (l = p.left) != null) { + if ((lr = p.left = l.right) != null) + lr.parent = p; + if ((pp = l.parent = p.parent) == null) + (root = l).red = false; + else if (pp.right == p) + pp.right = l; + else + pp.left = l; + l.right = p; + p.parent = l; + } + return root; + } + + static TreeNode balanceInsertion(TreeNode root, + TreeNode x) { + x.red = true; + for (TreeNode xp, xpp, xppl, xppr;;) { + if ((xp = x.parent) == null) { + x.red = false; + return x; + } + else if (!xp.red || (xpp = xp.parent) == null) + return root; + if (xp == (xppl = xpp.left)) { + if ((xppr = xpp.right) != null && xppr.red) { + xppr.red = false; + xp.red = false; + xpp.red = true; + x = xpp; + } + else { + if (x == xp.right) { + root = rotateLeft(root, x = xp); + xpp = (xp = x.parent) == null ? null : xp.parent; + } + if (xp != null) { + xp.red = false; + if (xpp != null) { + xpp.red = true; + root = rotateRight(root, xpp); + } + } + } + } + else { + if (xppl != null && xppl.red) { + xppl.red = false; + xp.red = false; + xpp.red = true; + x = xpp; + } + else { + if (x == xp.left) { + root = rotateRight(root, x = xp); + xpp = (xp = x.parent) == null ? null : xp.parent; + } + if (xp != null) { + xp.red = false; + if (xpp != null) { + xpp.red = true; + root = rotateLeft(root, xpp); + } + } + } + } + } + } + + static TreeNode balanceDeletion(TreeNode root, + TreeNode x) { + for (TreeNode xp, xpl, xpr;;) { + if (x == null || x == root) + return root; + else if ((xp = x.parent) == null) { + x.red = false; + return x; + } + else if (x.red) { + x.red = false; + return root; + } + else if ((xpl = xp.left) == x) { + if ((xpr = xp.right) != null && xpr.red) { + xpr.red = false; + xp.red = true; + root = rotateLeft(root, xp); + xpr = (xp = x.parent) == null ? null : xp.right; + } + if (xpr == null) + x = xp; + else { + TreeNode sl = xpr.left, sr = xpr.right; + if ((sr == null || !sr.red) && + (sl == null || !sl.red)) { + xpr.red = true; + x = xp; + } + else { + if (sr == null || !sr.red) { + if (sl != null) + sl.red = false; + xpr.red = true; + root = rotateRight(root, xpr); + xpr = (xp = x.parent) == null ? + null : xp.right; + } + if (xpr != null) { + xpr.red = (xp == null) ? false : xp.red; + if ((sr = xpr.right) != null) + sr.red = false; + } + if (xp != null) { + xp.red = false; + root = rotateLeft(root, xp); + } + x = root; + } + } + } + else { // symmetric + if (xpl != null && xpl.red) { + xpl.red = false; + xp.red = true; + root = rotateRight(root, xp); + xpl = (xp = x.parent) == null ? null : xp.left; + } + if (xpl == null) + x = xp; + else { + TreeNode sl = xpl.left, sr = xpl.right; + if ((sl == null || !sl.red) && + (sr == null || !sr.red)) { + xpl.red = true; + x = xp; + } + else { + if (sl == null || !sl.red) { + if (sr != null) + sr.red = false; + xpl.red = true; + root = rotateLeft(root, xpl); + xpl = (xp = x.parent) == null ? + null : xp.left; + } + if (xpl != null) { + xpl.red = (xp == null) ? false : xp.red; + if ((sl = xpl.left) != null) + sl.red = false; + } + if (xp != null) { + xp.red = false; + root = rotateRight(root, xp); + } + x = root; + } + } + } + } + } + + /** + * Recursive invariant check + */ + static boolean checkInvariants(TreeNode t) { + TreeNode tp = t.parent, tl = t.left, tr = t.right, + tb = t.prev, tn = (TreeNode)t.next; + if (tb != null && tb.next != t) + return false; + if (tn != null && tn.prev != t) + return false; + if (tp != null && t != tp.left && t != tp.right) + return false; + if (tl != null && (tl.parent != t || tl.hash > t.hash)) + return false; + if (tr != null && (tr.parent != t || tr.hash < t.hash)) + return false; + if (t.red && tl != null && tl.red && tr != null && tr.red) + return false; + if (tl != null && !checkInvariants(tl)) + return false; + if (tr != null && !checkInvariants(tr)) + return false; + return true; + } + } + + /* ------------------------------------------------------------ */ + // Primitive long HashMap support + + @SuppressWarnings("unchecked") + private K castKeyToGenericType(Long key) { + return (K)(key); + } + + private void initUsingPrimHashMap() { + usingPrimHashMap = true; + primMapNullKeyValid = false; + primMapValOfNullKey = null; + } + + /** + * set usingPrimHashMap to false to disable primitive long hashmap + */ + final protected void disablePrimHashMap() { + usingPrimHashMap = false; + } + + private boolean usePrimHashMap() { + return usingPrimHashMap; + } + + private boolean usePrimHashMap(Object key) { + if (!usingPrimHashMap) { + return false; + } + if (key != null && !(key instanceof Long)) { + rollbackToGenericMap(); + return false; + } + return true; + } + + /** + * This method copy prim hash map's key-values to Node[] table + * and then set usingPrimHashMap to false + */ + private void rollbackToGenericMap() { + if (!usePrimHashMap()) { + return ; + } + // add lock to prevent multiple threads from executing the following rollback code: + synchronized (this) { + if (!usePrimHashMap()) { + return ; + } + if (size > 0) { + // null table will use threshold as initial length. + // set threshold according size here to make sure that table.size is power of 2 + threshold = tableSizeFor(size); + // take a snapshot to detect concurrent modification + int expectedSize = size; + int expectedCount = modCount; + int remaining = size; + // put existing key-value to GenericMap + if (primMapNullKeyValid) { + putVal(null, primMapValOfNullKey, false, true, false); + --remaining; + } + final boolean[] valids = primMapValids; + if (valids != null) { + final Long[] keys = primMapKeys; + final V[] values = primMapValues; + int Cap = valids.length; + for (int i = 0; remaining > 0 && i < Cap; ++i) { + if (valids[i]) { + putVal(castKeyToGenericType(keys[i]), values[i], false, true, false); + --remaining; + } + } + } + + if (remaining != 0 || expectedSize != size || expectedCount != modCount) { + throw new ConcurrentModificationException(); + } + // Don't set arrays to null. Keep long map's data to avoid concurrent visit NPE + } + disablePrimHashMap(); + } + } + + /** + * Computes hash to get index. + */ + static private int primHashMapCalculateIndex(Object key, final int mask) { + return hash(key) & mask; + } + + private void primHashMapResize() { + final boolean[] oldValids = primMapValids; + int oldCap = (oldValids == null) ? 0 : oldValids.length; + int newCap = calNewCapAndUpdateThreshold(oldCap); + // 0 means oldCap reaches the MAXIMUM_CAPACITY + if (newCap == 0) { + throw new IllegalStateException("can't resize due to primitive long map reaches the max capacity"); + } + + final boolean[] newValids = new boolean[newCap]; + final Long[] newKeys = new Long[newCap]; + @SuppressWarnings({"rawtypes","unchecked"}) + final V[] newValues = (V[])new Object[newCap]; + + final int mask = newCap - 1; + if (oldValids != null) { + final Long[] oldKeys = primMapKeys; + final V[] oldValues = primMapValues; + int remaining = primMapNullKeyValid ? size - 1 : size; + for (int i = 0; remaining > 0 && i < oldCap; ++i) { + if (oldValids[i]) { + long key = oldKeys[i]; + V value = oldValues[i]; + int index = primHashMapCalculateIndex(key, mask); + while (newValids[index]) { + index = (++index) & mask; + } + newValids[index] = true; + newKeys[index] = key; + newValues[index] = value; + --remaining; + } + } + } + primMapValids = newValids; + primMapKeys = newKeys; + primMapValues = newValues; + } + + /** + * Implements Map.put and related methods. + * + * @param key the key + * @param value the value to put + * @param onlyIfAbsent if true, don't change existing value + * @return previous value, or null if none + */ + private V primHashMapPutVal(Long key, V value, boolean onlyIfAbsent) { + if (key == null) { + if (primMapNullKeyValid) { // existing mapping for key + V oldValue = primMapValOfNullKey; + if (!onlyIfAbsent || oldValue == null) + primMapValOfNullKey = value; + return oldValue; + } + primMapNullKeyValid = true; + primMapValOfNullKey = value; + ++modCount; + ++size; + return null; + } + if (primMapValids == null || primMapValids.length == 0) { + primHashMapResize(); + } + + final boolean[] valids = primMapValids; + final Long[] keys = primMapKeys; + final V[] values = primMapValues; + int remainingLength = valids.length; + final int mask = remainingLength - 1; + int index = primHashMapCalculateIndex(key, mask); + // find empty slots to insert + while (valids[index] && remainingLength > 0) { + if (Objects.equals(keys[index], key)) { + break; + } + index = (++index) & mask; + --remainingLength; + } + if (valids[index]) { // existing mapping for key + V oldValue = values[index]; + if (!onlyIfAbsent || oldValue == null) { + values[index] = value; + } + return oldValue; + } + keys[index] = key; + values[index] = value; + valids[index] = true; + ++modCount; + if (++size > threshold) + primHashMapResize(); + return null; + } + + /** + * find the key's index in prim hashmap + * + * @param key the key + * @return NULL_KEY_INDEX_FOR_RPIM_MAP if key is null and null key valid, + * related key-index if found, + * or KEY_NO_EXIST_FOR_PRIM_MAP if not found + */ + private int primHashGetIndexByKey(Object key) { + if (key == null) { + return primMapNullKeyValid ? NULL_KEY_INDEX_FOR_RPIM_MAP : KEY_NO_EXIST_FOR_PRIM_MAP; + } + if (!(key instanceof Long)) { + return KEY_NO_EXIST_FOR_PRIM_MAP; + } + final boolean[] valids = primMapValids; + if (valids == null || valids.length == 0) { + return KEY_NO_EXIST_FOR_PRIM_MAP; + } + + final Long[] keys = primMapKeys; + int remainingLength = valids.length; + final int mask = remainingLength - 1; + int index = primHashMapCalculateIndex(key, mask); + while (valids[index] && remainingLength > 0) { + if (Objects.equals(keys[index], key)) { + return index; + } + index = (++index) & mask; + --remainingLength; + } + return KEY_NO_EXIST_FOR_PRIM_MAP; + } + + private V primHashMapGetValByIndex(int index) { + if (index == KEY_NO_EXIST_FOR_PRIM_MAP) { + return null; + } + return (index == NULL_KEY_INDEX_FOR_RPIM_MAP) ? primMapValOfNullKey : primMapValues[index]; + } + + private V primHashMapGet(Object key) { + int index = primHashGetIndexByKey(key); + return primHashMapGetValByIndex(index); + } + + private boolean primHashMapContainsValue(Object value) { + int remaining = size; + if (primMapNullKeyValid) { + if (Objects.equals(value, primMapValOfNullKey)) { + return true; + } + --remaining; + } + final boolean[] valids = primMapValids; + if (valids == null || valids.length == 0) { + return false; + } + final V[] values = primMapValues; + final int length = valids.length; + for (int i = 0; remaining > 0 && i < length; ++i) { + if (valids[i]) { + if (Objects.equals(value, values[i])) { + return true; + } + --remaining; + } + } + return false; + } + + /** + * remove an element from prim hashmap by index. + * + * @param index the index of element to be removed + * @return the value of key, or null if none + */ + private V primHashMapRemoveByIndex(int index) { + int removeIdx = index; + if (removeIdx == KEY_NO_EXIST_FOR_PRIM_MAP) { + return null; + } + V oldValue; + if (removeIdx == NULL_KEY_INDEX_FOR_RPIM_MAP) { + oldValue = primMapValOfNullKey; + primMapNullKeyValid = false; + primMapValOfNullKey = null; + } else { + oldValue = primMapValues[removeIdx]; + final boolean[] valids = primMapValids; + final V[] values = primMapValues; + final Long[] keys = primMapKeys; + int mask = valids.length - 1; + // Moves the slot, whose expected idx and its actual index overwrite the removed slot, to the removed slot. + // Do it recursively until reaching an empty slot(there is always an empty slot since load factor <= 0.8f) + int actualIdx = (removeIdx + 1) & mask; + while (valids[actualIdx]) { + int expectedIdx = primHashMapCalculateIndex(keys[actualIdx], mask); + // move actual to remove, then set actual as new remove + // | expectedIdx--->removeIdx--->actualIdx | or + // |--->actualIdx expectedIdx--->removeIdx--->| or + // |--->removeIdx--->actualIdx expectedIdx--->| + if ((expectedIdx <= removeIdx && removeIdx < actualIdx) || + (expectedIdx > actualIdx && (expectedIdx <= removeIdx || removeIdx < actualIdx))) { + keys[removeIdx] = keys[actualIdx]; + values[removeIdx] = values[actualIdx]; + removeIdx = actualIdx; + } + actualIdx = (++actualIdx) & mask; + } + valids[removeIdx] = false; + values[removeIdx] = null; + } + ++modCount; + --size; + return oldValue; + } + + /** + * remove an element from prim hashmap by key. + * + * @param key the key + * @return the value of key, or null if none + */ + private V primHashMapRemoveByKey(Object key) { + int index = primHashGetIndexByKey(key); + return primHashMapRemoveByIndex(index); + } + + private V primHashMapComputeIfAbsent(K key, + Function mappingFunction) { + int index = primHashGetIndexByKey(key); + V oldValue = primHashMapGetValByIndex(index); + if (oldValue != null) { + return oldValue; + } + int mc = modCount; + V v = mappingFunction.apply(key); + if (mc != modCount) { throw new ConcurrentModificationException(); } + if (v == null) { + return null; + } else if (index != KEY_NO_EXIST_FOR_PRIM_MAP) { // key exist and oldValue is null + if (index == NULL_KEY_INDEX_FOR_RPIM_MAP) { + primMapValOfNullKey = v; + } else { + primMapValues[index] = v; + } + return v; + } else { // key not exist + primHashMapPutVal((Long)key, v, false); + return v; + } + } + + private V primHashMapComputeIfPresent(K key, + BiFunction remappingFunction) { + int index = primHashGetIndexByKey(key); + V oldValue = primHashMapGetValByIndex(index); + if (oldValue == null) { + return null; + } + + int mc = modCount; + V v = remappingFunction.apply(key, oldValue); + if (mc != modCount) { throw new ConcurrentModificationException(); } + if (v == null) { + primHashMapRemoveByIndex(index); + return null; + } + if (index == NULL_KEY_INDEX_FOR_RPIM_MAP) { + primMapValOfNullKey = v; + } else { + primMapValues[index] = v; + } + return v; + } + + private V primHashMapCompute(K key, + BiFunction remappingFunction) { + int index = primHashGetIndexByKey(key); + V oldValue = primHashMapGetValByIndex(index); + int mc = modCount; + V v = remappingFunction.apply(key, oldValue); + if (mc != modCount) { throw new ConcurrentModificationException(); } + if (index != KEY_NO_EXIST_FOR_PRIM_MAP) { + if (v != null) { + if (index == NULL_KEY_INDEX_FOR_RPIM_MAP) { + primMapValOfNullKey = v; + } else { + primMapValues[index] = v; + } + } else { + primHashMapRemoveByIndex(index); + } + } else if (v != null) { + primHashMapPutVal((Long)key, v, false); + } + return v; + } + + private V primHashMapMerge(K key, V value, + BiFunction remappingFunction) { + int index = primHashGetIndexByKey(key); + V oldValue = primHashMapGetValByIndex(index); + if (index != KEY_NO_EXIST_FOR_PRIM_MAP) { + V v; + if (oldValue != null) { + int mc = modCount; + v = remappingFunction.apply(oldValue, value); + if (mc != modCount) { + throw new ConcurrentModificationException(); + } + } else { + v = value; + } + if (v != null) { + if (index == NULL_KEY_INDEX_FOR_RPIM_MAP) { + primMapValOfNullKey = v; + } else { + primMapValues[index] = v; + } + } else { + primHashMapRemoveByIndex(index); + } + return v; + } else { + primHashMapPutVal((Long)key, value, false); + return value; + } + } + + /** + * prim hashmap node, used for key-value iterator. + */ + class primHashMapNode implements Map.Entry { + final K key; + V value; + final int nodeIdx; + + primHashMapNode(int nodeIdx) { + if (nodeIdx == NULL_KEY_INDEX_FOR_RPIM_MAP) { + this.key = null; + this.value = HashMap.this.primMapValOfNullKey; + } else { + this.key = HashMap.this.castKeyToGenericType(HashMap.this.primMapKeys[nodeIdx]); + this.value = HashMap.this.primMapValues[nodeIdx]; + } + this.nodeIdx = nodeIdx; + } + + public final K getKey() { return key; } + public final V getValue() { return value; } + public final String toString() { return key + "=" + value; } + + public final boolean equals(Object o) { + if (o == this) + return true; + + return o instanceof Map.Entry e + && Objects.equals(key, e.getKey()) + && Objects.equals(value, e.getValue()); + } + + public final int hashCode() { + return Objects.hashCode(key) ^ Objects.hashCode(value); + } + + public final V setValue(V newValue) { + V oldValue = value; + value = newValue; + if (nodeIdx == NULL_KEY_INDEX_FOR_RPIM_MAP) { + HashMap.this.primMapValOfNullKey = newValue; + } else { + HashMap.this.primMapValues[nodeIdx] = newValue; + } + return oldValue; + } + } + + /* ------------------------------------------------------------ */ + // prim hashmap iterators + + abstract class primHashMapIterator { + int nextIndex; + int curIndex; // current slot + int expectedModCount; // for fast-fail + int remaining; + int startIndex; + int stopIndex; + int mask; + + primHashMapIterator() { + expectedModCount = modCount; + remaining = size; + curIndex = nextIndex = KEY_NO_EXIST_FOR_PRIM_MAP; + // init startIndex/stopIndex if there are elements in primMapValues + if (remaining > (primMapNullKeyValid ? 1 : 0)) { + final boolean[] valids = primMapValids; + mask = valids.length - 1; + // Use reverse traversal to prevent a node from being traversed after it is deleted. + // Set stopIndex to the index of the first empty slot (starting from 0), and then set + // startIndex to the index of the first valid slot starting from the reverse of stopIndex. + stopIndex = 0; + while (valids[stopIndex]) { + stopIndex = (++stopIndex) & mask; + } + startIndex = stopIndex; + while (!valids[startIndex]) { + startIndex = (--startIndex) & mask; + } + } else { + startIndex = stopIndex = KEY_NO_EXIST_FOR_PRIM_MAP; + } + + if (remaining > 0) { // advance to first entry + if (primMapNullKeyValid) { // always set first node to null key if exist + nextIndex = NULL_KEY_INDEX_FOR_RPIM_MAP; + } else { + nextIndex = startIndex; + } + } + } + + public final boolean hasNext() { + return remaining > 0; + } + + final void findNext() { + if (modCount != expectedModCount) + throw new ConcurrentModificationException(); + if (nextIndex == KEY_NO_EXIST_FOR_PRIM_MAP) { + throw new NoSuchElementException(); + } + curIndex = nextIndex; + --remaining; + if (remaining > 0) { + // startIndex has been calculated if curIndex is null key index + if (curIndex != NULL_KEY_INDEX_FOR_RPIM_MAP) { + final boolean[] valids = primMapValids; + while (startIndex != stopIndex) { + startIndex = (--startIndex) & mask; + if (valids[startIndex]) { + break; + } + } + } + nextIndex = startIndex; + } else { + nextIndex = KEY_NO_EXIST_FOR_PRIM_MAP; + } + } + + public final void remove() { + if (curIndex == KEY_NO_EXIST_FOR_PRIM_MAP) { + throw new IllegalStateException(); + } + if (modCount != expectedModCount) + throw new ConcurrentModificationException(); + primHashMapRemoveByIndex(curIndex); + curIndex = KEY_NO_EXIST_FOR_PRIM_MAP; + expectedModCount = modCount; + } + } + + final class primHashMapKeyIterator extends primHashMapIterator + implements Iterator { + public final K next() { + findNext(); + return (curIndex == NULL_KEY_INDEX_FOR_RPIM_MAP) ? null : castKeyToGenericType(primMapKeys[curIndex]); + } + } + + final class primHashMapValueIterator extends primHashMapIterator + implements Iterator { + public final V next() { + findNext(); + return (curIndex == NULL_KEY_INDEX_FOR_RPIM_MAP) ? primMapValOfNullKey : primMapValues[curIndex]; + } + } + + final class primHashMapEntryIterator extends primHashMapIterator + implements Iterator> { + public final Map.Entry next() { + findNext(); + return new primHashMapNode(curIndex); + } + } + + /* ------------------------------------------------------------ */ + // prim hashmap spliterators + + abstract class primHashMapSpliterator implements Spliterator { + int index; // current index, modified on advance/split + int fence; // one past last index + int est; // size estimate + int expectedModCount; // for comodification checks + + // indicate whether this spliterator need to process null key or not + // always set to false if this spliterator came form trySplit() + boolean needToProcessNullKey; + + primHashMapSpliterator(int origin, int fence, int est, + int expectedModCount, boolean needToProcessNullKey) { + this.index = origin; + this.fence = fence; + this.est = est; + this.expectedModCount = expectedModCount; + this.needToProcessNullKey = needToProcessNullKey; + } + + final int getFence() { // initialize fence and size on first use + int hi; + if ((hi = fence) < 0) { + est = size; + expectedModCount = modCount; + boolean[] valids = primMapValids; + hi = fence = (valids == null) ? 0 : valids.length; + } + return hi; + } + + public final long estimateSize() { + getFence(); // force init + return (long) est; + } + } + + final class primHashMapKeySpliterator + extends primHashMapSpliterator { + primHashMapKeySpliterator(int origin, int fence, int est, + int expectedModCount, boolean needToProcessNullKey) { + super(origin, fence, est, expectedModCount, needToProcessNullKey); + } + + public primHashMapKeySpliterator trySplit() { + int hi = getFence(), lo = index, mid = (lo + hi) >>> 1; + return (lo >= mid) ? null : + new primHashMapKeySpliterator(lo, index = mid, est >>>= 1, + expectedModCount, false); + } + + public void forEachRemaining(Consumer action) { + int i, hi, mc; + if (action == null) + throw new NullPointerException(); + boolean[] valids = primMapValids; + Long[] keys = primMapKeys; + if ((hi = fence) < 0) { + mc = expectedModCount = modCount; + hi = fence = (valids == null) ? 0 : valids.length; + } + else + mc = expectedModCount; + if (valids != null && valids.length >= hi && + (i = index) >= 0 && i < (index = hi)) { + do { + if (valids[i]) { + action.accept(castKeyToGenericType(keys[i])); + } + ++i; + } while (i < hi); + if (modCount != mc) + throw new ConcurrentModificationException(); + } + if (needToProcessNullKey && primMapNullKeyValid) { + action.accept(null); + if (modCount != mc) + throw new ConcurrentModificationException(); + needToProcessNullKey = false; + } + } + + public boolean tryAdvance(Consumer action) { + int hi = getFence(); // force init + if (action == null) + throw new NullPointerException(); + boolean[] valids = primMapValids; + Long[] keys = primMapKeys; + if (valids != null && valids.length >= hi && index >= 0) { + while (index < hi) { + if (!valids[index]) { + ++index; + } else { + action.accept(castKeyToGenericType(keys[index])); + ++index; + if (modCount != expectedModCount) { + throw new ConcurrentModificationException(); + } + return true; + } + } + } + if (needToProcessNullKey && primMapNullKeyValid) { + action.accept(null); + if (modCount != expectedModCount) { + throw new ConcurrentModificationException(); + } + needToProcessNullKey = false; + return true; + } + return false; + } + + public int characteristics() { + return (fence < 0 || est == size ? Spliterator.SIZED : 0) | + Spliterator.DISTINCT; + } + } + + final class primHashMapValueSpliterator + extends primHashMapSpliterator { + primHashMapValueSpliterator(int origin, int fence, int est, + int expectedModCount, boolean needToProcessNullKey) { + super(origin, fence, est, expectedModCount, needToProcessNullKey); + } + + public primHashMapValueSpliterator trySplit() { + int hi = getFence(), lo = index, mid = (lo + hi) >>> 1; + return (lo >= mid) ? null : + new primHashMapValueSpliterator(lo, index = mid, est >>>= 1, + expectedModCount, false); + } + + public void forEachRemaining(Consumer action) { + int i, hi, mc; + if (action == null) + throw new NullPointerException(); + boolean[] valids = primMapValids; + V[] values = primMapValues; + if ((hi = fence) < 0) { + mc = expectedModCount = modCount; + hi = fence = (valids == null) ? 0 : valids.length; + } + else + mc = expectedModCount; + if (valids != null && valids.length >= hi && + (i = index) >= 0 && i < (index = hi)) { + do { + if (valids[i]) { + action.accept(values[i]); + } + ++i; + } while (i < hi); + if (modCount != mc) + throw new ConcurrentModificationException(); + } + if (needToProcessNullKey && primMapNullKeyValid) { + action.accept(primMapValOfNullKey); + if (modCount != mc) + throw new ConcurrentModificationException(); + needToProcessNullKey = false; + } + } + + public boolean tryAdvance(Consumer action) { + int hi = getFence(); // force init + if (action == null) + throw new NullPointerException(); + boolean[] valids = primMapValids; + V[] values = primMapValues; + if (valids != null && valids.length >= hi && index >= 0) { + while (index < hi) { + if (!valids[index]) { + ++index; + } else { + action.accept(values[index]); + ++index; + if (modCount != expectedModCount) + throw new ConcurrentModificationException(); + return true; + } + } + } + if (needToProcessNullKey && primMapNullKeyValid) { + action.accept(primMapValOfNullKey); + if (modCount != expectedModCount) + throw new ConcurrentModificationException(); + needToProcessNullKey = false; + return true; + } + return false; + } + + public int characteristics() { + return (fence < 0 || est == size ? Spliterator.SIZED : 0); + } + } + + final class primHashMapEntrySpliterator + extends primHashMapSpliterator> { + primHashMapEntrySpliterator(int origin, int fence, int est, + int expectedModCount, boolean needToProcessNullKey) { + super(origin, fence, est, expectedModCount, needToProcessNullKey); + } + + public primHashMapEntrySpliterator trySplit() { + int hi = getFence(), lo = index, mid = (lo + hi) >>> 1; + return (lo >= mid) ? null : + new primHashMapEntrySpliterator(lo, index = mid, est >>>= 1, + expectedModCount, false); + } + + public void forEachRemaining(Consumer> action) { + int i, hi, mc; + if (action == null) + throw new NullPointerException(); + boolean[] valids = primMapValids; + + if ((hi = fence) < 0) { + mc = expectedModCount = modCount; + hi = fence = (valids == null) ? 0 : valids.length; + } + else + mc = expectedModCount; + if (valids != null && valids.length >= hi && + (i = index) >= 0 && i < (index = hi)) { + do { + if (valids[i]) { + action.accept(new primHashMapNode(i)); + } + ++i; + } while ( i < hi); + if (modCount != mc) + throw new ConcurrentModificationException(); + } + if (needToProcessNullKey && primMapNullKeyValid) { + action.accept(new primHashMapNode(NULL_KEY_INDEX_FOR_RPIM_MAP)); + if (modCount != mc) + throw new ConcurrentModificationException(); + needToProcessNullKey = false; + } + } + + public boolean tryAdvance(Consumer> action) { + int hi = getFence(); // force init + if (action == null) + throw new NullPointerException(); + boolean[] valids = primMapValids; + if (valids != null && valids.length >= hi && index >= 0) { + while (index < hi) { + if (!valids[index]) { + ++index; + } + else { + action.accept(new primHashMapNode(index)); + ++index; + if (modCount != expectedModCount) + throw new ConcurrentModificationException(); + return true; + } + } + } + if (needToProcessNullKey && primMapNullKeyValid) { + action.accept(new primHashMapNode(NULL_KEY_INDEX_FOR_RPIM_MAP)); + if (modCount != expectedModCount) + throw new ConcurrentModificationException(); + needToProcessNullKey = false; + return true; + } + return false; + } + + public int characteristics() { + return (fence < 0 || est == size ? Spliterator.SIZED : 0) | + Spliterator.DISTINCT; + } + } + +} diff --git a/test/jdk/java/util/HashMap/LinkedHashMap.java b/test/jdk/java/util/HashMap/LinkedHashMap.java new file mode 100644 index 000000000..92c1a795a --- /dev/null +++ b/test/jdk/java/util/HashMap/LinkedHashMap.java @@ -0,0 +1,798 @@ +/* + * Copyright (c) 1997, 2020, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +package java.util; + +import java.util.function.Consumer; +import java.util.function.BiConsumer; +import java.util.function.BiFunction; +import java.io.IOException; + +/** + *

Hash table and linked list implementation of the {@code Map} interface, + * with predictable iteration order. This implementation differs from + * {@code HashMap} in that it maintains a doubly-linked list running through + * all of its entries. This linked list defines the iteration ordering, + * which is normally the order in which keys were inserted into the map + * (insertion-order). Note that insertion order is not affected + * if a key is re-inserted into the map. (A key {@code k} is + * reinserted into a map {@code m} if {@code m.put(k, v)} is invoked when + * {@code m.containsKey(k)} would return {@code true} immediately prior to + * the invocation.) + * + *

This implementation spares its clients from the unspecified, generally + * chaotic ordering provided by {@link HashMap} (and {@link Hashtable}), + * without incurring the increased cost associated with {@link TreeMap}. It + * can be used to produce a copy of a map that has the same order as the + * original, regardless of the original map's implementation: + * 

{@code
+ *     void foo(Map m) {
+ *         Map copy = new LinkedHashMap<>(m);
+ *         ...
+ *     }
+ * }
+ * This technique is particularly useful if a module takes a map on input, + * copies it, and later returns results whose order is determined by that of + * the copy. (Clients generally appreciate having things returned in the same + * order they were presented.) + * + *

A special {@link #LinkedHashMap(int,float,boolean) constructor} is + * provided to create a linked hash map whose order of iteration is the order + * in which its entries were last accessed, from least-recently accessed to + * most-recently (access-order). This kind of map is well-suited to + * building LRU caches. Invoking the {@code put}, {@code putIfAbsent}, + * {@code get}, {@code getOrDefault}, {@code compute}, {@code computeIfAbsent}, + * {@code computeIfPresent}, or {@code merge} methods results + * in an access to the corresponding entry (assuming it exists after the + * invocation completes). The {@code replace} methods only result in an access + * of the entry if the value is replaced. The {@code putAll} method generates one + * entry access for each mapping in the specified map, in the order that + * key-value mappings are provided by the specified map's entry set iterator. + * No other methods generate entry accesses. In particular, operations + * on collection-views do not affect the order of iteration of the + * backing map. + * + *

The {@link #removeEldestEntry(Map.Entry)} method may be overridden to + * impose a policy for removing stale mappings automatically when new mappings + * are added to the map. + * + *

This class provides all of the optional {@code Map} operations, and + * permits null elements. Like {@code HashMap}, it provides constant-time + * performance for the basic operations ({@code add}, {@code contains} and + * {@code remove}), assuming the hash function disperses elements + * properly among the buckets. Performance is likely to be just slightly + * below that of {@code HashMap}, due to the added expense of maintaining the + * linked list, with one exception: Iteration over the collection-views + * of a {@code LinkedHashMap} requires time proportional to the size + * of the map, regardless of its capacity. Iteration over a {@code HashMap} + * is likely to be more expensive, requiring time proportional to its + * capacity. + * + *

A linked hash map has two parameters that affect its performance: + * initial capacity and load factor. They are defined precisely + * as for {@code HashMap}. Note, however, that the penalty for choosing an + * excessively high value for initial capacity is less severe for this class + * than for {@code HashMap}, as iteration times for this class are unaffected + * by capacity. + * + *

Note that this implementation is not synchronized. + * If multiple threads access a linked hash map concurrently, and at least + * one of the threads modifies the map structurally, it must be + * synchronized externally. This is typically accomplished by + * synchronizing on some object that naturally encapsulates the map. + * + * If no such object exists, the map should be "wrapped" using the + * {@link Collections#synchronizedMap Collections.synchronizedMap} + * method. This is best done at creation time, to prevent accidental + * unsynchronized access to the map:

+ *   Map m = Collections.synchronizedMap(new LinkedHashMap(...));
+ * + * A structural modification is any operation that adds or deletes one or more + * mappings or, in the case of access-ordered linked hash maps, affects + * iteration order. In insertion-ordered linked hash maps, merely changing + * the value associated with a key that is already contained in the map is not + * a structural modification. In access-ordered linked hash maps, + * merely querying the map with {@code get} is a structural modification. + * ) + * + *

The iterators returned by the {@code iterator} method of the collections + * returned by all of this class's collection view methods are + * fail-fast: if the map is structurally modified at any time after + * the iterator is created, in any way except through the iterator's own + * {@code remove} method, the iterator will throw a {@link + * ConcurrentModificationException}. Thus, in the face of concurrent + * modification, the iterator fails quickly and cleanly, rather than risking + * arbitrary, non-deterministic behavior at an undetermined time in the future. + * + *

Note that the fail-fast behavior of an iterator cannot be guaranteed + * as it is, generally speaking, impossible to make any hard guarantees in the + * presence of unsynchronized concurrent modification. Fail-fast iterators + * throw {@code ConcurrentModificationException} on a best-effort basis. + * Therefore, it would be wrong to write a program that depended on this + * exception for its correctness: the fail-fast behavior of iterators + * should be used only to detect bugs. + * + *

The spliterators returned by the spliterator method of the collections + * returned by all of this class's collection view methods are + * late-binding, + * fail-fast, and additionally report {@link Spliterator#ORDERED}. + * + *

This class is a member of the + * + * Java Collections Framework. + * + * @implNote + * The spliterators returned by the spliterator method of the collections + * returned by all of this class's collection view methods are created from + * the iterators of the corresponding collections. + * + * @param the type of keys maintained by this map + * @param the type of mapped values + * + * @author Josh Bloch + * @see Object#hashCode() + * @see Collection + * @see Map + * @see HashMap + * @see TreeMap + * @see Hashtable + * @since 1.4 + */ +public class LinkedHashMap + extends HashMap + implements Map +{ + + /* + * Implementation note. A previous version of this class was + * internally structured a little differently. Because superclass + * HashMap now uses trees for some of its nodes, class + * LinkedHashMap.Entry is now treated as intermediary node class + * that can also be converted to tree form. The name of this + * class, LinkedHashMap.Entry, is confusing in several ways in its + * current context, but cannot be changed. Otherwise, even though + * it is not exported outside this package, some existing source + * code is known to have relied on a symbol resolution corner case + * rule in calls to removeEldestEntry that suppressed compilation + * errors due to ambiguous usages. So, we keep the name to + * preserve unmodified compilability. + * + * The changes in node classes also require using two fields + * (head, tail) rather than a pointer to a header node to maintain + * the doubly-linked before/after list. This class also + * previously used a different style of callback methods upon + * access, insertion, and removal. + */ + + /** + * HashMap.Node subclass for normal LinkedHashMap entries. + */ + static class Entry extends HashMap.Node { + Entry before, after; + Entry(int hash, K key, V value, Node next) { + super(hash, key, value, next); + } + } + + @java.io.Serial + private static final long serialVersionUID = 3801124242820219131L; + + /** + * The head (eldest) of the doubly linked list. + */ + transient LinkedHashMap.Entry head; + + /** + * The tail (youngest) of the doubly linked list. + */ + transient LinkedHashMap.Entry tail; + + /** + * The iteration ordering method for this linked hash map: {@code true} + * for access-order, {@code false} for insertion-order. + * + * @serial + */ + final boolean accessOrder; + + // internal utilities + + // link at the end of list + private void linkNodeLast(LinkedHashMap.Entry p) { + LinkedHashMap.Entry last = tail; + tail = p; + if (last == null) + head = p; + else { + p.before = last; + last.after = p; + } + } + + // apply src's links to dst + private void transferLinks(LinkedHashMap.Entry src, + LinkedHashMap.Entry dst) { + LinkedHashMap.Entry b = dst.before = src.before; + LinkedHashMap.Entry a = dst.after = src.after; + if (b == null) + head = dst; + else + b.after = dst; + if (a == null) + tail = dst; + else + a.before = dst; + } + + // overrides of HashMap hook methods + + void reinitialize() { + super.reinitialize(); + disablePrimHashMap(); + head = tail = null; + } + + Node newNode(int hash, K key, V value, Node e) { + LinkedHashMap.Entry p = + new LinkedHashMap.Entry<>(hash, key, value, e); + linkNodeLast(p); + return p; + } + + Node replacementNode(Node p, Node next) { + LinkedHashMap.Entry q = (LinkedHashMap.Entry)p; + LinkedHashMap.Entry t = + new LinkedHashMap.Entry<>(q.hash, q.key, q.value, next); + transferLinks(q, t); + return t; + } + + TreeNode newTreeNode(int hash, K key, V value, Node next) { + TreeNode p = new TreeNode<>(hash, key, value, next); + linkNodeLast(p); + return p; + } + + TreeNode replacementTreeNode(Node p, Node next) { + LinkedHashMap.Entry q = (LinkedHashMap.Entry)p; + TreeNode t = new TreeNode<>(q.hash, q.key, q.value, next); + transferLinks(q, t); + return t; + } + + void afterNodeRemoval(Node e) { // unlink + LinkedHashMap.Entry p = + (LinkedHashMap.Entry)e, b = p.before, a = p.after; + p.before = p.after = null; + if (b == null) + head = a; + else + b.after = a; + if (a == null) + tail = b; + else + a.before = b; + } + + void afterNodeInsertion(boolean evict) { // possibly remove eldest + LinkedHashMap.Entry first; + if (evict && (first = head) != null && removeEldestEntry(first)) { + K key = first.key; + removeNode(hash(key), key, null, false, true); + } + } + + void afterNodeAccess(Node e) { // move node to last + LinkedHashMap.Entry last; + if (accessOrder && (last = tail) != e) { + LinkedHashMap.Entry p = + (LinkedHashMap.Entry)e, b = p.before, a = p.after; + p.after = null; + if (b == null) + head = a; + else + b.after = a; + if (a != null) + a.before = b; + else + last = b; + if (last == null) + head = p; + else { + p.before = last; + last.after = p; + } + tail = p; + ++modCount; + } + } + + void internalWriteEntries(java.io.ObjectOutputStream s) throws IOException { + for (LinkedHashMap.Entry e = head; e != null; e = e.after) { + s.writeObject(e.key); + s.writeObject(e.value); + } + } + + /** + * Constructs an empty insertion-ordered {@code LinkedHashMap} instance + * with the specified initial capacity and load factor. + * + * @param initialCapacity the initial capacity + * @param loadFactor the load factor + * @throws IllegalArgumentException if the initial capacity is negative + * or the load factor is nonpositive + */ + public LinkedHashMap(int initialCapacity, float loadFactor) { + super(initialCapacity, loadFactor); + disablePrimHashMap(); + accessOrder = false; + } + + /** + * Constructs an empty insertion-ordered {@code LinkedHashMap} instance + * with the specified initial capacity and a default load factor (0.75). + * + * @param initialCapacity the initial capacity + * @throws IllegalArgumentException if the initial capacity is negative + */ + public LinkedHashMap(int initialCapacity) { + super(initialCapacity); + disablePrimHashMap(); + accessOrder = false; + } + + /** + * Constructs an empty insertion-ordered {@code LinkedHashMap} instance + * with the default initial capacity (16) and load factor (0.75). + */ + public LinkedHashMap() { + super(); + disablePrimHashMap(); + accessOrder = false; + } + + /** + * Constructs an insertion-ordered {@code LinkedHashMap} instance with + * the same mappings as the specified map. The {@code LinkedHashMap} + * instance is created with a default load factor (0.75) and an initial + * capacity sufficient to hold the mappings in the specified map. + * + * @param m the map whose mappings are to be placed in this map + * @throws NullPointerException if the specified map is null + */ + public LinkedHashMap(Map m) { + super(); + disablePrimHashMap(); + accessOrder = false; + putMapEntries(m, false); + } + + /** + * Constructs an empty {@code LinkedHashMap} instance with the + * specified initial capacity, load factor and ordering mode. + * + * @param initialCapacity the initial capacity + * @param loadFactor the load factor + * @param accessOrder the ordering mode - {@code true} for + * access-order, {@code false} for insertion-order + * @throws IllegalArgumentException if the initial capacity is negative + * or the load factor is nonpositive + */ + public LinkedHashMap(int initialCapacity, + float loadFactor, + boolean accessOrder) { + super(initialCapacity, loadFactor); + disablePrimHashMap(); + this.accessOrder = accessOrder; + } + + + /** + * Returns {@code true} if this map maps one or more keys to the + * specified value. + * + * @param value value whose presence in this map is to be tested + * @return {@code true} if this map maps one or more keys to the + * specified value + */ + public boolean containsValue(Object value) { + for (LinkedHashMap.Entry e = head; e != null; e = e.after) { + V v = e.value; + if (v == value || (value != null && value.equals(v))) + return true; + } + return false; + } + + /** + * Returns the value to which the specified key is mapped, + * or {@code null} if this map contains no mapping for the key. + * + *

More formally, if this map contains a mapping from a key + * {@code k} to a value {@code v} such that {@code (key==null ? k==null : + * key.equals(k))}, then this method returns {@code v}; otherwise + * it returns {@code null}. (There can be at most one such mapping.) + * + *

A return value of {@code null} does not necessarily + * indicate that the map contains no mapping for the key; it's also + * possible that the map explicitly maps the key to {@code null}. + * The {@link #containsKey containsKey} operation may be used to + * distinguish these two cases. + */ + public V get(Object key) { + Node e; + if ((e = getNode(key)) == null) + return null; + if (accessOrder) + afterNodeAccess(e); + return e.value; + } + + /** + * {@inheritDoc} + */ + public V getOrDefault(Object key, V defaultValue) { + Node e; + if ((e = getNode(key)) == null) + return defaultValue; + if (accessOrder) + afterNodeAccess(e); + return e.value; + } + + /** + * {@inheritDoc} + */ + public void clear() { + super.clear(); + head = tail = null; + } + + /** + * Returns {@code true} if this map should remove its eldest entry. + * This method is invoked by {@code put} and {@code putAll} after + * inserting a new entry into the map. It provides the implementor + * with the opportunity to remove the eldest entry each time a new one + * is added. This is useful if the map represents a cache: it allows + * the map to reduce memory consumption by deleting stale entries. + * + *

Sample use: this override will allow the map to grow up to 100 + * entries and then delete the eldest entry each time a new entry is + * added, maintaining a steady state of 100 entries. + * 

+     *     private static final int MAX_ENTRIES = 100;
+     *
+     *     protected boolean removeEldestEntry(Map.Entry eldest) {
+     *        return size() > MAX_ENTRIES;
+     *     }
+     *
+ * + *

This method typically does not modify the map in any way, + * instead allowing the map to modify itself as directed by its + * return value. It is permitted for this method to modify + * the map directly, but if it does so, it must return + * {@code false} (indicating that the map should not attempt any + * further modification). The effects of returning {@code true} + * after modifying the map from within this method are unspecified. + * + *

This implementation merely returns {@code false} (so that this + * map acts like a normal map - the eldest element is never removed). + * + * @param eldest The least recently inserted entry in the map, or if + * this is an access-ordered map, the least recently accessed + * entry. This is the entry that will be removed it this + * method returns {@code true}. If the map was empty prior + * to the {@code put} or {@code putAll} invocation resulting + * in this invocation, this will be the entry that was just + * inserted; in other words, if the map contains a single + * entry, the eldest entry is also the newest. + * @return {@code true} if the eldest entry should be removed + * from the map; {@code false} if it should be retained. + */ + protected boolean removeEldestEntry(Map.Entry eldest) { + return false; + } + + /** + * Returns a {@link Set} view of the keys contained in this map. + * The set is backed by the map, so changes to the map are + * reflected in the set, and vice-versa. If the map is modified + * while an iteration over the set is in progress (except through + * the iterator's own {@code remove} operation), the results of + * the iteration are undefined. The set supports element removal, + * which removes the corresponding mapping from the map, via the + * {@code Iterator.remove}, {@code Set.remove}, + * {@code removeAll}, {@code retainAll}, and {@code clear} + * operations. It does not support the {@code add} or {@code addAll} + * operations. + * Its {@link Spliterator} typically provides faster sequential + * performance but much poorer parallel performance than that of + * {@code HashMap}. + * + * @return a set view of the keys contained in this map + */ + public Set keySet() { + Set ks = keySet; + if (ks == null) { + ks = new LinkedKeySet(); + keySet = ks; + } + return ks; + } + + @Override + final T[] keysToArray(T[] a) { + Object[] r = a; + int idx = 0; + for (LinkedHashMap.Entry e = head; e != null; e = e.after) { + r[idx++] = e.key; + } + return a; + } + + @Override + final T[] valuesToArray(T[] a) { + Object[] r = a; + int idx = 0; + for (LinkedHashMap.Entry e = head; e != null; e = e.after) { + r[idx++] = e.value; + } + return a; + } + + final class LinkedKeySet extends AbstractSet { + public final int size() { return size; } + public final void clear() { LinkedHashMap.this.clear(); } + public final Iterator iterator() { + return new LinkedKeyIterator(); + } + public final boolean contains(Object o) { return containsKey(o); } + public final boolean remove(Object key) { + return removeNode(hash(key), key, null, false, true) != null; + } + public final Spliterator spliterator() { + return Spliterators.spliterator(this, Spliterator.SIZED | + Spliterator.ORDERED | + Spliterator.DISTINCT); + } + + public Object[] toArray() { + return keysToArray(new Object[size]); + } + + public T[] toArray(T[] a) { + return keysToArray(prepareArray(a)); + } + + public final void forEach(Consumer action) { + if (action == null) + throw new NullPointerException(); + int mc = modCount; + for (LinkedHashMap.Entry e = head; e != null; e = e.after) + action.accept(e.key); + if (modCount != mc) + throw new ConcurrentModificationException(); + } + } + + /** + * Returns a {@link Collection} view of the values contained in this map. + * The collection is backed by the map, so changes to the map are + * reflected in the collection, and vice-versa. If the map is + * modified while an iteration over the collection is in progress + * (except through the iterator's own {@code remove} operation), + * the results of the iteration are undefined. The collection + * supports element removal, which removes the corresponding + * mapping from the map, via the {@code Iterator.remove}, + * {@code Collection.remove}, {@code removeAll}, + * {@code retainAll} and {@code clear} operations. It does not + * support the {@code add} or {@code addAll} operations. + * Its {@link Spliterator} typically provides faster sequential + * performance but much poorer parallel performance than that of + * {@code HashMap}. + * + * @return a view of the values contained in this map + */ + public Collection values() { + Collection vs = values; + if (vs == null) { + vs = new LinkedValues(); + values = vs; + } + return vs; + } + + final class LinkedValues extends AbstractCollection { + public final int size() { return size; } + public final void clear() { LinkedHashMap.this.clear(); } + public final Iterator iterator() { + return new LinkedValueIterator(); + } + public final boolean contains(Object o) { return containsValue(o); } + public final Spliterator spliterator() { + return Spliterators.spliterator(this, Spliterator.SIZED | + Spliterator.ORDERED); + } + + public Object[] toArray() { + return valuesToArray(new Object[size]); + } + + public T[] toArray(T[] a) { + return valuesToArray(prepareArray(a)); + } + + public final void forEach(Consumer action) { + if (action == null) + throw new NullPointerException(); + int mc = modCount; + for (LinkedHashMap.Entry e = head; e != null; e = e.after) + action.accept(e.value); + if (modCount != mc) + throw new ConcurrentModificationException(); + } + } + + /** + * Returns a {@link Set} view of the mappings contained in this map. + * The set is backed by the map, so changes to the map are + * reflected in the set, and vice-versa. If the map is modified + * while an iteration over the set is in progress (except through + * the iterator's own {@code remove} operation, or through the + * {@code setValue} operation on a map entry returned by the + * iterator) the results of the iteration are undefined. The set + * supports element removal, which removes the corresponding + * mapping from the map, via the {@code Iterator.remove}, + * {@code Set.remove}, {@code removeAll}, {@code retainAll} and + * {@code clear} operations. It does not support the + * {@code add} or {@code addAll} operations. + * Its {@link Spliterator} typically provides faster sequential + * performance but much poorer parallel performance than that of + * {@code HashMap}. + * + * @return a set view of the mappings contained in this map + */ + public Set> entrySet() { + Set> es; + return (es = entrySet) == null ? (entrySet = new LinkedEntrySet()) : es; + } + + final class LinkedEntrySet extends AbstractSet> { + public final int size() { return size; } + public final void clear() { LinkedHashMap.this.clear(); } + public final Iterator> iterator() { + return new LinkedEntryIterator(); + } + public final boolean contains(Object o) { + if (!(o instanceof Map.Entry e)) + return false; + Object key = e.getKey(); + Node candidate = getNode(key); + return candidate != null && candidate.equals(e); + } + public final boolean remove(Object o) { + if (o instanceof Map.Entry e) { + Object key = e.getKey(); + Object value = e.getValue(); + return removeNode(hash(key), key, value, true, true) != null; + } + return false; + } + public final Spliterator> spliterator() { + return Spliterators.spliterator(this, Spliterator.SIZED | + Spliterator.ORDERED | + Spliterator.DISTINCT); + } + public final void forEach(Consumer> action) { + if (action == null) + throw new NullPointerException(); + int mc = modCount; + for (LinkedHashMap.Entry e = head; e != null; e = e.after) + action.accept(e); + if (modCount != mc) + throw new ConcurrentModificationException(); + } + } + + // Map overrides + + public void forEach(BiConsumer action) { + if (action == null) + throw new NullPointerException(); + int mc = modCount; + for (LinkedHashMap.Entry e = head; e != null; e = e.after) + action.accept(e.key, e.value); + if (modCount != mc) + throw new ConcurrentModificationException(); + } + + public void replaceAll(BiFunction function) { + if (function == null) + throw new NullPointerException(); + int mc = modCount; + for (LinkedHashMap.Entry e = head; e != null; e = e.after) + e.value = function.apply(e.key, e.value); + if (modCount != mc) + throw new ConcurrentModificationException(); + } + + // Iterators + + abstract class LinkedHashIterator { + LinkedHashMap.Entry next; + LinkedHashMap.Entry current; + int expectedModCount; + + LinkedHashIterator() { + next = head; + expectedModCount = modCount; + current = null; + } + + public final boolean hasNext() { + return next != null; + } + + final LinkedHashMap.Entry nextNode() { + LinkedHashMap.Entry e = next; + if (modCount != expectedModCount) + throw new ConcurrentModificationException(); + if (e == null) + throw new NoSuchElementException(); + current = e; + next = e.after; + return e; + } + + public final void remove() { + Node p = current; + if (p == null) + throw new IllegalStateException(); + if (modCount != expectedModCount) + throw new ConcurrentModificationException(); + current = null; + removeNode(p.hash, p.key, null, false, false); + expectedModCount = modCount; + } + } + + final class LinkedKeyIterator extends LinkedHashIterator + implements Iterator { + public final K next() { return nextNode().getKey(); } + } + + final class LinkedValueIterator extends LinkedHashIterator + implements Iterator { + public final V next() { return nextNode().value; } + } + + final class LinkedEntryIterator extends LinkedHashIterator + implements Iterator> { + public final Map.Entry next() { return nextNode(); } + } + + +} -- 2.22.0