澳门新浦京8455comJava HashMap工作原理及实现

澳门新浦京8455com 6

引言

HashMap在键值对存储中被经常使用,那么它到底是如何实现键值存储的呢?

很多刚学Java的同学们都知道HashMap,平常一般使用,可能并不知道它的工作原理,前段时间有为刚毕业的同事在使用HashMap的时候碰到了个问题找我,问题大概是这样的:

澳门新浦京8455com,JDK HashMap的实现原理分析

一 Entry

Entry是Map接口中的一个内部接口,它是实现键值对存储关键。在HashMap中,有Entry的实现类,叫做Entry。Entry类很简单,里面包含key,value,由外部引入的hash,还有指向下一个Entry对象的引用,和数据结构中学的链表中的note节点很类似。

Entry类的属性和构造函数:

final K key;
V value;
Entry<K,V> next;
int hash;
/**
 * Creates new entry.
 */
Entry(int h, K k, V v, Entry<K,V> n) {
    value = v;
    next = n;
    key = k;
    hash = h;
}
 Map map = new HashMap(); map.put(1l, "abc"); System.out.println(map.get; 

HashMap的数据结构

先来看看数组和链表数据结构的特点:

数组:存储区间连续,寻址容易,插入和删除困难

链表:存储区间离散,寻址困难,插入和删除简单

HashMap的出现就是将数组和链表的优点相结合。

澳门新浦京8455com 1

image

澳门新浦京8455com 2

image

我们发现哈希表是由数组+链表组成的。

二 HashMap的初始化

//HashMap构造方法
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;
    threshold = initialCapacity;
    init();
}

这是HashMap的构造函数之一,其他构造函数都引用这个构造函数进行初始化。参数InitialCapacity指的是HashMap中table数组最初的大小,参数loadFactory指的是HashMap可容纳键值对与数组长度的比值(举个例子:数组长度默认值为16,loadFactory默认值为0.75,如果HashMap中存储的键值对即Entry多于12,则会进行扩容,扩容后大小为当前数组长度的2倍)。在构造函数中不会对数组进行初始化,只有在put等操作方法内会进行判断是否要初始化或扩容。

明明有值啊,为什么是null呢?

一些重要的属性
    //最大容量
    static final int MAXIMUM_CAPACITY = 1 << 30;

    //可以看到,是存放Entry<k,v>元素的数组,名为table。
    transient Entry<K,V>[] table;

    //当table的占用超过这个值,就要扩容。
    int threshold;

    //负载因子  threshold = capacity*loadFactory
    final float loadFactor;

三 table数组

在HashMap中有一个概念叫做threshold(实际可容纳量),实际可容纳量指的是在HashMap中允许存在最多的Entry的个数,它是由HashMap中内置的数组table的长度*load
factory(负载因子)得来。其作用是保证HashMap的效率。

table数组是HashMap实现键值对存储的又一关键,具体键值对是怎么存的呢?请看下图

澳门新浦京8455com 3

如图中的[key,value]就是Entry对象来实现的,而table数组是用来存放Entry对象的。

//数组的初始化:
private static int roundUpToPowerOf2(int number) {
    return number >= MAXIMUM_CAPACITY
            ? MAXIMUM_CAPACITY
            : (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1;
}
private void inflateTable(int toSize) {
    // Find a power of 2 >= toSize
    int capacity = roundUpToPowerOf2(toSize);
    threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
    table = new Entry[capacity];
    initHashSeedAsNeeded(capacity);
}

在put等方法中发现数组未进行初始化时会调用InflateTable方法进行初始化,输入参数为初始设置的InitialCapacity,实际上他会调用roundUpToPowerOf2方法返回一个比初始容量大的最小的2的幂数(其中一个原因是在得到Entry所在数组位置时方便)。

下面我们一起来探讨一下HashMap的工作原理及实现,首先看个例子,带着问题去研究

数组的存储规则

那么如何确定数据存储在数组的哪个下标中呢?

一般根据
hash(key)&(len-1)来获得,如,数组长度为16,hash(key.hashCode())为2。我们做如下运算:

&:按位与操作,若对应的二进制位都为1,结果为1.

2 & (16-1)

2的二进制为: 0000 0010
15的二进制:   0000 1111
结果:        0000 0010 (转换成int值为2)

最后,该元素就存放在table[2]位置上。

四 put方法

public V put(K key, V value) {
    if (table == EMPTY_TABLE) {
        inflateTable(threshold);
    }
    if (key == null)
        return putForNullKey(value);
    int hash = hash(key);
    int i = indexFor(hash, table.length);
    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))) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }
    modCount++;
    addEntry(hash, key, value, i);
    return null;
}
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++;
    addEntry(0, null, value, 0);
    return null;
}
void addEntry(int hash, K key, V value, int bucketIndex) {
    if ((size >= threshold) && (null != table[bucketIndex])) {
        resize(2 * table.length);
        hash = (null != key) ? hash(key) : 0;
        bucketIndex = indexFor(hash, table.length);
    }
    createEntry(hash, key, value, bucketIndex);
}
void createEntry(int hash, K key, V value, int bucketIndex) {
    Entry<K,V> e = table[bucketIndex];
    table[bucketIndex] = new Entry<>(hash, key, value, e);
    size++;
}

