java 数据结构(6) Hashmap Hashtable Treemap LinkedHashMap

参考
java提高篇(二三)-----HashMap
HashMap vs. TreeMap vs. Hashtable vs. LinkedHashMap
Java之美[从菜鸟到高手演变]之HashMap、HashTable
hashmap方法摘要

Java中数据存储方式最底层的两种结构,一种是数组,另一种就是链表,数组的特点:连续空间,寻址迅速,但是在删除或者添加元素的时候需要有较大幅度的移动,所以查询速度快,增删较慢。而链表正好相反,由于空间不连续,寻址困难,增删元素只需修改指针,所以查询慢、增删快。有没有一种数据结构来综合一下 数组和链表,以便发挥他们各自的优势?答案是肯定的!就是:哈希表。哈希表具有较快(常量级)的查询速度,及相对较快的增删速度,所以很适合在海量数据的环境中使用。一般实现哈希表的方法采用“拉链法”,我们可以理解为“链表的数组”,如下图:


java 数据结构(6) Hashmap Hashtable Treemap LinkedHashMap_第1张图片
数组里全是链表结构

从上图中,我们可以发现哈希表是由数组+链表组成的,一个长度为16的数组中,每个元素存储的是一个链表的头结点。那么这些元素是按照什么样的规则 存储到数组中呢。一般情况是通过hash(key)%len获得,也就是元素的key的哈希值对数组长度取模得到。比如上述哈希表 中,12%16=12,28%16=12,108%16=12,140%16=12。所以12、28、108以及140都存储在数组下标为12的位置。它 的内部其实是用一个Entity数组来实现的,属性有key、value、next。

一、HashMap内部结构

1、初始化

static final int DEFAULT_INITIAL_CAPACITY = 16;// 初始容量:16
static final int MAXIMUM_CAPACITY = 1 << 30; //最大容量:2的30次方:1073741824
static final float DEFAULT_LOAD_FACTOR = 0.75f; //装载因子,后面再说它的作用

其中Entry为HashMap的内部类,它包含了键key、值value、下一个节点next,以及hash值,这是非常重要的,正是由于Entry才构成了table数组的项为链表。

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

        /**
         * Creates new entry.
         */
        Entry(int h, K k, V v, Entry n) {
            value = v;
            next = n;
            key = k;
            hash = h;
        }
        .......
    }

2.构造方法

public HashMap() {  
        this.loadFactor = DEFAULT_LOAD_FACTOR;  
        threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);  
        table = new Entry[DEFAULT_INITIAL_CAPACITY]; //默认开辟16个
        init();  
    }

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

capacity <<= 1表示实际的开辟的空间要大于传入的第一个参数的值。举个例子:new HashMap(7,0.8),loadFactor为0.8,capacity为7,通过上述代码后,capacity的值为:8.(1 << 2的结果是2,2 << 2的结果为4)。所以,最终capacity的值为8,最后通过new Entry[capacity]来创建大小为capacity的数组。

3.put操作

