Java集合框架(四)Map

Map

    先看下map的类图:    


    我们主要学习HashMap,LinkedHashMap,Hashtable,WeakedHashMap和TreeMap。

1.map介绍

    map在java中用来保存具有映射关系的数据,以键值对的形式保存,一个key对应一个value,key不可以重复。可以把map中的key部分看成一个set集合,无序不重复,把value部分看成是一个list集合,都可以通过索引来进行访问,只不过这里的索引不是数字下标而是map中的key。

2.map主要实现和基本用法

    map和set的实现结构基本相同,从两者的类图中也可以看出来。事实上java中就是先有得map集合,再有得set集合,set集合是被当成一个value全都是null的map集合。

    HashMap:(使用最多的实现类)

     测试代码:

package com.ljw.ColleactionAndMap;

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

/**
 * Created by liujiawei on 2018/6/30.
 */
public class TestMap {
    public static void main(String[] args) {
        HashMap hashMap = new HashMap();

        hashMap.put(null,1);
        hashMap.put(null,2);
        hashMap.put("jack","jack");
        hashMap.put("tom","tom");
        hashMap.put("jak","jack");
        hashMap.put(2,"2");
        hashMap.put(1,"1");


        System.out.println(hashMap);

        System.out.println(hashMap.keySet());  //以集合形式获取map的所有key

        System.out.println(hashMap.get(1));


        System.out.println("是否保存'33'的key===" + hashMap.containsKey("33"));

        System.out.println("是否保存'33'的value===" + hashMap.containsValue("33"));

        System.out.println(hashMap.entrySet());  //以集合形式获取map中的entry

        //迭代hashmap的4中常见方式

        //1.通过迭代器迭代entryset
        System.out.println("通过迭代器迭代entryset");
        Iterator it = hashMap.entrySet().iterator();
        while(it.hasNext()){
            Map.Entry entry = (Map.Entry) it.next();
            System.out.println(entry.getKey() + "====" + entry.getValue());
        }


        //2。for循环entryset  推荐
        System.out.println("推荐使用for循环entryset");
        for (Object o:hashMap.entrySet()) {
            Map.Entry<Object,Object> entry = (Map.Entry<Object, Object>) o;
            System.out.println(entry.getKey() + "====" + entry.getValue());
        }
        

        //3.遍历key获取values
        System.out.println("遍历key获取values");
        for (Object o:hashMap.keySet()) {
            System.out.println(o + "===" + hashMap.get(o));
        }

        //4。遍历value
        System.out.println("遍历value");
        for (Object o:hashMap.values()) {
            System.out.println(o);
        }


    }
}

 运行结果:


    通过上面的结果可以看到,hashmap中支持插入null作为key,key是唯一的,插入重复的key时,后插入的value会代替之前的value。我们还注意到插入的顺序和我们输出的顺序不一致,这是因为HashMap在插入key时,会通过计算hashcode来自己确定存储位置,所以是无序的。HashMap还可以以集合的形式返回所有的key,通过HashMap的keySet()可以对map的对象进行迭代。通过get(Object key)方法,可以获取到对应的value。

    LinkedHashMap:

    测试代码:

package com.ljw.ColleactionAndMap;

import java.util.LinkedHashMap;

/**
 * Created by liujiawei on 2018/7/2.
 */
public class TestLinkedHashMap {
    public static void main(String[] args) {
        LinkedHashMap linkedHashMap = new LinkedHashMap();

        linkedHashMap.put(null,1);
        linkedHashMap.put(null,2);
        linkedHashMap.put("jack","jack");
        linkedHashMap.put("tom","tom");
        linkedHashMap.put("jak","jack");
        linkedHashMap.put(2,"2");
        linkedHashMap.put(1,"1");

        System.out.println(linkedHashMap);

    }
}

运行结果:


    LinkedHashMap在HashMap的基础上,通过链表来维护插入的key的顺序,保证放入和取出的顺序是一致的。

    因为需要维护插入的顺序,所以性能上没有HashMap好。

  Hashtable:

    Hashtable和HashMap的用法基本相同,区别在于Hashtable是线程安全的,不支持null作为key。 


   WeakedHashMap:

    WeakedHashMap和HashMap的用法相同,区别的是WeakedHashMap中放的是弱引用(java引用相关参考)
    我们用代码看下是什么意思:
   测试代码:
package com.ljw.ColleactionAndMap;

import java.util.WeakHashMap;

/**
 * Created by liujiawei on 2018/7/2.
 */
public class TestWeakedHashMap {
    public static void main(String[] args) {
        WeakHashMap weakHashMap = new WeakHashMap();
        weakHashMap.put(new String("jack"),"jack");
        weakHashMap.put(new String("tom"),"tom");
        weakHashMap.put(new String("pony"),"pony");

        System.out.println(weakHashMap);
        System.gc();
        System.out.println(weakHashMap);

        String tony = "tony";
        weakHashMap.put(tony,tony);
        System.gc();
        System.out.println(weakHashMap);


    }
}

 运行结果:


    可以看到第一次放入的三个数据,在调用了System.gc()以后,全都被回收了,最后增加的数据保留了下面,这就是因为上面三个全都属于弱引用,最后那个则是强饮用。

   *使用WeakedHashMap时,里面要注意全都是弱引用,否则就失去了使用它的意义。

 TreeMap:

    对照TreeSet, TreeSet内部通过红黑树来存储数据,要求插入的对象都实现compator接口,依次来保证内部元素处于有序状态。TreeMap也是通过红黑树实现了内部对象的排序。我们用代码看下:

package com.ljw.ColleactionAndMap;

import java.util.Comparator;
import java.util.TreeMap;

/**
 * Created by liujiawei on 2018/7/2.
 */
public class TestTreeMap {
    public static void main(String[] args) {
        TreeMap treeMap = new TreeMap();
        treeMap.put(1,1);
        treeMap.put(2,1);
        treeMap.put(3,1);
        treeMap.put(4,1);
        System.out.println(treeMap);


        TreeMap treeMap1 = new TreeMap(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                int a = (int) o1;
                int b = (int) o2;
                if(a < b)
                    return 1;
                if(a == b)
                    return 0;
                if(a > b)
                    return -1;
                return 0;
            }
        });

        treeMap1.put(1,1);
        treeMap1.put(2,1);
        treeMap1.put(3,1);
        treeMap1.put(4,1);
        System.out.println(treeMap1);


    }
}

 运行结果:


     和TreeSet一样,TreeMap中的对象需要实现Compator接口,否则无法进行排序,抛出异常。

  在实例化时,通过内部类直接重写compare()方法,可以实现定制排序的效果。

     *除非需要map中的对象总是处于有序状态,此时选择TreeMap,其他时候就应该尽量使用其他集合,因为排序会额外消耗时间。


3.HashMap和Hashtable底层分析(jdk1.7)

    HashMap:

我们从HashMap的源码中来分析下HashMap初始化/新增/扩容这三个过程。
初始化:
        先记住这三个参数,后面会介绍这三个用途。

         默认容量:16

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

默认加载因子:0.75f

static final float DEFAULT_LOAD_FACTOR = 0.75f;

       扩容因子:

int threshold;

HashMap的三个构造方法,其实调用的都是最后一个:

public HashMap() {
    this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
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();
}
   我们直接看最后一个构造方法,我们可以看到在这个方法里面没有生成任何对象,只是对初始化容量initialCapacity,加载因子loadFactory还有扩容因子threshold做了简单的赋值。

    这里的init()方法是留给HashMap的子类实现的,这里没有任何实际意义。

  新增:

    HashMap中的新增对象都是通过put(key,value)方法来实现,它是以什么形式存储数据的,null是怎么处理的,重复的key是怎么判断的,都在这个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;
}
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;
      table是HashMap中的声明的一个Entry类型的数组,这个对象是map中的一个内部实现类,用于保存key-value这种键值对类型的数据。

