Java 集合 Map Properties读取属性文件

map用于保存具有映射关系的数据，因此Map集合里保存着两组值，一组值用于保存Map里的key，另外一组值用于保存Map里的value，key和value都可以是任何引用类型的数据。Map的key不允许重复，即同一个Map对象的任何两个key通过equals方法比较总是返回false。key和value之间存在单向一对一关系，即通过指定的key，总能找到唯一的、确定的value。从Map中取出数据时，只要给出指定的key，就可以取出对应的value。

Map有时也称为字典，或关联数组。Map接口中定义如下方法：

• void clear()：删除Map对象中所有key-value对

• boolean containsKey(Object key)：查询Map中是否包含指定key，如果包含则返回true

• boolean containsValue(Object value)：查询Map中是否包含一个或多个value，如果包含则返回true

• Set entrySet()：返回Map中所有包含的key-value对组成的Set集合，每个集合元素都是Map.Entry(Entry是Map的内部类）对象

• Object get(Obejct key)：返回指定key所对应的value；如果此Map中不包含key，则返回null

• boolean isEmpty()：查询该Map是否为空（即不包含任何key-value对），如果为空则返回true

• Set keySet()：返回该Map中所有key所组成的set集合

• Object put(Object key, Object value)：添加一个key-value对，如果当前Map中已有一个与该key相等的key-value对，则新的key-value对会覆盖原来的key-value对

• Object remove(Object key)：删除指定key对应的key-value对，返回被删除key所关联的value，如果该key不存在，返回null

• int size()：返回该Map里的key-value对的个数

• Collection values()：返回该Map里所有value组成的Collection

Map中包括一个内部类：Entry。该类封装了一个key-value对，Entry包含三个方法：

• Object getkey():返回该Entry里包含的key值

• Object getValue():返回该Entry里包含的value值

• Object setValue():设置该Entry里包含的value值，并返回新设置的value值

    import java.util.*;
    
    public class MapTest
    {
        public static void main(String[] args)
        {
            Map map = new HashMap();
            // 成对放入多个key-value对
            map.put("勒布朗詹姆斯", 6);
            map.put("凯文杜兰特", 35);
            map.put("斯蒂芬库里", 30);
            // 多次放入的key-value对中value可以重复
            map.put("维斯布鲁克", 0);
            // 放入重复的key时，新的value会覆盖原有的value
            // 如果新的value覆盖了原有的value，该方法返回被覆盖的value
            System.out.println(map.put("勒布朗詹姆斯", 23)); // 输出6
            System.out.println(map); // 输出的Map集合包含4个key-value对
            // 输出{凯文杜兰特=35, 勒布朗詹姆斯=23, 斯蒂芬库里=30, 维斯布鲁克=0}
            // 判断是否包含指定key
            System.out.println("是否包含值为 勒布朗詹姆斯 key："
                + map.containsKey("勒布朗詹姆斯")); // 输出true
            // 判断是否包含指定value
            System.out.println("是否包含值为 0 value："
                + map.containsValue(0)); // 输出true
            // 获取Map集合的所有key组成的集合，通过遍历key来实现遍历所有key-value对
            for (Object key : map.keySet() )
            {
                // map.get(key)方法获取指定key对应的value
                System.out.println(key + "-->" + map.get(key));
            }
            map.remove("凯文杜兰特"); // 根据key来删除key-value对。
            System.out.println(map); // 输出结果不再包含 疯狂凯文杜兰特=35 的key-value对
        }
}

Map的实现类都重写了toString()方法，调用Map对象的toString()方法总是返回如下格式的字符串：{key1=value, key2=value...}

Java8为Map新增的方法

Java8除了为map增加了remove(Object key, Object value)默认方法之外，还增加了如下方法：

• Object compute(Object key, BiFunction remappingFunction)：该方法使用remappingFunction根据原key-value对计算一个新value。只要新value不为null，就使用新value覆盖原value；如果原value不为null，但新value为null，则删除原key-value对；如果原value、新value同时为null，那么该方法不改变任何key-value对，直接返回null

• Object computeIfAbsent(Object key, Function mappingFunction)：如果传给该方法的key参数在Map中对应的value为null，则使用mappingFunction根据key计算一个新的结果，如果计算结果不为null，则用计算结果覆盖原有value。如果原Map原来不包含该key，那么该方法可能会添加一组key-value对

• Object computeIfPresent(Object key ,BiFunction remappingFunction)：如果传给该方法的key参数在Map中对应的value不为null，该方法将使用remappingFunction根据原key、value计算一个新的结果，如果计算结果不为null，则使用该结果覆盖原来的value，如果计算的结果为null，则删除原key-value对

• void forEach(BiConsumer action)：该方法是Java 8为Map新增的一个遍历key-value对的方法

• Object getOrDefault(Object key, V defaultValue)：获取指定key对应的value。如果该key不存在则返回defaultValue

• Object merge(Object key, Object value, BiFunction remappingFunction)：该方法会先根据Key参数获取该Map中对应的value。如果获得value为null，则直接用传入的value覆盖原有的value(在这中情况下，可能要添加一组key-value对)；如果获取的value不为null,则使用remappingFunction 函数根据原value、新value计算一新的结果，并用得到的结果去覆盖原有的value

• Object putIfAbsent(Object key, Object value)：该方法会自动检测指定key对应的value是否为null，如果该key对应的value为null，该方法将会用新value代替原来的null值

• Object replace(Object key, Object value)：将Map中指定key对应的value替换成新的value。与传统的put方法不同的是，该方法不可能添加新的key-value对。如果尝试替换的key在原Map中不存在，该方法不会添加key-value对，而是返回null

• boolean replace(K key, V oldValue, V newValue)
  将Map中指定key-value对的原value提换成新value。如果在Map中找到指定的key-value对，则执行替换并返回true,否额返回false

• replaceAll(Bifunction function)：该方法使用Bifunction 对原key-value对执行计算，并将计算结果作为key-value对的value的值

import java.util.*;

public class MapTest2
{
    public static void main(String[] args)
    {
        Map map = new HashMap();
        // 成对放入多个key-value对
        map.put("勒布朗詹姆斯", 6);
        map.put("凯文杜兰特", 35);
        map.put("斯蒂芬库里", 30);
        // 尝试替换key为"维斯布鲁克"的value，由于原Map中没有对应的key，
        // 因此对Map没有改变，不会添加新的key-value对
        map.replace("维斯布鲁克", 0);
        System.out.println(map);
        // 使用原value与参数计算出来的结果覆盖原有的value
        map.merge("勒布朗詹姆斯", 17 ,
            (oldVal , param) -> (Integer)oldVal + (Integer)param);
        System.out.println(map); // "勒布朗詹姆斯"的value增大了17，变为23
        // 当key为"詹姆斯哈登"对应的value为null（或不存在时），使用计算的结果作为新value
        map.computeIfAbsent("凯文加内特" , (key)->((String)key).length());
        System.out.println(map); // map中添加了 凯文加内特=5 这组key-value对
        // 当key为"凯文加内特"对应的value存在时，使用计算的结果作为新value
        map.computeIfPresent("凯文加内特",
            (key , value) -> (Integer)value + 16);
        System.out.println(map); // map中 凯文加内特=5 变成 凯文加内特=21
    }
}

Java8改进的HashMap和Hashtable实现类

HashMap和Hashtable都是Map接口的典型实现类，它们之间的关系完全类似于ArrayList和Vector的关系

使用HashMap存在key冲突时依然具有较好的性能

• Hashtable是一个线程安全的Map实现，但HashMap是线程不安全的实现，所以HashMap比Hashtable的性能高一点；但如果有多线程访问同一个Map对象时，使用Hashtable实现类会更好

• Hashtable不允许使用null作为key和value，如果试图把null值放进Hashtable中，将会引发NullPointerException异常；但HashMap可以使用null作为key或value

由于HashMap里的key不能重复，所以HashMap里最多只有一个key-value对的key为null，但可以有无数多个key-value对的value为null

public class NullInHashMap
{
    public static void main(String[] args)
    {
        HashMap hm = new HashMap();
        // 试图将两个key为null的key-value对放入HashMap中
        hm.put(null, null);
        hm.put(null, null);    // ①
        // 将一个value为null的key-value对放入HashMap中
        hm.put("a", null);    // ②
        // 输出Map对象
        System.out.println(hm);
    }
}

①代码处无法将key-value对放入，因为Map中已经有一个key-value对的key为null，所以无法再放入key为null值的key-value对

{null=null, a=null}

为了成功的在HashMap、Hashtable中存储、获取对象，用作key的对象必须实现hashCode()方法和equals()方法

与HashSet集合不能保证元素的顺序一样，HashMap、Hashtable也不能保证其中key-value对的顺序。类似于HashSet的是，HashMap、Hashtable判断两个key相等的标准也是：两个key通过equals方法比较返回true，两个key的hashCode值也相等。除此之外，HashMap、Hashtable中还包含一个containsValue()方法用于判断是否包含指定value。HashMap、Hashtable判断两个value相等的标准更简单：只要两个对象通过equals比较返回true即可

import java.util.Hashtable;

class A
{
    int count;
    public A(int count) 
    {
        this.count = count;
    }
    // 根据count的值来判断两个对象是否相等
    public boolean equals(Object obj) 
    {
        if (obj == this) 
        {
            return true;
        }
        if (obj != null && obj.getClass() == A.class) 
        {
            A a = (A)obj;
            return this.count == a.count; 
        }
        return false;
    }
    // 根据count来计算hashCode值
    public int hashCode() 
    {
        return this.count;
    }
}

class B
{
    // 重写equals()方法，B对象与任何对象通过equals()方法比较都返回ture
    public boolean equals() 
    {
        return true;
    }
}

public class HashtableTest2 
{
    public static void main(String[] args) 
    {
        Hashtable ht = new Hashtable<>();
        ht.put(new A(23), "勒布朗詹姆斯");
        ht.put(new A(0), "凯文乐福");
        // ht.put(new A(2), "凯里欧文");
        ht.put(new A(6), new B());
        System.out.println(ht);
        // 只要两个对象通过equals()方法比较返回true
        // Hashtable就认为它们是相等的value
        // 由于Hashtable中有一个B对象
        // 它与任何对象通过equals比较都相等，所以下面输出true
        System.out.println(ht.containsValue("克利夫兰骑士")); // ① 输出true
        // 只要两个A对象的count相等，它们通过equals比较返回true，且hashCode相等
        // Hashtable即认为它们是相同的key，所以下面输出true
        System.out.println(ht.containsKey(new A(23)));   // ② 输出true
        // 下面语句可以删除最后一个key-value对
        ht.remove(new A(6));    //③
        System.out.println(ht);
    }
}

与HashSet类似的是，如果使用可变对象作为HashMap、Hashtable的key，并且程序修改了作为key的可变对象，可能引发与HashSet类似的情形：程序无法准确访问到Map中被修改过key。 所以说尽量不要使用可变对象作为HashMapHashtable的key

LinkedHashMap实现类

HashSet有一个子类是LinkedHashSet,HashMap也有一个LinkedHashMap子类;LinkedHashMap也使用双向链表来维护key-value对的次序；该链表负责维护key的迭代顺序，迭代顺序与key-value的插入顺序一致

LinkedHashMap可以避免对HashMap、Hashtable里的key-value对进行排序（只要插入key-value对时保持顺序即可）。同时又可避免使用TreeMap所增加的成本

LinkedHashMap需要维护元素的插入顺序，因此性能略低于HashMap的性能，但在迭代访问Map里的全部元素时将有很好的性能，因为它以链表来维护内部顺序

public class LinkedHashMapTest
{
    public static void main(String[] args)
    {
        LinkedHashMap scores = new LinkedHashMap();
        scores.put("勒布朗詹姆斯", 23);
        scores.put("维斯布鲁克", 0);
        scores.put("斯蒂芬库里", 30);
        // 调用forEach方法遍历scores里的所有key-value对
        scores.forEach((key, value) -> System.out.println(key + "-->" + value));
    }
}

使用Properties读取属性文件

Properties类是Hashtable类的子类，用于处理属性文件（例如Windows操作平台上的ini文件）。Properties类可以把Map对象和属性文件关联起来，从而可以把Map对象中的key-value对写入属性文件，也可以把属性文件中的“属性名=属性值”加载到Map对象中。由于属性文件里的属性名、属性值只能是字符串类型，所以Properties里的key、value都是字符串类型

修改Properties里的key、value值的方法

• String getProperty(String key)：获取Properties中指定属性名对应的属性值，类似于Map的get(Object key)方法

• String getProperty(String key, String defaultValue)：该方法与前一个方法基本类似。该方法多一个功能，如果Properties中不存在指定key时，该方法返回默认值

• Object geProperty(String key、String value)：设置属性值，类似Hashtable的put方法

读、写属性文件的方法：

• void load(InputStream inStream)：从属性文件（以输入流表示）中加载属性名=属性值，把加载到的属性名=属性值对追加到Properties里（由于Properties是Hashtable)的子类，它不保证key-value对之间的次序）