在put方法中

  1. 首先会判断数组是否为空,如果为空会对数组进行初始化。

  2. 接下来判断key是否为null,如果为null就采用第二个方法对键值对进行put。

3.
接下来对key进行hash得到一个数值,再对这个数值进行处理(IndexFor方法)得到所在数组中的位置。

4.
接下来会遍历所在数组位置的链表,如果key的hash和传入key的hash相同且(key内存地址相等

equals方法相等),则意味着会更新在链表中的value值,并返回旧的value值。

  1. 如果上边的方法都没有奏效,则会调用第三个方法,创建一个新的Entry对象。

在putForNullKey方法中
,我们看到它是为了NULL值专门设置的,NULL值的hash始终为0,所以key为NULL的Entry对象肯定在数组的第0个位置。同样,如果找到则更新,没有找到则添加。

调用addEntry方法
意味着要往这个数组链表中添加一个Entry,所以会在最开始判断已经存在的Entry数量是否超过了实际可容纳量。如果超过了,则会调用resize方法将数组扩大两倍,注意在扩大之后会对已经存入的Entry进行重排,原因是当初存入时IndexFor方法与数组长度有关系。接着会调用第四个方法。

createEntry方法
很简单,就是将原本在数组中存放的链表头置入到新的Entry之后,将新的Entry放入数组中。从这里我们可以看出HashMap不保证顺序问题。

get方法和contains方法原理和put方法一致,即先通过对key的hash得到其value值所在的链表头在数组中的位置,再通过equals方法判断value是否存在。

public class TestMap { public static void main(String[] args) { Map<String, Integer> map = new HashMap<String, Integer>(); map.put; map.put("java", 1); map.put; map.put("python", 3); map.put; map.put("nodejs", 5); for(Entry<String, Integer> entry : map.entrySet { System.out.println(entry.getKey() + ": " + entry.getValue; } System.out.println("php".hashCode() == "c++".hashCode; }}
HashMap的基础存储结构

HashMap中有个静态内部类Entry,其属性有key,value,next,hash。key是键,value是值,next是指向下一个Entry元素的引用,hash是key.hashCode()的hash值。如下:

    static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> next;
        final int hash;
    }

五 其他

//hash方法
final int hash(Object k) {
    int h = hashSeed;
    if (0 != h && k instanceof String) {
        return sun.misc.Hashing.stringHash32((String) k);
    }
    h ^= k.hashCode();
    // 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);
}

hash方法中最终返回值与key的hashCode方法有关。

运行结果是:

HashMap的存取实现

总结

  1. 最终数组初始化的容量大小会是大于等于你传入初始容量的最小2的幂数。
  2. key为null或value为null能存入HashMap的原因是对null值会进行单独的操作。
  3. 在table数组中的链表中每个Entry的共同点是key的hash(key.hashCode)部分相同。
  4. 注意对key的hashCode和equals方法的重写当你想让两个key映射一个对象,因为判定key相等的条件是(hashCode相等+(内存相等
    或 equals相等))。
  5. 最早存入的键值对会在链表的末端。
  6. 当数组没有链表存在时,HashMap性能最好为O(1)。而最差为O(threshould)。
null: 0php: 4c++: 2java: 1nodejs: 5false
table初始大小

table的初始大小需要根据HashMap的构造函数来决定。

澳门新浦京8455com 420161001120548021.png

空参数构造函数
    /**
     * Constructs an empty <tt>HashMap</tt> with the default initial capacity
     * (16) and the default load factor (0.75).
     */
    public HashMap() {
        //负载因子
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        //阈值 当table的占用超过此值时就会扩容
        threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
        //给table的默认长度
        table = new Entry[DEFAULT_INITIAL_CAPACITY];
        init();
    }

英文注释已经说明了一切,table的默认长度为16,负载因子的默认值为0.75

当然也可以看看这些常量的值,如下:

    static final float DEFAULT_LOAD_FACTOR = 0.75f;
     static final int DEFAULT_INITIAL_CAPACITY = 16;

让我们来看一下 HashMap 中的几个参数的意义- loadFactor : 负载因子
默认0.75initialCapacity : 初始化容量16,最大是(1 <<
30)1073741824table : Entry<K,V>[] table
是用来存储数据的数组Entry<K,V> 是HashMap的一个内部类,链表结构

指定容量的构造函数

当然可以直接指定初始容量,其负载因子为默认的0.75

    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }
static class Entry<K,V> implements Map.Entry<K,V> { final K key; V value; Entry<K,V> next; int hash; ... }
指定容量和负载因子的构造函数

创建HashMap的时候可以指定容量和负载因子,但是HashMap真正的容量并不等于你指定的值。

看下面这段代码,设置capacity的值为1,当其
<initialCapacity的时候,会让capacity <<=
1,也就是×2,意思也就是capacity的值必须大于等于initialCapacity(也就是我们输入的参数),且是2的倍数。

  public HashMap(int initialCapacity, float loadFactor) {
        // Find a power of 2 >= initialCapacity
        int capacity = 1;
        while (capacity < initialCapacity)
            capacity <<= 1;
        this.loadFactor = loadFactor;
        threshold = (int)(capacity * loadFactor);
        table = new Entry[capacity];
        init();
    }

既然table是用来存储数据的,那么例子中我们往map放了六条数据,table中应该就有六条数据对吧。细心的同学可能发现了上图table中只有四条,table[0],table[7],table[10],table[12]数据,还有两条数据去哪了呢?而且打印结果也是六条数据。是不是eclipse有bug啊,还有两条数据没显示出来。
再仔细一看为什么“c++”这条数据跑到了table[7]的next去了,那null这条数据呢?看来不是eclipse的bug,那原因是什么呢?

确定数组Index

数组下标 = hash(key.hashCode())&(数组长度-1)

所以,数组下标相同,hashcode不一定相同。