看下inflateTable()这个方法,inflate是膨胀的意思,可以看出,这就是给table初始化的方法:

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);
}
      在HashMap中,数组的容量总是2的次幂,这是因为2的次幂在计算机中运行效率最高,扩容因子在这里被重新赋值,具体计算就是容量*加载因子。这个数值将用来判断何时需要扩容Entry数组。根据计算出的容量,完成对table的初始化,默认是一个大小为16的数组。
    继续看下,put()方法,可以看到HashMap之所以支持null作为key,就是它对null做了特殊处理,看下putForNullKey()方法:
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;
}

    可以看到,当key是null,会去table第一个位置找对应的数据,如果有的话,新的value会替代原有的value放在第一个位置,同时返回老得value。可以for循环有个判断条件是e = e.next,我们继续往下看:

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;

    可以看到非null类型的key处理步骤其实和null差不多,都是计算key的hash值,找到对应的存储位置来进行操作,这里的e.next是用来查询链表中的下一个数据,这涉及到HashMap内部的存储,用一个图说明下HashMap的存储:


    HashMap内部使用数组来存储数据,这个数组是一个链表数组,里面存放Entry对象,Entry有三个属性,hash,key,value,key和value就是我们放进map的数据,hash则是通过hash(object)方法计算出的hashcode,所以HashMap的存储过程是这样理解的:

    我们put一个key,value进map,首先拿到这个key,通过hashcode找到对应位置的数据,这是一个链表,先比较链表中的第一个对象的value,看是否相同,是的话,替换value,返回老的value,不是则和链表的下一个数据进行比较。

    扩容:
    我们已经知道,put(key,value),最后其实执行的操作就是addEntry(hash,key,value),我们对table进行的扩容也是在这个方法中进行的:
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);
}
     通过比较数组中已占用的空间和扩容因子,如果已占用的大小已经大于等于扩容因子了,那么直接在原有大小的基础上扩展一倍的空间。


    Hashtable:

     Hashtable和Vector一样,也是从最初的jdk就存在的一个集合,命名甚至都没有遵守驼峰命名的规则,现在基本不再使用这个集合,但是从研究的角度还是有必要了解下的:

    初始化:

    看下Hashtable的有关构造函数:

public Hashtable() {
    this(11, 0.75f);
}
	public Hashtable(int initialCapacity) {
    this(initialCapacity, 0.75f);
}
public Hashtable(int initialCapacity, float loadFactor) {
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
        throw new IllegalArgumentException("Illegal Load: "+loadFactor);

    if (initialCapacity==0)
        initialCapacity = 1;
    this.loadFactor = loadFactor;
    table = new Entry[initialCapacity];
    threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
    initHashSeedAsNeeded(initialCapacity);
}
    可以看到,Hashtable在实例化的过程中就对table对象完成了初始化过程,默认容量为11,加载因子也是0.75f。


    新增:
public Hashtable(int initialCapacity, float loadFactor) {
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
        throw new IllegalArgumentException("Illegal Load: "+loadFactor);

    if (initialCapacity==0)
        initialCapacity = 1;
    this.loadFactor = loadFactor;
    table = new Entry[initialCapacity];
    threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
    initHashSeedAsNeeded(initialCapacity);
}
可以看到,Hashtable在实例化的过程中就对table对象完成了初始化过程,默认容量为11,加载因子也是0.75f。
新增:
public synchronized V put(K key, V value) {
    // Make sure the value is not null
    if (value == null) {
        throw new NullPointerException();
    }

    // Makes sure the key is not already in the hashtable.
    Entry tab[] = table;
    int hash = hash(key);
    int index = (hash & 0x7FFFFFFF) % tab.length;
    for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
        if ((e.hash == hash) && e.key.equals(key)) {
            V old = e.value;
            e.value = value;
            return old;
        }
    }

    modCount++;
    if (count >= threshold) {
        // Rehash the table if the threshold is exceeded
        rehash();

        tab = table;
        hash = hash(key);
        index = (hash & 0x7FFFFFFF) % tab.length;
    }

    // Creates the new entry.
    Entry<K,V> e = tab[index];
    tab[index] = new Entry<>(hash, key, value, e);
    count++;
    return null;
}
    可以看到,Hashtable之所以不支持null作为key,就是因为在新增的代码中对null做了处理,直接抛出了异常。

后面的插入以及扩容操作基本大同小异。


4.map集合比较

    HashMap,LinkedHashMap,TreeMap和Hashtable这四个的使用,可以参考以下:

(1) HashMap是为了快速查询而设计的,当需要使用map集合时,如果没有特殊需求,首选HashMap;
(2)LinkedHashMap作为HashMap的子类,额外通过链表来对插入的数据做了管理,使得插入和取出的顺序相同,在迭代查询上有优势,插入删除操作还是HashMap更好;
(3)TreeMap使用红黑树,使得内部数据总是处于排序状态,但是这耗费了额外的性能,如果没有这个排序的需要,尽量不要使用TreeMap;
(4)需要线程安全,可以使用Hashtable.






展开阅读全文

没有更多推荐了,返回首页