• void Store(OutputStream out, String comment)：将Properties中的key-valu对写入指定属性文件（以输出流表示）

public class PropertiesTest
{
    public static void main(String[] args)
        throws Exception
    {
        Properties props = new Properties();
        // 向Properties中增加属性
        props.setProperty("username" , "LeBron");
        props.setProperty("teams" , "Cavaliers");
        // 将Properties中的key-value对保存到a.ini文件中
        props.store(new FileOutputStream("NBA.ini")
            , "comment line");   //①
        // 新建一个Properties对象
        Properties props2 = new Properties();
        // 向Properties中增加属性
        props2.setProperty("gender" , "male");
        // 将a.ini文件中的key-value对追加到props2中
        props2.load(new FileInputStream("NBA.ini") );   //②
        System.out.println(props2);
    }
}

SortedMap接口和TreeMap实现类

Map接口派生了一个SortedMap子接口，TreeMap为其实现类。类似TreeSet排序，TreeMap也是基于红黑树对TreeMap中所有key进行排序，从而保证TreeMap中所有key-value对处于有序状态。TreeMap两种排序方法：

• 自然排序：TreeMap的所有key必须实现Comparable接口，而且所有key应该是同一个类的对象，否则将会抛出ClassCastExcepiton异常

• 定制排序：创建TreeMap时，传入一个Comparator对象，该对象负责对TreeＭap中所有key进行排序。采用定制排序时不要求Map的key实现Comparable接口