   /**
     * Returns index for hash code h.
     */
    static int indexFor(int h, int length) {
        return h & (length-1);
    }

我们先来看看执行put()的时候到底做了什么?大概浏览一下源码

存取示例代码
/** * 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>.) */ public V put(K key, V value) { if (table == EMPTY_TABLE) { inflateTable(threshold); } if (key == null) return putForNullKey; int hash = hash; int i = indexFor(hash, table.length); for (Entry<K,V> e = table[i]; e != null; e = e.next) { Object k; if (e.hash == hash && ((k = e.key) == key || key.equals { V oldValue = e.value; e.value = value; e.recordAccess; return oldValue; } } modCount++; addEntry(hash, key, value, i); return null; }
简单实现
// 存储时:
int hash = key.hashCode(); // 计算key的hashcode的hash值
//将计算出来的hash与数组长度取余
int index = hash & (Entry[].length-1);
//将值赋予数组下表
Entry[index] = value;

// 取值时:
int hash = key.hashCode();
int index = hash &( Entry[].length - 1 );
return Entry[index];
执行过程大致是这样的:
  1. 先对table的非空检查,为空就初始化

  2. 对key的非空检查,如果key是null,会被存储到table[0],因为null的hash值总是0

  3. 对key的hashCode()做hash,然后再通过indexFor()计算index,这个就是table数组的索引;

  4. 如果在刚才计算出来的索引位置中table没有元素,直接把Entry对象放在那个索引上

  5. 如果索引上有元素,然后会进行迭代,在迭代的过程中,会调用equals()方法来检查key的相等性(key.equals,如果这个方法返回true,它就会用当前Entry的value来替换之前的value。如果返回false就一直到Entry->next是null,把当前的Entry对象变成链表的下一个节点

  6. 如果table的长度超过了loadFactor *current
    capacity,就要重新resize一个原来长度两倍的HashMap

到这里就恍然大悟了,刚才“c++”为什么会跑到table[7]中了,原来“PHP”和“c++”的hashCode()做hash,然后再通过indexFor()计算出来的index都是7,但是“php”和“c++”并不equals,所以这两条数据就形成一个链表存在table[7]中。至于null那条数据去哪了,大家应该也知道了。那get()方法呢?

当你理解了hashmap的put的工作原理,理解get的工作原理就非常简单了。当你传递一个key从hashmap总获取value的时候:

  1. 对key进行null检查。如果key是null,table[0]这个位置的元素将被返回。

  2. key的hashcode()方法被调用,然后计算hash值。

  3. indexFor(hash,table.length)用来计算要获取的Entry对象在table数组中的精确的位置,使用刚才计算的hash值。在获取了table数组的索引之后,会迭代链表,调用equals()方法检查key的相等性,如果equals()方法返回true,get方法返回Entry对象的value,否则,返回null。

  1. HashMap中数据是用一个叫table的数组来存的,table的索引在逻辑上叫做“桶”,它存储了链表的第一个元素。
  2. HashMap有一个叫做Entry的内部类,它用来存储key-value对。table数组存的就是它。Entry用一个next属性实现多个Entry以单向链表存放,插入元素时,如果两条Key落在同一个桶,并且这两条key不equals,后入桶的Entry将next指向桶当前的Entry,否则后入桶的会将前面的给覆盖(确保key的唯一性);
  3. 使用HashMap的时候最好使用泛型,如果key放的是自己的对象,最好重写equals()和hashcode()。

百度找了一张形象点的HashMap结构图

澳门新浦京8455com 520161001140638976.png

由上图可以看出哈希表是一个数组+链表的存储结构。HashMap存储结构文字解释:

table[0] →[index=1,Entry<K,V>] table[1] →[index=2,Entry<K,V>] ... 依次类推
put的具体实现

put往HashMap中存值

 public V put(K key, V value) {
        if (key == null)
            return putForNullKey(value); //null总是放在table下标为0的链表中

        //计算key的hashCode的hash值
        int hash = hash(key.hashCode());

        //计算要存放的数组下标
        int i = indexFor(hash, table.length);

        //遍历链表
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            //如果key在链表中已存在,则替换为新value
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                //返回旧值
                return oldValue;
            }
        }

        //遍历链表完毕没有相同的key,则添加值到链表中
        modCount++;
        addEntry(hash, key, value, i);
        return null;
    }

我们知道,如果在HashMap中,如果当前key已经存在,再put进去相同key的值,就会替换掉旧值。那么这个是如何实现的呢?
主要是下面这段代码:

 if (e.hash == hash && ((k = e.key) == key || key.equals(k)))

如果key的hash相等,且==或者equals对比的值相等,则证明key相等。
我们举个例子:

        String str1 = new String("HelloJava");
        String str2 = new String("HelloJava");
        System.out.println("str1 == str2:"+(str1 == str2));
        System.out.println("str1.equals(str2):"+str1.equals(str2));

        System.out.println("str1的hashcode:"+str1.hashCode());
        System.out.println("str2的hashcode:"+str2.hashCode());

        System.out.println("str1的Hash值:"+hash(str1.hashCode()));
        System.out.println("str2的Hash值:"+hash(str2.hashCode()));

        //输出结果如下:
        //str1 == str2:false
        //str1.equals(str2):true
        //str1的hashcode:-1094607372
        //str2的hashcode:-1094607372
        //str1的Hash值:-1269085867
        //str2的Hash值:-1269085867

可以看到,str1的hash和str2的hash是相等的,虽然==的值为false,但是equals的值为true,所以str1和str2在HashMap中依然是相等的key.(String类重写了equals和hashCode方法)

那么如果判断当前的HashMap中没有此key,就要将其key和value都添加到HashMap中,见下面这个方法:

    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);
    }

可以看到,这个方法其实就是将table[bucketIndex]下的链断开,将新的Entry插入到最前面,再将链搭起来。如下图:

澳门新浦京8455com 6

除了这个还有reSize()方法,就是当tale的占用超过threshold时,table长度就会扩充两倍,具体细节下面说。

get的实现

get的实现还是依靠判断key是否相等来取值,若有,则返回其值,若没有则返回null.

public V get(Object key) {
        //如果key等于null,则直接放table数组下标为0的位置上
        if (key == null)
            return getForNullKey();
        int hash = hash(key.hashCode());
        //先定位table数组下标位置,再遍历该位置处的链表
        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;
        }

        //没有找到,返回null
        return null;
}
null值的存取

