（1）HashMap()：构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。

（2）HashMap(int initialCapacity)：构造一个带指定初始容量和默认加载因子 (0.75) 的空 HashMap。

（3）HashMap(int initialCapacity, float loadFactor)：构造一个带指定初始容量和加载因子的空 HashMap。

在这里提到了两个参数：初始容量，加载因子。其中容量表示哈希表中桶的数量，初始容量是创建哈希表时的容量，加载因子是哈希表在其容量自动增加之前可以达到多满的一种尺度，它衡量的是一个散列表的空间的使用程度，负载因子越大表示散列表的装填程度越高，反之愈小。对于使用链表法的散列表来说，查找一个元素的平均时间是O(1+a)，因此如果负载因子越大，对空间的利用更充分，然而后果是查找效率的降低；如果负载因子太小，那么散列表的数据将过于稀疏，对空间造成严重浪费。系统默认负载因子为0.75，一般情况下我们是无需修改的。

 public HashMap() {
     this.loadFactor = DEFAULT_LOAD_FACTOR;
     threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);//计算下次需要调整大小的极限值
     table = new Entry[DEFAULT_INITIAL_CAPACITY];//根据默认容量（16）初始化table
     init();
 }

 //根据给定的初始容量的装载因子创建一个空的HashMap
 //初始容量小于0或装载因子小于等于0将报异常 
 public HashMap(int initialCapacity, float loadFactor) {  
     //初始容量不能<0  
     if (initialCapacity < 0)  
         throw new IllegalArgumentException("Illegal initial capacity: "  
                 + initialCapacity);  
     //初始容量不能 > 最大容量值，HashMap的最大容量值为2^30  
     if (initialCapacity > MAXIMUM_CAPACITY)  
         initialCapacity = MAXIMUM_CAPACITY;  
     //负载因子不能 < 0  
     if (loadFactor <= 0 || Float.isNaN(loadFactor))  
         throw new IllegalArgumentException("Illegal load factor: "  
                 + loadFactor);  

     // 计算出大于 initialCapacity 的最小的 2 的 n 次方值。  
     int capacity = 1;  
     while (capacity < initialCapacity)  
         capacity <<= 1;  
       
     this.loadFactor = loadFactor;  
     //设置HashMap的容量极限，当HashMap的容量达到该极限时就会进行扩容操作  
     threshold = (int) (capacity * loadFactor);  
     //初始化table数组  
     table = new Entry[capacity];  
     init();  
 }  

 //根据指定容量创建一个空的HashMap
 public HashMap(int initialCapacity) {
     this(initialCapacity, DEFAULT_LOAD_FACTOR);//调用上面的构造方法，容量为指定的容量，装载因子是默认值
 }

 //通过传入的map创建一个HashMap，容量为默认容量（16）和(map.zise()/DEFAULT_LOAD_FACTORY)+1的较大者，装载因子为默认值
 public HashMap(Map<? extends K, ? extends V> m) {
     this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
                   DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
     putAllForCreate(m);
 }

从源码中可以看出，每次新建一个HashMap时，都会初始化一个table数组。table数组的元素为Entry节点。

四、---Entry类---

初始化table时均使用了Entry，table的数组元素为Entry结点。Entry是HashMap的一个内部类，实现Map接口的内部接口

Entry。下面给出Map.Entry接口及HashMap.Entry类的内容。Map.Entry接口定义的方法如下：

 K getKey();//获取Key
 V getValue();//获取Value
 V setValue();//设置Value，至于具体返回什么要看具体实现
 boolean equals(Object o);//定义equals方法用于判断两个Entry是否相同
 int hashCode();//定义获取hashCode的方法

static class Entry<K,V> implements Map.Entry<K,V> {  
        final K key;  
        V value;  
        Entry<K,V> next;  
        final int hash;  
  
        /** 
         * Creates new entry. 
         */  
        Entry(int h, K k, V v, Entry<K,V> n) {  
            value = v;  
            next = n;  
            key = k;  
            hash = h;  
        }  
        .......  
    } 

五、---其他方法---

5.1put(E key, V value)

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<K, V> 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;  
    } 

static int hash(int h) {  
        h ^= (h >>> 20) ^ (h >>> 12);  
        return h ^ (h >>> 7) ^ (h >>> 4);  
    }  

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

 // 构造方法一：调用默认的HashMap构造方法初始化map
 public HashSet() {
     map = new HashMap<E,Object>();
 }
 // 构造方法二：根据给定的Collection参数调用HashMap(int initialCapacity)的构造方法创建一个HashMap（这个构造方法的HashMap的源码分析里已经描述过了）
 // 调用addAll方法将c中的元素添加到HashSet对象中
 public HashSet(Collection<? extends E> c) {
     map = new HashMap<E,Object>(Math.max((int) (c.size()/.75f) + 1, 16));
     addAll(c);
 }
 // 构造方法三：构造一个指定初始化容量和负载因子的HashMap
 public HashSet(int initialCapacity, float loadFactor) {
     map = new HashMap<E,Object>(initialCapacity, loadFactor);
 }
 // 构造方法四：构造一个指定初始化容量的HashMap
 public HashSet(int initialCapacity) {
     map = new HashMap<E,Object>(initialCapacity);
 }
 // 构造方法五：构造一个指定初始化容量和负载因子的LinkedHashMap
 // dummy参数被忽略，只是用于区分其他的，包含一个int、float参数的构造方法
 HashSet(int initialCapacity, float loadFactor, boolean dummy) {
     map = new LinkedHashMap<E,Object>(initialCapacity, loadFactor);
 }

public int size() {  
        return map.size();  
    }  

4.3add(E e)

public boolean add(E e) {  
        return map.put(e, PRESENT)==null;  
    }  

 public class LinkedHashSet<E>
     extends HashSet<E>
     implements Set<E>, Cloneable, java.io.Serializable {
 
     public LinkedHashSet(int initialCapacity, float loadFactor) {
             super(initialCapacity, loadFactor, true);
     }
 
     public LinkedHashSet(int initialCapacity) {
         super(initialCapacity, .75f, true);
     }
 
     public LinkedHashSet() {
         super(16, .75f, true);
     }
 
     public LinkedHashSet(Collection<? extends E> c) {
         super(Math.max(2*c.size(), 11), .75f, true);
         addAll(c);
     }
 }

 HashSet(int initialCapacity, float loadFactor, boolean dummy) {
     map = new LinkedHashMap<E,Object>(initialCapacity, loadFactor);
 }