TreeMap中判断两个key相等的标准是：两个key通过compareTo方法返回0，TreeMap即认为这两个key是相等的。

如果使用自定义的类作为TreeMap的key，应重新该类的equals方法和compareTo方法时应有一致的返回结果：即两个key通过equals方法比较返回true时，它们通过compareTo方法比较应该返回0。如果equals方法与compareTo方法的返回结果不一致，要么该TreeMap与Map接口的规则有出入（当equals比较返回true,但CompareTo比较不返回0时），要么TreeMap处理起来性能有所下降（当compareTo比较返回0，当equals比较不返回true时）

根据key顺序来访问Map中key-value对方法：

• Map.Entry firstEntry()：返回该Map中最小key所对应的key-value对，如果该Map为空，则返回null

• Map.Entry lastEntry()：返回该Map中最大key所对应的key-value对，如果该Map为空，或不存在这样的key-value都返回null

• Object firstKey()：返回该Map中的最小key值，如果该Map为空，则返回null

• Object lastKey()：返回该Map中的最大key值，如果该Map为空，或不存在这样的key都返回null

• Map.Entry higherEntry(Object key)：返回该Map中位于key后一位的key-value对（即大于指定key的最小key所对应的key-value对）。如果该Map为空，则返回null

• Map.Entry lowerEntry(Object key)：返回该Map中位于key前一位的key-value对（即小于指定key的最大key所对应的key-value对）。如果该Map为空，或不存在这样的key-value则返回null

