mirror of
https://github.com/CyC2018/CS-Notes.git
synced 2026-03-13 09:50:42 +08:00
auto commit
This commit is contained in:
CyC2018
@@ -1,126 +1,6 @@
|
||||
/*
|
||||
* Copyright (c) 1997, 2010, 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.*;
|
||||
|
||||
/**
|
||||
* Hash table based implementation of the <tt>Map</tt> interface. This
|
||||
* implementation provides all of the optional map operations, and permits
|
||||
* <tt>null</tt> values and the <tt>null</tt> key. (The <tt>HashMap</tt>
|
||||
* class is roughly equivalent to <tt>Hashtable</tt>, 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.
|
||||
*
|
||||
* <p>This implementation provides constant-time performance for the basic
|
||||
* operations (<tt>get</tt> and <tt>put</tt>), assuming the hash function
|
||||
* disperses the elements properly among the buckets. Iteration over
|
||||
* collection views requires time proportional to the "capacity" of the
|
||||
* <tt>HashMap</tt> 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.
|
||||
*
|
||||
* <p>An instance of <tt>HashMap</tt> has two parameters that affect its
|
||||
* performance: <i>initial capacity</i> and <i>load factor</i>. The
|
||||
* <i>capacity</i> 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
|
||||
* <i>load factor</i> 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 <i>rehashed</i> (that is, internal data
|
||||
* structures are rebuilt) so that the hash table has approximately twice the
|
||||
* number of buckets.
|
||||
*
|
||||
* <p>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
|
||||
* <tt>HashMap</tt> class, including <tt>get</tt> and <tt>put</tt>). 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.
|
||||
*
|
||||
* <p>If many mappings are to be stored in a <tt>HashMap</tt> 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.
|
||||
*
|
||||
* <p><strong>Note that this implementation is not synchronized.</strong>
|
||||
* If multiple threads access a hash map concurrently, and at least one of
|
||||
* the threads modifies the map structurally, it <i>must</i> 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:<pre>
|
||||
* Map m = Collections.synchronizedMap(new HashMap(...));</pre>
|
||||
*
|
||||
* <p>The iterators returned by all of this class's "collection view methods"
|
||||
* are <i>fail-fast</i>: if the map is structurally modified at any time after
|
||||
* the iterator is created, in any way except through the iterator's own
|
||||
* <tt>remove</tt> 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.
|
||||
*
|
||||
* <p>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 <tt>ConcurrentModificationException</tt> on a best-effort basis.
|
||||
* Therefore, it would be wrong to write a program that depended on this
|
||||
* exception for its correctness: <i>the fail-fast behavior of iterators
|
||||
* should be used only to detect bugs.</i>
|
||||
*
|
||||
* <p>This class is a member of the
|
||||
* <a href="{@docRoot}/../technotes/guides/collections/index.html">
|
||||
* Java Collections Framework</a>.
|
||||
*
|
||||
* @param <K> the type of keys maintained by this map
|
||||
* @param <V> 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<K,V>
|
||||
extends AbstractMap<K,V>
|
||||
implements Map<K,V>, Cloneable, Serializable
|
||||
|
||||
Reference in New Issue
Block a user