HashMap源码 详细解析
来源:互联网 发布:在淘宝复制的链接在哪 编辑:程序博客网 时间:2024/05/22 04:43
/* * @(#)HashMap.java1.73 07/03/13 * * Copyright 2006 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */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 * @version 1.73, 03/13/07 * @see Object#hashCode() * @see Collection * @see Map * @see TreeMap * @see Hashtable * @since 1.2 *//*** HashMap这个集合花了几天,看完了其实也没有什么难的啊,认真阅读,多读源代码,一步一个脚印,修炼成大牛 第一变过完了HashMap,还要多看几遍,我相信每一遍的效果都会不一样的,这个代码是java官方写的代码,有很多优点,仔细阅读,从中吸取更多的营养**/public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable{ /** * The default initial capacity - MUST be a power of two. */ //hash表默认的初始化容量,大小为16 static final int DEFAULT_INITIAL_CAPACITY = 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. */ //hash表的最大容量为,2^30 static final int MAXIMUM_CAPACITY = 1 << 30; /** * The load factor used when none specified in constructor. */ //装载因子默认为,0.75即:hash表中如果映射到表中的元素个数超过0.75*16=12个 //(这个里面的个数,指的是数组中拉链的个数,就是链表中有一个元素也算一个),则会扩容,这样做法是避免发生大量的元素堆积 static final float DEFAULT_LOAD_FACTOR = 0.75f; /** * The table, resized as necessary. Length MUST Always be a power of two. */ //hash表存的是Entry对象,Entry里面封装的有key 和value ,table 就是定义的Hash表 transient Entry[] table; /** * The number of key-value mappings contained in this map. */ //就是hash表中存储总共的元素个数,就是Entry对象的个数 transient int size; /** * The next size value at which to resize (capacity * load factor). * @serial */ //就是Hash表中能存储的最大链表个数,表的大小*装载因子, 如果超过这个值,hash表就必须扩容 int threshold; /** * The load factor for the hash table. * * @serial */ //装载因子的大小 final float loadFactor; /** * 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修饰后,就不需要序列化了,序列化的时候就不包含改属性了 transient volatile int modCount; /** * Constructs an empty <tt>HashMap</tt> 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 */ //Hash表的第一个构造方法,第一个参数初始化的容量,第二个参数是装载因子的大小 public HashMap(int initialCapacity, float loadFactor) {//如果Hash表初始容量<0 则抛出非法的初始化容量 if (initialCapacity < 0) throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);//如果初始化容量大于最大容量(2^30)则 初始化容量默认为最大容量(2^30),就是即使你设置的初始容量超过2^30,但是你的初始容量依然为2^30 if (initialCapacity > MAXIMUM_CAPACITY) initialCapacity = MAXIMUM_CAPACITY;//如果装载因子小于等于0,Float.isNan()(?) 将会抛出 非法的初始化装载因子 if (loadFactor <= 0 || Float.isNaN(loadFactor)) throw new IllegalArgumentException("Illegal load factor: " + loadFactor); // Find a power of 2 >= initialCapacity//我们设置的初始化容量,如果是2的次方,我们通过这循环,自动调整为大于设置这个初始化容量的第一个2的次方//(注:加入我的初始容量是9,那么我的初始容量为16,我的初始容量设置为10,11,12,13,14,15 ,则我的初始容量都转换为16) int capacity = 1; while (capacity < initialCapacity) capacity <<= 1; //将装载因子赋值为0.75f this.loadFactor = loadFactor;//赋值hash表能够存储的拉链个数 threshold = (int)(capacity * loadFactor);//hash表的大小 table = new Entry[capacity];//然后调用init方法,其实这个init方法什么都没有实现,我们自己可以实现的 init(); } /** * Constructs an empty <tt>HashMap</tt> 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. */ //第二个构造方法,只有一个参数是初始化容量,装载因子默认为0.75 //然后调用第二个构造方法,默认的装载因子为0.75 public HashMap(int initialCapacity) { this(initialCapacity, DEFAULT_LOAD_FACTOR); } /** * Constructs an empty <tt>HashMap</tt> with the default initial capacity * (16) and the default load factor (0.75). */ //第三个构造方法,空构造,hash默认大小为16,装载因子为0.75 public HashMap() { this.loadFactor = DEFAULT_LOAD_FACTOR; threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR); table = new Entry[DEFAULT_INITIAL_CAPACITY];//调用初始化方法,这个方法是空方法 init(); } /** * Constructs a new <tt>HashMap</tt> with the same mappings as the * specified <tt>Map</tt>. The <tt>HashMap</tt> is created with * default load factor (0.75) and an initial capacity sufficient to * hold the mappings in the specified <tt>Map</tt>. * * @param m the map whose mappings are to be placed in this map * @throws NullPointerException if the specified map is null */ //第四个构造方法,还是调用带两个参数的构造方法 public HashMap(Map<? extends K, ? extends V> m) { this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1, DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);//这个方法 不懂啊 putAllForCreate(m); } // internal utilities /** * Initialization hook for subclasses. This method is called * in all constructors and pseudo-constructors (clone, readObject) * after HashMap has been initialized but before any entries have * been inserted. (In the absence of this method, readObject would * require explicit knowledge of subclasses.) */ void init() { } /** * Applies a supplemental hash function to a given hashCode, which * defends against poor quality hash functions. This is critical * because HashMap uses power-of-two length hash tables, that * otherwise encounter collisions for hashCodes that do not differ * in lower bits. Note: Null keys always map to hash 0, thus index 0. */ //这个函数,是用来计算hash值的 传过来的是key.hashCode(); 计算key的hash值,然后映射到hash表中 key.hashCode() & length(table)-1 static int hash(int h) { // This function ensures that hashCodes that differ only by // constant multiples at each bit position have a bounded // number of collisions (approximately 8 at default load factor). h ^= (h >>> 20) ^ (h >>> 12); return h ^ (h >>> 7) ^ (h >>> 4); } /** * Returns index for hash code h. */ //通过key计算key映射到hash表的那个位置,然后把Entry<key,value>这个对象存入到hash表中,如果hash表的该位置有元素 //则存储这个位置链表的最前面,即使链头 static int indexFor(int h, int length) { return h & (length-1); //注意这个length-1 也是很有讲究的, 0 到length-1 表的索性是从0开始到length-1结束的 一定要注意了 } /** * Returns the number of key-value mappings in this map. * * @return the number of key-value mappings in this map */ //hash表中的存入的Entry<Key,Value> 对象的总个数. public int size() { return size; } /** * Returns <tt>true</tt> if this map contains no key-value mappings. * * @return <tt>true</tt> if this map contains no key-value mappings */ //判断hash表是否为空 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. * * <p>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.) * * <p>A return value of {@code null} does not <i>necessarily</i> * 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 (key == null) return getForNullKey(); int hash = hash(key.hashCode()); for (Entry<K,V> e = table[indexFor(hash, table.length)]; e != null; e = e.next) { Object k; if (e.hash == hash && ((k = e.key) == key || key.equals(k))) return e.value; } return null; } /** * Offloaded version of get() to look up null keys. Null keys map * to index 0. This null case is split out into separate methods * for the sake of performance in the two most commonly used * operations (get and put), but incorporated with conditionals in * others. */ private V getForNullKey() { for (Entry<K,V> e = table[0]; e != null; e = e.next) { if (e.key == null) return e.value; } return null; } /** * Returns <tt>true</tt> if this map contains a mapping for the * specified key. * * @param key The key whose presence in this map is to be tested * @return <tt>true</tt> if this map contains a mapping for the specified * key. */ public boolean containsKey(Object key) { return getEntry(key) != null; } /** * Returns the entry associated with the specified key in the * HashMap. Returns null if the HashMap contains no mapping * for the key. */ final Entry<K,V> getEntry(Object key) { int hash = (key == null) ? 0 : hash(key.hashCode()); for (Entry<K,V> e = table[indexFor(hash, table.length)]; e != null; e = e.next) { Object k; if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) return e; } return 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 <tt>key</tt>, or * <tt>null</tt> if there was no mapping for <tt>key</tt>. * (A <tt>null</tt> return can also indicate that the map * previously associated <tt>null</tt> with <tt>key</tt>.) */ //注意这个方法是hash表核心 元素是怎样放入hash表中去的 //是通过key 来找到Entry对象存入在hash表中的具体位置 //首先通过key 得到key.hashCode(), 然后将key.hashCode()传入hash(int key )得到hash值(从这一步我们可以看出把key的hash值进行了二次处理) //然后,通过hash(key.hashCode())得到hash值:h , h&length(table)-1 得到在表中的索引,从而就找到了存入在表中的位置 //最后如果这个位置为空,则将数据存入,如果不为空,则判断这个链表中的元素(Entry对象)是否与这个要存入的key的hash值相同,且key的内容相同,则认为存入的统一Entry<Key,Value> //则将前一个覆盖,并把覆盖 的Entry<Key,Value>中value值返回 public V put(K key, V value) {//如果传入的key为null,则将key封装为一个Entry<Key,Value>对象存入hash表中的第一个位置 if (key == null) return putForNullKey(value);//如果key值不为空,则得到key所映射的hash值 int hash = hash(key.hashCode());//通过hash值得到key映射在hash表中的位置 int i = indexFor(hash, table.length);//这个for很重要 找到key映射到hash表的位置后,将key和value封装成一个Entry<Key,Value> 对象。 //这个Entry对象中的属性有,key,value,通过key得到的hash值,和指向自己本身的一个引用next for (Entry<K,V> e = table[i]; e != null; e = e.next) { Object k;//这个if里面的条件判断,是这个hash表的核心很重要的。必须的深入的理解:1,首先我new出来的对象,把同一个对象往hashmap里面存,那么hash值一定相等// 那么key值必相等,如以同一对象往hash表里放,则一定符合条件,进入if。 将原来key对应的value给覆盖了,返回原value值,放入新value值。//第二问题:如果我们new出了两个对象 ,这两个对象,这两个对象完全一样,怎么办啊, 我们有需求就是两个内容相同的对象我们默认为一个key的 ,这个需求怎么办?怎么解决呢?//第二个问题,解决办法 是我们必须从写key的hashCode()和equals的方法,这样才可以的,如果不重写 key的hashCode和equals方法,他会调用父类的//即Object的hashCode()和equals() Object的hashCode()返回的这个对象在堆内存中的首地址,而equals是比较 两个对象的地址//那么如果不重写hashCode(),则两个不同对象的内存地址肯定不会相同,则hash值肯定不会相同,如果重写了hashCode()方法,重写的hashCode()的功能是,内容相同的key即使不是一个对象,//则hashCode()获得值是相等的,这个hashCode()是根据内容获得的,如果key的内容相同,则内容相同的hashCode()相等.//第三个问题?必须重写eqauls方法 ,用来比较两个对象的key的内容相同, 这样如果两个对象的内容相同 ,则hashCode()值和equals()比较为真,则两个内容相同的对象会被新的覆盖 if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { V oldValue = e.value; e.value = value; e.recordAccess(this); return oldValue; } } modCount++;//如果要存入hash变的key和拉链中的存入的key都不相等,则将key,value封装为Entry<Key,Value>对象存入拉链的头部.//注意在这个方法里面进行扩容 addEntry(hash, key, value, i);//这个返回null也很有讲究,判断一个key在拉链中是否有重复,可以用这null来判断,如果返回的null则key在拉链中是第一次出现,如果不空,则不是第一次进入. return null; } /** * Offloaded version of put for null keys */ //该方法的作用是 如果key=null ,则将进行单独处理,将这个空加入hash表的第一个位置,即table[0]这个位置 private V putForNullKey(V value) { for (Entry<K,V> e = table[0]; e != null; e = e.next) { if (e.key == null) { V oldValue = e.value; e.value = value; e.recordAccess(this); return oldValue; } } modCount++;//将为null的key封装为 Entry<Null,Value>对象 存入hash表 其中Entry对象中的hash值为0 addEntry(0, null, value, 0); return null; } /** * This method is used instead of put by constructors and * pseudoconstructors (clone, readObject). It does not resize the table, * check for comodification, etc. It calls createEntry rather than * addEntry. */ //这个方法是私有方法,外部无法调用,和put(Key key ,Value value)的主要区别是: //遇到重复的key时,put方法将其覆盖,返回被覆盖的value值,但是putForCreate方法直接覆盖原来的value,不返回原来的value值 private void putForCreate(K key, V value) { int hash = (key == null) ? 0 : hash(key.hashCode()); int i = indexFor(hash, table.length); /** * Look for preexisting entry for key. This will never happen for * clone or deserialize. It will only happen for construction if the * input Map is a sorted map whose ordering is inconsistent w/ equals. */ for (Entry<K,V> e = table[i]; e != null; e = e.next) { Object k; if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) { e.value = value; return; } } createEntry(hash, key, value, i); } //这个是私有的方法,泛型必须要深入的理解,这个传递的是一个泛型类型 private void putAllForCreate(Map<? extends K, ? extends V> m) {//这个是泛型里面又嵌套了泛型,认真的琢磨 for (Iterator<? extends Map.Entry<? extends K, ? extends V>> i = m.entrySet().iterator(); i.hasNext(); ) { Map.Entry<? extends K, ? extends V> e = i.next(); putForCreate(e.getKey(), e.getValue()); } } /** * Rehashes the contents of this map into a new array with a * larger capacity. This method is called automatically when the * number of keys in this map reaches its threshold. * * If current capacity is MAXIMUM_CAPACITY, this method does not * resize the map, but sets threshold to Integer.MAX_VALUE. * This has the effect of preventing future calls. * * @param newCapacity the new capacity, MUST be a power of two; * must be greater than current capacity unless current * capacity is MAXIMUM_CAPACITY (in which case value * is irrelevant). */ //这个方法是进行扩容的,但是hash表的 table.length*装在因子, 表中无位置的时候,需要对hash表进行扩容。 void resize(int newCapacity) { Entry[] oldTable = table;//首先得到老的hash表 int oldCapacity = oldTable.length; //然后得到老的hash表的长度,如果老的hash表以及达到最大值时:2^30 则无法进行扩容,不进行扩容。 if (oldCapacity == MAXIMUM_CAPACITY) { threshold = Integer.MAX_VALUE; return; } Entry[] newTable = new Entry[newCapacity]; //设置扩容后的hash表容量,在这里其实是重新建立一个hash表而已//这个函数的作用是将扩展前表的元素移动到新扩展的表里面来,很耗时的。 transfer(newTable); table = newTable; threshold = (int)(newCapacity * loadFactor); //改变表中能够容纳拉链的条数。 } /** * Transfers all entries from current table to newTable. */ //这个函数的主要作用是进行扩容,看看他是怎样扩容的 void transfer(Entry[] newTable) {//首先得到扩容前的表 Entry[] src = table;//得到新表的大小 int newCapacity = newTable.length;//下面这个循环的作用是来进行扩容的//用来循环扩容前表的内容 for (int j = 0; j < src.length; j++) { Entry<K,V> e = src[j]; if (e != null) { src[j] = null; do {//下面几行代码的作用是很关键的,看看sun程序员的代码风格。//取出表中该位置的下一个元素 Entry<K,V> next = e.next;//然后取出hash值,根据hash值计算在扩容后表中的位置。 int i = indexFor(e.hash, newCapacity);//将新表中的元素连接到e后面 e.next = newTable[i];//将元素放入扩容后的表中 newTable[i] = e;//将下一个元素赋值给e e = next; } while (e != null); } } } /** * 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<? extends K, ? extends V> m) { int numKeysToBeAdded = m.size(); if (numKeysToBeAdded == 0) return; /* * Expand the map if the map if the number of mappings to be added * is greater than or equal to threshold. This is conservative; the * obvious condition is (m.size() + size) >= threshold, but this * condition could result in a map with twice the appropriate capacity, * if the keys to be added overlap with the keys already in this map. * By using the conservative calculation, we subject ourself * to at most one extra resize. */ if (numKeysToBeAdded > threshold) { int targetCapacity = (int)(numKeysToBeAdded / loadFactor + 1); if (targetCapacity > MAXIMUM_CAPACITY) targetCapacity = MAXIMUM_CAPACITY; int newCapacity = table.length; while (newCapacity < targetCapacity) newCapacity <<= 1; if (newCapacity > table.length) resize(newCapacity); } for (Iterator<? extends Map.Entry<? extends K, ? extends V>> i = m.entrySet().iterator(); i.hasNext(); ) { Map.Entry<? extends K, ? extends V> e = i.next(); put(e.getKey(), e.getValue()); } } /** * 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 <tt>key</tt>, or * <tt>null</tt> if there was no mapping for <tt>key</tt>. * (A <tt>null</tt> return can also indicate that the map * previously associated <tt>null</tt> with <tt>key</tt>.) */ //这个函数的作用是通过key删除hash表中的Entry<K,V>对象,然后返回被删除元素的value public V remove(Object key) { Entry<K,V> e = removeEntryForKey(key); return (e == null ? null : e.value); } /** * Removes and returns the entry associated with the specified key * in the HashMap. Returns null if the HashMap contains no mapping * for this key. */ //final修饰的方法不能够被重写 //这个方法的作用是,通过key删除hash表中的元素,然后返回被删除元素的value final Entry<K,V> removeEntryForKey(Object key) {//通过key.hashCode()得到hash值,然后通过hash值在表中找到元素要存储的位置。 int hash = (key == null) ? 0 : hash(key.hashCode()); int i = indexFor(hash, table.length);//得到位置后,取出hash表中的值 Entry<K,V> prev = table[i];//将hash表中的值赋值给e Entry<K,V> e = prev; //对这个位置进行循环,取出所有的Entry<K,V>对象值。 while (e != null) {//首先得到要删除元素的指向下一个元素的引用 Entry<K,V> next = e.next; Object k; if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) { modCount++; size--;//hash表中的第一个元素就是要移除的值,则直接将下一个相邻的元素赋值到表中的链头 if (prev == e) table[i] = next; else prev.next = next; e.recordRemoval(this); return e; }//prev保存的当前元素的上一个Entry<K,V>对象 prev = e;//e保存的是当前对象。 e = next; } return e; } /** * Special version of remove for EntrySet. */ final Entry<K,V> removeMapping(Object o) { if (!(o instanceof Map.Entry)) return null; Map.Entry<K,V> entry = (Map.Entry<K,V>) o; Object key = entry.getKey(); int hash = (key == null) ? 0 : hash(key.hashCode()); int i = indexFor(hash, table.length); Entry<K,V> prev = table[i]; Entry<K,V> e = prev; while (e != null) { Entry<K,V> next = e.next; if (e.hash == hash && e.equals(entry)) { modCount++; size--; if (prev == e) table[i] = next; else prev.next = next; e.recordRemoval(this); return e; } prev = e; e = next; } return e; } /** * Removes all of the mappings from this map. * The map will be empty after this call returns. */ //这个函数的作用是清除hash表中所有元素的值,就是清空hash表 public void clear() { modCount++;//这个hash表table 是个全局变量 Entry[] tab = table; for (int i = 0; i < tab.length; i++) tab[i] = null; size = 0; } /** * Returns <tt>true</tt> 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 <tt>true</tt> if this map maps one or more keys to the * specified value */ //用于判断Hash表中是否包含指定的value,如果包含则返回true,否则返回false public boolean containsValue(Object value) {//如果value为null则单独开个函数进行判断if (value == null) return containsNullValue();Entry[] tab = table; for (int i = 0; i < tab.length ; i++) for (Entry e = tab[i] ; e != null ; e = e.next) if (value.equals(e.value)) return true;return false; } /** * Special-case code for containsValue with null argument */ //value值为Null的情况下,为什么要单独开函数判断啊,sun公司写的代码真是耐人寻味啊 private boolean containsNullValue() {Entry[] tab = table; for (int i = 0; i < tab.length ; i++) for (Entry e = tab[i] ; e != null ; e = e.next) if (e.value == null) return true;return false; } /** * Returns a shallow copy of this <tt>HashMap</tt> instance: the keys and * values themselves are not cloned. * * @return a shallow copy of this map */ public Object clone() { HashMap<K,V> result = null;try { result = (HashMap<K,V>)super.clone();} catch (CloneNotSupportedException e) { // assert false;} result.table = new Entry[table.length]; result.entrySet = null; result.modCount = 0; result.size = 0; result.init(); result.putAllForCreate(this); return result; }//静态内部类,内部类可以操作外部类的所有变量,sun公司为什么要用静态内部类 static class Entry<K,V> implements Map.Entry<K,V> {//key用final修饰是不可变的 final K key; V value; Entry<K,V> next;//hash值也是不可变的 final int hash; /** * Creates new entry. */ //构造方法,创建这个Entry<K,V>需要传递hash值,key,value,下一个Entry<K,V>对象的引用 Entry(int h, K k, V v, Entry<K,V> n) { value = v; next = n; key = k; hash = h; } //final修饰的方法不能够被重写//得到key public final K getKey() { return key; } public final V getValue() { return value; } public final V setValue(V newValue) { V oldValue = value; value = newValue; return oldValue; } //重写了equals和hashCode方法//equals比较的是key和value的内容相同则就认为是同一个Entry对象 public final boolean equals(Object o) { if (!(o instanceof Map.Entry)) return false; Map.Entry e = (Map.Entry)o; Object k1 = getKey(); Object k2 = e.getKey(); if (k1 == k2 || (k1 != null && k1.equals(k2))) { Object v1 = getValue(); Object v2 = e.getValue(); if (v1 == v2 || (v1 != null && v1.equals(v2))) return true; } return false; } //重写hashCode()方法 public final int hashCode() { return (key==null ? 0 : key.hashCode()) ^ (value==null ? 0 : value.hashCode()); } public final String toString() { return getKey() + "=" + getValue(); } /** * This method is invoked whenever the value in an entry is * overwritten by an invocation of put(k,v) for a key k that's already * in the HashMap. */ void recordAccess(HashMap<K,V> m) { } /** * This method is invoked whenever the entry is * removed from the table. */ void recordRemoval(HashMap<K,V> m) { } } /** * Adds a new entry with the specified key, value and hash code to * the specified bucket. It is the responsibility of this * method to resize the table if appropriate. * * Subclass overrides this to alter the behavior of put method. */ //addEntry的作用是将key和value封装为Entry对象加入到hash表中去。 void addEntry(int hash, K key, V value, int bucketIndex) {Entry<K,V> e = table[bucketIndex]; table[bucketIndex] = new Entry<K,V>(hash, key, value, e);//如果超出了容量,则需要进行扩容 if (size++ >= threshold) resize(2 * table.length); } /** * Like addEntry except that this version is used when creating entries * as part of Map construction or "pseudo-construction" (cloning, * deserialization). This version needn't worry about resizing the table. * * Subclass overrides this to alter the behavior of HashMap(Map), * clone, and readObject. */ //和addEntry这个方法一样,主要区别就是这个方法没有判断扩容,不管 hash表是否达到最大的threshold,都将Entry对象加入到hash表中去 void createEntry(int hash, K key, V value, int bucketIndex) {Entry<K,V> e = table[bucketIndex]; table[bucketIndex] = new Entry<K,V>(hash, key, value, e); size++; }//这个抽象类写 在这里的目的是什么,完全用不到啊??????sun公司到低是什么目的啊?????//我明白了,这个是给自己调用的,主要是关于hashMap迭代用的 private abstract class HashIterator<E> implements Iterator<E> { Entry<K,V> next;// next entry to return int expectedModCount;// For fast-fail int index;// current slot Entry<K,V> current;// current entry// HashIterator() { expectedModCount = modCount; if (size > 0) { // advance to first entry Entry[] t = table;//在hash表中找到第一个非空的元素 while (index < t.length && (next = t[index++]) == null) ; } } public final boolean hasNext() { return next != null; } final Entry<K,V> nextEntry() { if (modCount != expectedModCount) throw new ConcurrentModificationException(); Entry<K,V> e = next; if (e == null) throw new NoSuchElementException(); //如果hash表中只有一个元素,继续遍历找到hash表中第二个非空的元素 if ((next = e.next) == null) { Entry[] t = table; while (index < t.length && (next = t[index++]) == null) ; } current = e; return e; } //在hash表移除当前遍历的元素 public void remove() { if (current == null) throw new IllegalStateException(); if (modCount != expectedModCount) throw new ConcurrentModificationException(); Object k = current.key; current = null; HashMap.this.removeEntryForKey(k); expectedModCount = modCount; } } //这一步为什么用nextEntry()什么意思啊???真是搞不明白啊//难道一个类不类,可以调用另外一个类不类的方法吗?不是很明白呀//回去代码实战一把,如果说,一个内部类和调用另外一个内部类的方法,这个我可以理解了//下面这三个方法:KeyIterator 、ValueIterator、EntryIterator使用的很巧妙啊,下次自己造个集合需要写迭代器和模仿hashMap来写 private final class ValueIterator extends HashIterator<V> { public V next() { return nextEntry().value; } } private final class KeyIterator extends HashIterator<K> { public K next() { return nextEntry().getKey(); } } private final class EntryIterator extends HashIterator<Map.Entry<K,V>> { public Map.Entry<K,V> next() { return nextEntry(); } } // Subclass overrides these to alter behavior of views' iterator() method//这三个方法实现的也很好,堪称完美啊! HashMap内部写的迭代器太完美了啊 Iterator<K> newKeyIterator() { return new KeyIterator(); } Iterator<V> newValueIterator() { return new ValueIterator(); } Iterator<Map.Entry<K,V>> newEntryIterator() { return new EntryIterator(); } // Views private transient Set<Map.Entry<K,V>> entrySet = null; /** * 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 <tt>remove</tt> operation), the results of * the iteration are undefined. The set supports element removal, * which removes the corresponding mapping from the map, via the * <tt>Iterator.remove</tt>, <tt>Set.remove</tt>, * <tt>removeAll</tt>, <tt>retainAll</tt>, and <tt>clear</tt> * operations. It does not support the <tt>add</tt> or <tt>addAll</tt> * operations. */ //将所有key封装到Set集合中,这里面得到Set集合,也是在hashmap内部实现的,KeySet继承AbstractSet<K> public Set<K> keySet() { Set<K> ks = keySet; return (ks != null ? ks : (keySet = new KeySet())); } //其实得到KeySet也没什么大不了的哈,源代码实现很简单的 private final class KeySet extends AbstractSet<K> {//得到的迭代器,是hashMap的迭代器. public Iterator<K> iterator() { return newKeyIterator(); } public int size() { return size; } public boolean contains(Object o) { return containsKey(o); } public boolean remove(Object o) {//这中写法,很奇特,以前没有用这种方式写过啊 return HashMap.this.removeEntryForKey(o) != null; } public void clear() { HashMap.this.clear(); } } /** * 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 <tt>remove</tt> operation), * the results of the iteration are undefined. The collection * supports element removal, which removes the corresponding * mapping from the map, via the <tt>Iterator.remove</tt>, * <tt>Collection.remove</tt>, <tt>removeAll</tt>, * <tt>retainAll</tt> and <tt>clear</tt> operations. It does not * support the <tt>add</tt> or <tt>addAll</tt> operations. */ //得到Collection集合,这个集合中包含newValueIterator迭代器 public Collection<V> values() { Collection<V> vs = values; return (vs != null ? vs : (values = new Values())); } private final class Values extends AbstractCollection<V> { public Iterator<V> iterator() { return newValueIterator(); } public int size() { return size; } public boolean contains(Object o) { return containsValue(o); } public void clear() { HashMap.this.clear(); } } /** * 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 <tt>remove</tt> operation, or through the * <tt>setValue</tt> 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 <tt>Iterator.remove</tt>, * <tt>Set.remove</tt>, <tt>removeAll</tt>, <tt>retainAll</tt> and * <tt>clear</tt> operations. It does not support the * <tt>add</tt> or <tt>addAll</tt> operations. * * @return a set view of the mappings contained in this map */ //提供给外部调用,得到一个Set集合,这个Set集合里面存放的都是Entry对象 public Set<Map.Entry<K,V>> entrySet() {return entrySet0(); } private Set<Map.Entry<K,V>> entrySet0() { Set<Map.Entry<K,V>> es = entrySet; return es != null ? es : (entrySet = new EntrySet()); } //EntrySet实现也很简单,首先返回个遍历Entry的迭代器,以及判断集合中是否包含指定的对象 private final class EntrySet extends AbstractSet<Map.Entry<K,V>> { public Iterator<Map.Entry<K,V>> iterator() { return newEntryIterator(); } public boolean contains(Object o) { if (!(o instanceof Map.Entry)) return false; Map.Entry<K,V> e = (Map.Entry<K,V>) o; Entry<K,V> candidate = getEntry(e.getKey()); return candidate != null && candidate.equals(e); } public boolean remove(Object o) { return removeMapping(o) != null; } public int size() { return size; } public void clear() { HashMap.this.clear(); } } /** * Save the state of the <tt>HashMap</tt> instance to a stream (i.e., * serialize it). * * @serialData The <i>capacity</i> of the HashMap (the length of the * bucket array) is emitted (int), followed by the * <i>size</i> (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. */ private void writeObject(java.io.ObjectOutputStream s) throws IOException {Iterator<Map.Entry<K,V>> i = (size > 0) ? entrySet0().iterator() : null;// Write out the threshold, loadfactor, and any hidden stuffs.defaultWriteObject();// Write out number of bucketss.writeInt(table.length);// Write out size (number of Mappings)s.writeInt(size); // Write out keys and values (alternating)if (i != null) { while (i.hasNext()) {Map.Entry<K,V> e = i.next();s.writeObject(e.getKey());s.writeObject(e.getValue()); } } } private static final long serialVersionUID = 362498820763181265L; /** * Reconstitute the <tt>HashMap</tt> instance from a stream (i.e., * deserialize it). */ private void readObject(java.io.ObjectInputStream s) throws IOException, ClassNotFoundException {// Read in the threshold, loadfactor, and any hidden stuffs.defaultReadObject();// Read in number of buckets and allocate the bucket array;int numBuckets = s.readInt();table = new Entry[numBuckets]; init(); // Give subclass a chance to do its thing.// Read in size (number of Mappings)int size = s.readInt();// Read the keys and values, and put the mappings in the HashMapfor (int i=0; i<size; i++) { K key = (K) s.readObject(); V value = (V) s.readObject(); putForCreate(key, value);} } // These methods are used when serializing HashSets int capacity() { return table.length; } float loadFactor() { return loadFactor; }}
阅读全文
0 0
- HashMap源码 详细解析
- HashMap详细介绍(源码解析)和使用示例
- HashMap源码详细解释
- Android源码解析 -- HashMap
- HashMap源码解析
- HashMap源码解析
- HashMap源码解析
- HashMap源码解析
- HashMap源码解析
- HashMap源码解析
- Java HashMap 源码解析
- Java HashMap 源码解析
- Java HashMap 源码解析
- 源码解析HashMap
- Java:HashMap源码解析
- HashMap 源码解析
- HashMap源码解析
- HashMap 源码解析
- 设计模式(Design Patterns)
- httpclient详解
- HTML5语法
- RocketMQ(二)
- Python2048小游戏demo
- HashMap源码 详细解析
- Nginx 多域名配置
- vue axios
- PAT题解——1102. Invert a Binary Tree (25)
- 在Javascript中的相关数组操作(2)--初学者的小笔记
- c++中的this 指针
- Spring中 @Autowired标签与 @Resource标签 的区别
- 杜教的板子(递推求值)
- (原创题) 友好素数对 (素数打表+预处理+二分)