public V put(K key, V value) {
        //当key为null,调用putForNullKey方法,保存null与table
        //第一个位置中,这是HashMap允许为null的原因
        if (key == null)
            return putForNullKey(value);
        //计算key的hash值
        int hash = hash(key.hashCode());                  ------(1)
        //计算key hash 值在 table 数组中的位置
        int i = indexFor(hash, table.length);             ------(2)
        //从i出开始迭代 e,找到 key 保存的位置
        for (Entry e = table[i]; e != null; e = e.next) {
            Object k;
            //判断该条链上是否有hash值相同的(key相同)
            //若存在相同,则直接覆盖value,返回旧value
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;    //旧值 = 新值
                e.value = value;
                e.recordAccess(this);
                return oldValue;     //返回旧值
            }
        }
        //修改次数增加1
        modCount++;
        //将key、value添加至i位置处
        addEntry(hash, key, value, i);
        return null;
    }

    private V putForNullKey(V value) {
        for (Entry 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;
    }

static int indexFor(int h, int length) {
        return h & (length-1);
    }

就是说,获取Entry的第一个元素table[0],并基于第一个元素的next属性开始遍历,直到找到key为null的Entry,将其value设置为新的value值。如果没有找到key为null的元素,则调用如上述代码的addEntry(0, null, value, 0);增加一个新的entry,代码如下:

void addEntry(int hash, K key, V value, int bucketIndex) {
    Entry e = table[bucketIndex];
        table[bucketIndex] = new Entry(hash, key, value, e);
        if (size++ >= threshold)
            resize(2 * table.length); 
    }

先获取第一个元素table[bucketIndex],传给e对象,新建一个entry,key为null,value为传入的value值,next为获取的e对象。如果容量大于threshold,容量扩大2倍。如果key不为null,这也是大多数的情况,重新看一下源码:

public V put(K key, V value) {  
        if (key == null)  
            return putForNullKey(value);  
        int hash = hash(key.hashCode());//---------------2---------------  
        int i = indexFor(hash, table.length);  
        for (Entry e = table[i]; e != null; e = e.next) {//--------------3-----------  
            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;  
            }  
        }//-------------------4------------------  
        modCount++;//----------------5----------  
        addEntry(hash, key, value, i);-------------6-----------  
        return null;  
    }  

看源码中2处,首先会进行key.hashCode()操作,获取key的哈希值,hashCode()是Object类的一个方法,为本地方法,内部实现比较复杂,我们会在后面作单独的关于Java中Native方法的分析中介绍。hash()的源码如下:

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

int i = indexFor(hash, table.length);的意思,相当于int i = hash % Entry[].length;得到i后,就是在Entry数组中的位置,上述代码5和6处是如果Entry数组中不存在新要增加的元素,则执行5,6处的代码,如果存在,即Hash冲突,则执行 3-4处的代码,此处HashMap中采用链地址法解决Hash冲突。具体方法可以解释为下面的这段文字:
上面我们提到过Entry类里面有一个next属性,作用是指向下一个Entry。如, 第一个键值对A进来,通过计算其key的hash得到的i=0,记做:Entry[0] = A。一会后又进来一个键值对B,通过计算其i也等于0,现在怎么办?HashMap会这样做:B.next = A,Entry[0] = B,如果又进来C,i也等于0,那么C.next = B,Entry[0] = C;这样我们发现i=0的地方其实存取了A,B,C三个键值对,他们通过next这个属性链接在一起,也就是说数组中存储的是最后插入的元素。
到这里为止,HashMap的大致实现,我们应该已经清楚了。当然HashMap里面也包含一些优化方面的实现,这里也说一下。比 如:Entry[]的长度一定后,随着map里面数据的越来越长,这样同一个i的链就会很长,会不会影响性能?HashMap里面设置一个因素(也称为因子),随着map的size越来越大,Entry[]会以一定的规则加长长度。
4.get操作

