JDK源代码学习系列一---java.util（1）

//section 0 Entry的定义
        final K key;
        V value;
        Entry<K,V> next;
        final int hash; <--Entry的hash永不会变
//section 1
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { <--用entry的hash在比较
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }

        modCount++;
        addEntry(hash, key, value, i); <--在hash位置的链表中找不到entry时，添加
//section 2
    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); <-- 传入链表head
        if (size++ >= threshold)
            resize(2 * table.length);
    }
//section 3
        Entry(int h, K k, V v, Entry<K,V> n) {
            value = v;
            next = n; <-- 把当前entry设为head，把原head设为head->next
            key = k;
            hash = h;
        }

int hash = hash(key.hashCode());
//此处省略若干
if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
                return e.value;

import java.util.HashMap;
import java.util.Map;


public class TestMap {
	public static void main(String[] args) {
		TestBean bean1 = new TestBean();
		bean1.hashCode = 1;
		
		Map m = new HashMap();
		m.put(bean1, bean1);
		int j =0,total = 20000;//CAPACITY初始为16,20000个key肯定有落在同一个bucket上的。
		for(int i=0;i<total;i++) {
			bean1.hashCode = i;
			if(m.get(bean1)==bean1) {
				j++;
			}
		}
		System.out.println(j);
		System.out.println((float)j/total);
	}
}

class TestBean {
	static int count = 0;
	public int hashCode = 0;
	
	public int hashCode() {
		return hashCode;
	}
	public String toString() {
		return "TestBean"+count+"\r\n";
	}
}

emsn 写道

youjianbo_han_87 写道

1. 先鄙视下论坛规则，我好久没上了，竟然要回答什么尿尿问题。
2. 贴出 JDK1.5_update_22中 HashMap的 get方法的源码：
/**
     * Returns the value to which the specified key is mapped in this identity
     * hash map, or <tt>null</tt> if the map contains no mapping for this key.
     * A return value of <tt>null</tt> does not <i>necessarily</i> indicate
     * that the map contains no mapping for the key; it is also possible that
     * the map explicitly maps the key to <tt>null</tt>. The
     * <tt>containsKey</tt> method may be used to distinguish these two cases.
     *
     * @param   key the key whose associated value is to be returned.
     * @return  the value to which this map maps the specified key, or
     *          <tt>null</tt> if the map contains no mapping for this key.
     * @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;
    }

通过代码可以得知，如果一个Key对应2个Value，看到注释的部分吗？ 他按顺序找到后，直接就 Return a.value了。而不会循环Person2.

源代码一贴，神秘感就没了,哈哈

源码就是硬道理，不过[youjianbo_han_87]可能理解错了楼主的意图了，楼主是在put后，修改了key的关键域字段，人为改变了对象的hashCode和equals的行为（相对put时的状态），给我们设计提了个醒哦：key尽量使用状态不可变的类（偶一般都是Long、Integer、String做key）

 

这是个坏的例子：既然person使用id做为关键域，逻辑上关键域就不应当再修改了，否则程序或代码行为不可预知。

呵呵，以前项目中用map做缓存，都是用的String做key，就是看中了String不可变，建议缓存key对象中这样的关键域做成了final，呵呵调用的想是坏都不行（也遇到过和楼主一样的情形，调用者重用了返回的key，搞三搞四，调试了蛮久才发现，后来基本上返回的尽量new或者clone一个对象）

map只认put时的key状态，put后对key修改了关键域->改变了hashCode和equals行为，当然再次get时会按照新的hashCode和equals来定位Entry了

 

 

 

很有道理，从设计角度讲这有不合理的地方，此处仅为讨论问题而故而为之，不推荐像我这么做