• Object higherKey()：返回该Map中位于key后一位的key值（即大于指定key的最小key值）。如果该Map为空，或不存在这样的key都返回null

• Object lowerKey()：返回该Map中位于key前一位的key值（即小于指定key的最大key值）。如果该Map为空，或不存在这样的key都返回null

• NavigableMap subMap(Object fromKey, boolean fromInclusive, Object
  tokey, boolean tolnclusive)：返回该Map的子Map，其key的范围从fromKey(是否包括取决于第二个参数）到tokey（是否包括取决于第四个参数）。

• NavigableMap headMap(Object toKey, boolean lnclusive)：返回该Map的子Map，其key的范围是小于toKey（是否包括取决于第二个参数）的所有key

• NavigableMap tailMap(Object fromKey, boolean lnclusive)：返回该Map的子Map，其key的范围是大于fromKey（是否包括取决于第二个参数）的所有key

• SorterMap subMap(Object fromKey, Object toKey)：返回该Map的子Map，其key的范围从fromKey（包括）到toKey（不包括）

• SortedMap headMap(Object toKey)：返回该Map的子Map，其key的范围是小于tokey（是否包括取决于第二个参数）的所有key

• SortedMap tailMap(Object fromKey)：返回该Map的子Map，其key的范围是大于fromkey（是否包括取决于第二个参数）的所有key

class R implements Comparable
{
    int count;
    public R(int count)
    {
        this.count = count;
    }
    public String toString()
    {
        return "R[count:" + count + "]";
    }
    // 根据count来判断两个对象是否相等。
    public boolean equals(Object obj)
    {
        if (this == obj)
            return true;
        if (obj != null    && obj.getClass() == R.class)
        {
            R r = (R)obj;
            return r.count == this.count;
        }
        return false;
    }
    // 根据count属性值来判断两个对象的大小。
    public int compareTo(Object obj)
    {
        R r = (R)obj;
        return count > r.count ? 1 :
            count < r.count ? -1 : 0;
    }
}
public class TreeMapTest
{
    public static void main(String[] args)
    {
        TreeMap tm = new TreeMap();
        tm.put(new R(3) , "轻量级Java EE企业应用实战");
        tm.put(new R(-5) , "疯狂Java讲义");
        tm.put(new R(9) , "疯狂Android讲义");
        System.out.println(tm);
        // 返回该TreeMap的第一个Entry对象
        System.out.println(tm.firstEntry());
        // 返回该TreeMap的最后一个key值
        System.out.println(tm.lastKey());
        // 返回该TreeMap的比new R(2)大的最小key值。
        System.out.println(tm.higherKey(new R(2)));
        // 返回该TreeMap的比new R(2)小的最大的key-value对。
        System.out.println(tm.lowerEntry(new R(2)));
        // 返回该TreeMap的子TreeMap
        System.out.println(tm.subMap(new R(-1) , new R(4)));
    }
}

WeakHashMap

HashMap中的key保存的是实际对象的强引用，这意味着只要该HashMap对象不被销毁，该HashMap的所有key所引用的对象就不会被垃圾回收，HashMap也不会自动删除这些key所对应的key-value对

WeakHashMap中的key保存的是实际对象的弱引用，这意味着只要该WeakHashMap对象没被其他强对象引用变量引用，则这些key所引用的对象可能被垃圾回收，就有可能会被垃圾回收机制回收对应的Key-value，WeakHashMap也可能自动删除这些key所对应的key-value对

public class WeakHashMapTest
{
    public static void main(String[] args)
    {
        WeakHashMap whm = new WeakHashMap();
        // 将WeakHashMap中添加三个key-value对，
        // 三个key都是匿名字符串对象（没有其他引用）
        whm.put(new String("南特") , new String("Nantes"));
        whm.put(new String("巴黎") , new String("Paris"));
        whm.put(new String("波尔多") , new String("Bordeaux"));
        //将 WeakHashMap中添加一个key-value对，
        // 该key是一个系统缓存的字符串对象。
        whm.put("马赛" , new String("Marseille"));    // ①
        // 输出whm对象，将看到4个key-value对。
        System.out.println(whm);
        // 通知系统立即进行垃圾回收
        System.gc();
        System.runFinalization();
        // 通常情况下，将只看到一个key-value对。
        System.out.println(whm);
    }
}

当系统进行垃圾回收时，删除了WeakHashMap对象的前三个key-value对。因为添加前三个key-value对时，这三个key都是匿名的字符串对象，WeakHashMap只保留了对它们的弱引用，这样垃圾回收时会自动删除这三个key-value对。第4个key-value对的key是一个字符串直接量（系统会自动保留对该字符串对象的强引用），所以垃圾回收时不会回收它

IdentityHashMap实现类

IdentityHashMap的实现机制与HashMap基本相似，在IdentityHashMap中，判断两个key是否相等，是通过严格相等即（key1==key2）来判断的，而HashMap是通过equals()方法和hashCode()这两个方法来判断key是否相等的。IdentityHashMap允许使用null作为key和value，不保证key-value对之间的顺序，不保证它们的顺序随时间的推移保持不变

public class IdentityHashMapTest
{
    public static void main(String[] args)
    {
        IdentityHashMap ihm = new IdentityHashMap();
        // 下面两行代码将会向IdentityHashMap对象中添加两个key-value对
        ihm.put(new String("勒布朗詹姆斯") , 23);
        ihm.put(new String("勒布朗詹姆斯") , 6);
        // 下面两行代码只会向IdentityHashMap对象中添加一个key-value对
        ihm.put("科比布莱恩特" , 8);
        ihm.put("科比布莱恩特" , 24);
        System.out.println(ihm);
    }
}

前2个key-value对中的key是新创建的字符串对象，它们通过==比较不相等，所以IdentityHashMap会把它们当成2个key来处理；后2个key-value对中的key都是字符串直接量，而且它们的字符序列完全相同，Java使用常量池来管理字符串直接量，所以它们通过==比较返回true，IdentityHashMap会认为它们是同一个Key，因此只有一次可以添加成功

EnumMap实现类

EnumMap是一个与枚举类一起使用的Map实现，EnumMap中的所有key都必须是单个枚举类的枚举值。创建EnumMap时必须显式或隐式指定它对应的枚举类。EnumMap具有如下特征：

• EnumMap在内部以数组形式保存，所以这种实现形式非常紧凑、高效

• EunmMap根据key的自然顺序（即枚举值在枚举类中的定义顺序）来维护key-value对的顺序。当程序通过keySet()、entrySet()、values()等方法遍历EnumMap时可以看到这种顺序

• EnumMap不允许使用null作为key，但允许使用null作为value。如果试图使用null作为key时将抛出NullpointerException。如果只是查询是否包含值为null的key，或只是删除值为null的key，都不会抛出异常

enum NBA_Player
{
    James,Westbrook,Curry,Harden
}
public class EnumMapTest
{
    public static void main(String[] args)
    {
        // 创建EnumMap对象，该EnumMap的所有key都是Season枚举类的枚举值
        EnumMap enumMap = new EnumMap(NBA_Player.class);
        enumMap.put(NBA_Player.Westbrook, "俄克拉荷马雷霆");
        enumMap.put(NBA_Player.James, "克利夫兰骑士");
        System.out.println(enumMap);
    }
}

创建EnumMap对象时指定它的key只能是NBA_Player枚举类的枚举值。如果向该EnumMap中添加两个key-value对后，这两个key-value对将会以NBA_Player枚举值的自然顺序排序

各Map实现类的性能分析

HashMap和Hashtable的实现机制几乎一样，但由于Hashtable是一个古老的、线程安全的集合，因此HashMap通常比Hashtable要快

TreeMap比HashMap和Hashtable要慢（尤其在插入、删除key-value对时更慢），因为TreeMap底层采用红黑树来管理key-value对（红黑树的每个节点就是一个key-value对）
TreeMap中的key-value总是处于有序状态，无需专门进行排序操作。当TreeMap被填充后，就可以调用keySet()，取得由key组成的Set，然后使用toArray()方法生成key的数组，接下来使用Arrays的binarySearch()方法在已排序的数组中快速查询对象

LinkedHashMap比HashMap慢一点，因为它需要维护链表来保持Map中key-value时的添加顺序

IdentityHashMap性能没有特别出色支持，采用与HashMap基本相似的实现，只是它使用==而不是equals()方法来判断元素相等

EnumMap性能最好，但它只能使用同一个枚举类的枚举值作为key

对于一般的应用场景，程序应该多考虑使用HashMap，因为HashMap正是为快速查询设计的（HashMap底层其实也是采用数组来存储key-value对）。但如果程序需要一个总是排好序的Map时，则可以考虑使用TreeMap

HashSet和HashMap的性能选项

对于HashSet及其子类而言，它们采用hash算法来决定集合中元素的存储位置，并通过hash算法来控制集合的大小；
对于HashMap、Hashtable及其子类而言，它们采用hash算法来觉得Map中key的存储，并通过hash算法来增加key集合的大小

hash表里可以存储元素的位置被称为“桶(bucket)”，在通常情况下，单个“桶”里存储一个元素时，此时拥有最好的性能：hash算法可以根据hashCode值计算出“桶”的存储位置，接着从“桶”中取出元素。但hash表的状态是open的：在发生“hash冲突”的情况下，单个桶会存储多个元素，这些元素以链表形式存储，必须按顺序搜索。如下图所示是hash表保存各元素

因为HashSet和HashMap、Hashtable都使用hash算法来决定其元素（HashMap则只考虑key）的存储，因此HashSet、HashMap的hash表中包含如下属性

• 容量（capacity）：hash表中桶的数量

• 初始化容量（inital capacity）：创建hash表时桶的数量。HashMap和HashSet都允许在构造器中指定初始化容量

• 尺寸（size）：当前hash表中记录的数量

• 负载因子（load factor）：负载因子等于“size/capacity”。负载因子为0，表示空的hash表，0.5表示半满的hash表，依次类推。轻负载的hash表具有冲突少，适宜插入与查询的特点（但是用Iterator迭代元素时比较慢）

除此之外，hash表里还有一个“负载极限”是一个0~1的数值，“负载极限”决定了hash表的最大填满程序。
当hash表中的负载因子达到指定的“负载极限”时，hash表会自动成倍地增加容量（桶的数量），并将原有的对象重新分配，嵌入新的桶内，这称为rehashing

HashSet和HashMap、Hashtable的构造器允许指定一个负载极限，HashSet和HashMap、Hashtable默认的“负载极限”为0.75，这表明当该hash表的3/4已经被填满时，hash表会发生rehashing

“负载极限”的默认值（0.75）是时间和空间成本上的一种折中：较高的“负载极限”可以降低hash表所占用的内存空间，但会增加查询数据和时间的开销，而查询是最频繁的操作（HashMap的get()和put()方法都要用到查询）；
较低的“负载极限”会提高查询数据的性能，但会增加hash表所占用的内存开销。

如果开始就知道HashSet和HashMap、Hashtable会保存很多记录，则可以在创建时就使用较大的初始化容量，如果初始化容量始终大于HashSet、Hashtable和HashMap所包含的最大记录数除以“负载极限”，就不会发生rehashing。使用足够大的初始化容量创建HashSet和HashMap、Hashtable时，可以更高效地增加记录，但将初始化容量设置太高会浪费空间，所以不要讲初始化容量设置过高