public V get(Object key) {  
        if (key == null)  
            return getForNullKey();  
        int hash = hash(key.hashCode());  
        for (Entry 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为null时,调用getForNullKey(),源码如下:

private V getForNullKey() {  
        for (Entry e = table[0]; e != null; e = e.next) {  
            if (e.key == null)  
                return e.value;  
        }  
        return null;  
    }  

当key不为null时,先根据hash函数得到hash值,在更具indexFor()得到i的值,循环遍历链表,如果有:key值等于已存在的key值,则返回其value。如上述get()代码1处判断。
总结下HashMap新增put和获取get操作:

//存储时:  
int hash = key.hashCode();  
int i = hash % Entry[].length;  
Entry[i] = value;  
  
//取值时:  
int hash = key.hashCode();  
int i = hash % Entry[].length;  
return Entry[i]; 

5.遍历
参考
简单分析Java的HashMap.entrySet()的实现
keySet 与entrySet 遍历HashMap性能差别
对于keySet其实是遍历了2次,一次是转为iterator,一次就从hashmap中取出key所对于的value。而entryset只是遍历了第一次,他把key和value都放到了entry中,所以就快了。
(1)keySet

Iterator keySetIterator = 
keySetMap.keySet().iterator();
        while (keySetIterator.hasNext()) {
            String key = keySetIterator.next();
            String value = keySetMap.get(key);
            
        }

(2)entrySet

Iterator> entryKeyIterator = 
entrySetMap.entrySet().iterator();
        while (entryKeyIterator.hasNext()) {
            Entry e = entryKeyIterator.next();
            String value=e.getValue();
        }

entrySet()方法返回的是一个特殊的Set,定义为HashMap的内部私有类

private final class EntrySet extends AbstractSet>

HashMap的entrySet()方法返回一个特殊的Set,这个Set使用EntryIterator遍历,而这个Iterator则直接操作于HashMap的内部存储结构table上。通过这种方式实现了“视图”的功能。整个过程不需要任何辅助存储空间。从这一点也可以看出为什么entrySet()是遍历HashMap最高效的方法,原因很简单,因为这种方式和HashMap内部的存储方式是一致的。

二、hashmap hashtable treemap

Java SE中有四种常见的Map实现——HashMap, TreeMap, Hashtable和LinkedHashMap。如果我们使用一句话来分别概括它们的特点,就是:

  • HashMap就是一张hash表,键和值都没有排序。
  • TreeMap以红-黑树结构为基础,键值按顺序排列。
    参考红黑树(一)之 原理和算法详细介绍
  • LinkedHashMap保存了插入时的顺序。参考【Java集合源码剖析】LinkedHashmap源码剖析
  • Hashtable是同步的(而HashMap是不同步的)。
public static void main(String args[]){
    System.out.println("map");
    testHash(new HashMap(),"HashMap");
    testHash(new Hashtable(),"Hashtable");
    testHash(new TreeMap(),"TreeMap");
}
private static void testHash(Map map,String typeStr){
    map.put("a","aaa");
    map.put("b","bbb");
    map.put("c","ccc");
    map.put("d","ddd");
    Iterator iterator = map.keySet().iterator();
    while(iterator.hasNext()){
      Object key = iterator.next();
      System.out.println(typeStr+map.get(key));
    }
    System.out.println("---------");
}
三、如果HashMap的键(key)是自定义的对象,那么需要按规则定义equals和hashCode
  • public boolean equals(Object o)
  • public int hashCode()
class Dog {
    String color;
    Dog(String c) {
   color = c;
    }
    public String toString(){   
   return color + " dog";
    }
}
public class TestHashMap {
    public static void main(String[] args) {
   HashMap hashMap = new HashMap();
   Dog d1 = new Dog("red");
   Dog d2 = new Dog("black");
   Dog d3 = new Dog("white");
   Dog d4 = new Dog("white");
   hashMap.put(d1, 10);
   hashMap.put(d2, 15);
   hashMap.put(d3, 5);
   hashMap.put(d4, 20);
   //print size
   System.out.println(hashMap.size());
   //loop HashMap
   for (Entry entry : hashMap.entrySet()) {
       System.out.println(entry.getKey().toString() 
       + " - " + entry.getValue());
   }
    }
}
//结果:
4
white dog - 5
black dog - 15
red dog - 10
white dog - 20

注意,我们错误的将”white dogs”添加了两次,但是HashMap却接受了两只”white dogs”。这不合理(因为HashMap的键不应该重复),我们会搞不清楚真正有多少白色的狗存在。

class Dog {
    String color;
 
    Dog(String c) {
        color = c;
    }
 
    public boolean equals(Object o) {
        return ((Dog) o).color == this.color;
    }
 
    public int hashCode() {
        return color.length();
    }
 
    public String toString(){   
        return color + " dog";
    }
}
//现在输出结果如下
3
red dog - 10
white dog - 20
black dog - 15

输出结果如上是因为HashMap不允许有两个相等的元素存在。默认情况下(也就是类没有实现hashCode()和equals()方法时),会使用Object类中的这两个方法。Object类中的hashCode()对于不同的对象会返回不同的整数,而只有两个引用指向的同样的对象时equals()才会返回true。
另外,关于这两个方法,可以参考java中正确使用equals和hashCode

三、hashtable实际使用

1.参考现在搞java的人,还有用vector和hashtable的嘛?

一直很好奇。感觉这俩是只在教科书上出现过的东西。实际中从没见过有人使用。但很多人面试时候总会问这俩东西。如果从深入理解的角度来说了解一下无妨。但是从应用角度来说意义不大。

不需要线程同步有 ArrayList / HashMap,需要线程同步有 java.util.concurrent 的 ConcurrentHashMap / CopyOnWriteArrayList 或者根据代码行为进行手工同步 [1] 。这种被淘汰的东西当然不应该用。
2.嵌套使用
参考java Map集合嵌套,value为Map和value为List

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;


public class MapDemo {

    public static void main(String[] args) {
        System.out.println("Map集合的值为Map");
        oneToMap();
        
        System.out.println("Map集合的值为List,特别常用!必须会!");
        oneToList();
    }
    
    /*
     * 这种是把班级和学生作为映射
     * 而且又把学号和姓名做了映射
     */
    public static void oneToMap() {
        Map> jiSuanJi = 
        new HashMap>();
        Map ruanJian = new HashMap();
        Map wangZhan = new HashMap();
        
        /*
         * 千万不要每次都new一个进去,这样就不是原来的集合了
         * 结果yingyong这个key对应的value集合是null
         * 遍历Map的时候还会出现空指针错误
         */
        //jiSuanJi.put("yingyong", (Map) 
        //new HashMap().put("01", "haha"));
        //jiSuanJi.put("yingyong", (Map) 
        //new HashMap().put("02", "xixi"));
        
        /*
         * 要使用下面这种方式,先把集合定义好,
         * 把映射关系设置好,再去给集合添加元素
         */
        jiSuanJi.put("ruanJian", ruanJian);
        jiSuanJi.put("wangZhan", wangZhan);
        
        ruanJian.put("01", "zhangsan");
        ruanJian.put("02", "lisi");
        
        wangZhan.put("01", "zhaoliu");
        wangZhan.put("02", "zhouqi");
        
        Set keySet = jiSuanJi.keySet();
        for(Iterator it = keySet.iterator();it.hasNext();) {
            String key = it.next();
            System.out.println(key);
            Map map = jiSuanJi.get(key);
            Set> entrySet = map.entrySet();
            for(Iterator> it2 
                = entrySet.iterator();it2.hasNext();) {
                Map.Entry me = it2.next();
                System.out.println(me.getKey() + ".." + me.getValue());
            }
        }
    }
    
    /*
     * 这种把班级和学生做了映射
     * 学生类中封装了学号和姓名
     */
    public static void oneToList() {
        Map> jiSuanJi = 
        new HashMap>();
        List ruanJian = new ArrayList();
        List wangZhan = new ArrayList();
        
        jiSuanJi.put("ruanJian", ruanJian);
        jiSuanJi.put("wangZhan", wangZhan);
        
        ruanJian.add(new PersonDemo("01","zhangsan"));
        ruanJian.add(new PersonDemo("02","lisi"));
        wangZhan.add(new PersonDemo("01","wangwu"));
        wangZhan.add(new PersonDemo("02","zhaoliu"));
        
        Set keySet = jiSuanJi.keySet();
        for(Iterator it = keySet.iterator();it.hasNext();){
            String key = it.next();
            System.out.println(key);
            List list = jiSuanJi.get(key);
            for(Iterator it2 = list.iterator();it2.hasNext();) {
                PersonDemo pd = it2.next();
                System.out.println(pd);
            }
        }
    }
    
}

class PersonDemo {
    
    private String id;
    private String name;
    
    public PersonDemo(String id, String name) {
        super();
        this.id = id;
        this.name = name;
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return this.id + "..." + this.name;
    }
}

你可能感兴趣的:(java 数据结构(6) Hashmap Hashtable Treemap LinkedHashMap)