Java-集合篇-HashMap

Map接口：
数据结构：哈希表
哈希表：通过关键码来映射到值的一个数据结构
哈希函数：键与值映射的一个映射关系

哈希函数：
1.直接寻址法 ： f(x)=kx+b （k、b都是常数）
2.除留余数法 ： f(x)=x%k (k<=m)[m为存储位置长度]

哈希冲突：m!=n 但是 f(m)=f(n)
解决：1.链地址法
   2.探测法（线性探测、随机探测）

HashMap:

常用方法：
int size(); map中存储键值对的个数
boolean isEmpty(); 判断集合是否为空
boolean containsKey(Object key); 判断键是否存在
boolean containsValue(Object value); 判断值是否存在
void putAll(Map<? extnds K, ? extends V> m);
void clear();清除集合

HashMap JDK源码分析：

继承关系

public class HashMap<K,V>
    extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable

继承了AbstractMap(jdk1.2)、实现了map接口implements Map<K,V>，可以克隆、可以序列化

构造函数

//指定初始容量、指定加载因子
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();
}

   //通过默认加载因子和默认容量初始化
    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }
    public HashMap() {
        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
    }

   //通过map集合来初始化当前集合
    public HashMap(Map<? extends K, ? extends V> m) {
        this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
                      DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
        inflateTable(threshold);

        putAllForCreate(m);
    } 

put方法添加元素

public V put(K key, V value) {
     //第一次插入元素，需要对数组进行初始化：注意：数组大小为2的指数关系
    if (table == EMPTY_TABLE) {
        inflateTable(threshold);
    }
    //可以存储key为null的情况
    if (key == null)
        return putForNullKey(value);
    //key不为null 
    //通过key来哈希找到该数据所存在的索引位置：key相关的哈希值   
    int hash = hash(key);
    int i = indexFor(hash, table.length);
    //遍历该位置i下面的链表：（判断key是否存在，存在替换value，不存在创建新entry）
    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;
} 

插入key为null情况：
key为null做特殊处理，存储在table索引位0号位置
遍历该位置下的链表，查看key为null的节点是否存在，存在即将value更新为传入的value
若该链表下不存在则创建新的entry节点插入该链表

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

扩容方式

final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        if (oldCap > 0) {
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr;
        @SuppressWarnings({"rawtypes","unchecked"})
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else { // preserve order
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        do {
                            next = e.next;
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
                            else {
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

默认值
private static final long serialVersionUID = 362498820763181265L;
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
哈希表中数组默认初始值大小为16
static final int MAXIMUM_CAPACITY = 1 << 30;
哈希表中数组最大容量值
static final float DEFAULT_LOAD_FACTOR = 0.75f;
默认的加载因子-》扩容使用
static final int TREEIFY_THRESHOLD = 8;
static final int UNTREEIFY_THRESHOLD = 6;
static final int MIN_TREEIFY_CAPACITY = 64;

HashMap底层的实现是数组+链表实现:数组中存储的是一个个entry实体，hash到同一个索引位置的数据通过链表链接起来

使用迭代器遍历HashMap：

public static void main(String[] args) {
        HashMap <String, String> hashMap = new HashMap <String, String>();

        //插入元素 put
        hashMap.put("zhangsan", "1");
        hashMap.put("lisi","2");
        hashMap.put("wangwu","3");
        hashMap.put("lilei",null);
        hashMap.put(null,"1");
        //通过键获取值得方法
//        String lisi = hashMap.get("2");
//        System.out.println(hashMap.size());
        //删除元素
//        hashMap.remove(null);

//        System.out.println(hashMap.size());
//        System.out.println(lisi);
//        System.out.println(hashMap.containsKey("lilei"));
//        System.out.println(hashMap.size());

        /**
         * 数据无序
         * 键不能重复、值可以重复
         * 键和值都能为null
         */


        //对map集合的遍历：3种遍历方式
        //通过键值对遍历
        //先将HashMap实例转化为set实例（类型map.entry<>）
        Iterator <Map.Entry <String, String>> iterator = hashMap.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry <String, String> next = iterator.next();
            String key = next.getKey();
            String value = next.getValue();
            System.out.print(key+":"+value+" ");
        }
        System.out.println();
        //通过键来遍历
        //仅仅对键进行访问
        Iterator <String> iterator1 = hashMap.keySet().iterator();
        while (iterator1.hasNext()) {
            String next = iterator1.next();
            System.out.print(next+" ");
        }

        System.out.println();
        //通过值来对map集合进行遍历
        Iterator <String> iterator2 = hashMap.values().iterator();
        while (iterator2.hasNext()) {
            String next = iterator2.next();
            System.out.print(next+" ");
        }
    }

HashMap的简单应用：
产生100000个随机数（范围为1-1000），统计各个数字出现的次数

 public static void main(String[] args) {
        HashMap<Integer,Integer> hashMap = new HashMap<>();
        Random random = new Random();
        for(int i =0 ;i<100000 ;i++){
            int value = random.nextInt(1000)+1;
            Integer v = hashMap.get(value);
            if(v==null) {
                hashMap.put(value, 1);
            }else {
                v++;
                hashMap.put(value,v);
            }
        }
        Iterator<Map.Entry<Integer,Integer>> iterator = hashMap.entrySet().iterator();
        int count = 0;
        while(iterator.hasNext()){
            count++;
            Map.Entry<Integer,Integer> next = iterator.next();
            Integer key = next.getKey();
            Integer value = next.getValue();
            System.out.print(key+":"+value+"   ");
            if(count==20){
                System.out.println();
                count = 0;
            }
        }
        System.out.println();

    }