null key总是存放在table数组的第一个元素位置,也就是table[0]。
注意:0下标不一定只存储key为null的元素

    //存值:
    private V putForNullKey(V value) {
        //将数组下标为0的元素赋值给e,然后遍历这个链表
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {

            //判断null为key的entry是否存在,若存在,替换值,返回旧值
            if (e.key == null) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }

        //若不存在,添加至链表,返回null
        modCount++;
        addEntry(0, null, value, 0);
        return null;
    }


    //取值
    private V getForNullKey() {
        //判断数组下标为0的链表中,key为null的值是否存在,若存在返回其值
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null)
                return e.value;
        }
        //若不存在,返回null
        return null;
    }

解决Hash冲突的方法

现在不予考虑细节

1. 开放定址法(线性探测再散列,二次探测再散列,伪随机探测再散列)
2. 再哈希法
3. 链地址法
4. 建立一个公共溢出区

Java中hashmap的解决办法就是采用的链地址法。

用链地址法处理冲突的办法是:把具有相同散列地址的关键字(同义词)值放在同一个单链表中,称为同义词链表。

再散列reSize的过程

首先这个过程是自动的,当table的占用超过threshold(capticy*loadFactor)时,resize()方法就会自动调用,扩充table的长度。

如果当前的capacity超过了MAXIMUM_CAPACITY,就将threshold设置为Interger.MAX_VALUE,然后就不会扩容了。

具体实现看下面的源码:

    /**
     * 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; //2的30次方

/**
     * 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).
     */
    void resize(int newCapacity) {
        //旧table
        Entry[] oldTable = table;
        //旧table的容量
        int oldCapacity = oldTable.length;
        //如果旧table的容量==MAXIMUM_CAPACITY,将threshold设置为Integer.MAX_VALUE,返回
        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return;
        }
        //按新容量大小创建newTable
        Entry[] newTable = new Entry[newCapacity];
        //数据转移
        transfer(newTable);
        table = newTable;
        //threshold重新赋值
        threshold = (int)(newCapacity * loadFactor);
    }




 /**
     * Transfers all entries from current table to newTable.
     */
    void transfer(Entry[] newTable) {
        Entry[] src = table;
        int newCapacity = newTable.length;
        //遍历原table
        for (int j = 0; j < src.length; j++) {
            Entry<K,V> e = src[j];
            if (e != null) {
                src[j] = null;
                do {
                    Entry<K,V> next = e.next;
                    //将原table的entry重新计算index,再放入到新table中
                    int i = indexFor(e.hash, newCapacity);
                    e.next = newTable[i];
                    newTable[i] = e;
                    e = next;
                } while (e != null);
            }
        }
    }
      .

HashMap的遍历方式

在foreach中遍历Entry的set集合

entry是HashMap的基础存储单元,map.entrySet()返回的是Entry的set集合。可以通过以下这种方式来获取HashMap的键值对。

    /**
     * 遍历hashmap的第一种方式
     * foreach 
     */
    public void getMap1(HashMap<String,String> map){
        for (Map.Entry<String,String> entry: map.entrySet()) {
            System.out.println(entry.getKey()+":"+entry.getValue());
        }
    }
在foreach中遍历keySet或者values

若只需要Map集合中的键或者值,就可以使用以下这种方式

    /**
     * 遍历map的第二种方式
     * 只可获得key或者value
     */
    public void getMap2(Map<String, String> map) {
        for (String key : map.keySet()) {
            System.out.println("key:" + key);
        }

        for (String value:map.values()) {
            System.out.println("value:"+value);
        }
    }
迭代器的遍历方式

这种方法的好处是可以利用iterator.remove()来删除entries。

    /**
     * 第三种遍历方式
     * 迭代器
     */
    public void getMap3(Map<String,String> map){
        Iterator<Map.Entry<String, String>> iterator = map.entrySet().iterator();
        while(iterator.hasNext()){
            Map.Entry<String, String> entry = iterator.next();
            System.out.println(entry.getKey()+":"+entry.getValue());
        }
    }
根据key遍历

这种方法效率低,不推荐使用。
为什么效率低:因为每次都需要根据key来寻值。

    /**
     * 根据key找值
     */
    public void getMap4(Map<String,String> map){
        Set<String> keySet = map.keySet();
        for (String key:keySet) {
            System.out.println("key:"+key);
            System.out.println("value:"+map.get(key));
        }

    }
You can leave a response, or trackback from your own site.

Leave a Reply

网站地图xml地图