java数组与集合框架（三）--Map，Hashtable，HashMap，LinkedHashMap，TreeMap

Map集合：

Map接口: 基于 键（key）/值（value）映射

Map接口概述

Map与Collection并列存在。用于保存具有映射关系的数据:key-value

• Map 中的key 和value 都可以是任何引用类型的数据
• Map 中的key 用Set来存放，不允许重复，即同一个Map 对象所对应的类，须重写hashCode()和equals()方法
• 常用String类作为Map的“键”
• key 和value 之间存在单向一对一关系，即通过指定的key 总能找到唯一的、确定的value
• Map接口的常用实现类：HashMap、TreeMap、LinkedHashMap和Properties。其中，HashMap是Map 接口使用频率最高的实现类
• |--Hashtable：底层是哈希表数据结构，是线程同步的。不可以存储null键，null值
• |--HashMap：底层是哈希表数据结构，是线程不同步的。可以存储null键，null值。替代了Hashtable。基于Map 接口的实现类;允许使用 null 值和 null 键;此类不保证映射的顺序;在多线程操作下不安全
• LinkedHashMap:
• 基于哈希表和链接列表的实现类;具有可预知的迭代顺序（双重链接表的有序性）
• |--TreeMap：底层是二叉树结构，可以对map集合中的键进行指定顺序的排序。
• Properties
• Hashtable的一个子类;属性列表中每个键及其对应值都是一个字符串;在多线程操作下安全

Map集合存储和Collection不同之处：

• Collection一次存一个元素；Map一次存一对元素。
• Collection是单列集合；Map是双列集合。
• Map中的存储的一对元素：一个是键，一个是值，键与值之间有对应(映射)关系。
• 特点：要保证map集合中键的唯一性。

Map接口：常用方法

添加、删除、修改操作：

Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中
void putAll(Map m):将m中的所有key-value对存放到当前map中
Object remove(Object key)：移除指定key的key-value对，并返回value
void clear()：清空当前map中的所有数据

元素查询的操作：

Object get(Object key)：获取指定key对应的value
boolean containsKey(Object key)：是否包含指定的key
boolean containsValue(Object value)：是否包含指定的value
int size()：返回map中key-value对的个数
boolean isEmpty()：判断当前map是否为空
boolean equals(Object obj)：判断当前map和参数对象obj是否相等

元视图操作的方法：

Set keySet()：返回所有key构成的Set集合
Collection values()：返回所有value构成的Collection集合
Set entrySet()：返回所有key-value对构成的Set集合
Collection values()：获取map集合中的所有的值。

想要获取map中的所有元素：

  原理：map中是没有迭代器的，collection具备迭代器，只要将map集合转成Set集合，可以使用迭代器了。之所以转成set，是因为map集合具备着键的唯一性，其实set集合就来自于map，set集合底层其实用的就是map的方法。

把map集合转成set的方法

Set keySet();//取的是键

Set entrySet();//取的是键和值的映射关系。

Entry就是Map接口中的内部接口；

为什么要定义在map内部呢？entry是访问键值关系的入口，是map的入口，访问的是map中的键值对。

取出map集合中所有元素的方式：

keySet()方法。

可以将map集合中的键都取出存放到set集合中。对set集合进行迭代。迭代完成，再通过get方法对获取到的键进行值的获取。

Set keySet = map.keySet();
Iterator it = keySet.iterator();
while(it.hasNext()) {
	Object key = it.next();
	Object value = map.get(key);
	System.out.println(key+":"+value);
}

entrySet()方法:

Set entrySet = map.entrySet();
Iterator it = entrySet.iterator();
while(it.hasNext()) {
	Map.Entry  me = (Map.Entry)it.next();
	System.out.println(me.getKey()+"::::"+me.getValue());
}

四种方式遍历Map集合：

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
public class TreeSetTest1 {
	public static void main(String[] args){
		Map<Integer,String> ts=new HashMap<Integer,String>();
		ts.put(2,"zhangshan");
		ts.put(3,"lishi");
		ts.put(1,"wangwu"); 
//第一种， 获取所有的key，然后借助集GET方法遍历MAP集合。
A:键找值
a:获取所有键的集合
b:遍历键的集合,得到每一个键
c:根据键到集合中去找值
		Set<Integer>keySet1= ts.keySet();
		for(Integer key:keySet1){
			System.out.println("第1个方法"+key+":"+ts.get(key));
		}
		
		Set<Integer>keySet3= ts.keySet();
		Iterator<Integer> it=keySet3.iterator();
		while(it.hasNext()){
			int key=it.next();
			System.out.println("第2个方法"+key+":"+ts.get(key));
		}
//第二中，将Map中的key及对应的value封装成Entry对象放到Set集合中，即调用Map集合的entryset方法，逐次遍历
B:键值对对象找键和值
a:获取所有的键值对对象的集合
b:遍历键值对对象的集合，获取每一个键值对对象
c:根据键值对对象去获取键和值

		Set<Entry<Integer,String>>keySet2= ts.entrySet();
		for(Entry<Integer,String> en:keySet2){
			System.out.println("第3个方法"+en.getKey()+":"+en.getValue());
		}
		
		Set<Entry<Integer,String>>keySet4= ts.entrySet();
		Iterator<Entry<Integer,String>>inte=keySet4.iterator();
		while(inte.hasNext()){
			Entry<Integer, String> en=inte.next();
			System.out.println("第4个方法"+en.getKey()+":"+en.getValue());
		}

		Set entrySet = ts.entrySet();
		Iterator it1 = entrySet.iterator();
		while(it1.hasNext()) {
			Map.Entry  me = (Map.Entry)it1.next();
			System.out.println(me.getKey()+"::::"+me.getValue());
		}
	}
}

Map实现类之一：HashMap

• HashMap是Map 接口使用频率最高的实现类。它不是线程同步的，同时也不保证有序。允许使用null键和null值，与HashSet一样，不保证映射的顺序。所有的key构成的集合是Set:无序的、不可重复的。所以，key所在的类要重写：equals()和hashCode()。所有的value构成的集合是Collection:无序的、可以重复的。所以，value所在的类要重写：equals()。一个key-value构成一个entry。所有的entry构成的集合是Set:无序的、不可重复的。
• HashMap 判断两个key 相等的标准是：两个key 通过equals() 方法返回true，hashCode值也相等。
• HashMap判断两个value相等的标准是：两个value 通过equals() 方法返回true。

HashMap的存储结构

HashMap源码中的重要常量

//默认的初始容量为16 
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//最大的容量上限为2^30 
static final int MAXIMUM_CAPACITY = 1 << 30;
//默认的负载因子为0.75 
static final float DEFAULT_LOAD_FACTOR = 0.75f; 
// Bucket中链表长度大于该默认值，转化为红黑树，变成树型结构的临界值为8 
static final int TREEIFY_THRESHOLD = 8;
 // Bucket中红黑树存储的Node小于该默认值，转化为链表，恢复链式结构的临界值为6 
static final int UNTREEIFY_THRESHOLD = 6; 
//哈希表 
transient Node<K,V>[] table; 
//哈希表中键值对的个数 
transient int size; 
//哈希表被修改的次数 
transient int modCount; 
//它是通过capacity*load factor计算出来的，当size到达这个值时，就会进行扩容操作 
int threshold; 
//负载因子
final float loadFactor;

//桶中的Node被树化时最小的hash表容量。（当桶中Node的数量大到需要变红黑树时，若hash表容量小于MIN_TREEIFY_CAPACITY时，此时应执行resize扩容操作这个MIN_TREEIFY_CAPACITY的值至少是TREEIFY_THRESHOLD的4倍。）。当哈希表的大小超过这个阈值，才会把链式结构转化成树型结构，否则仅采取扩容来尝试减少冲突

static final int MIN_TREEIFY_CAPACITY = 64； 
table：存储元素的数组，总是2的n次幂
entrySet：存储具体元素的集
size：HashMap中存储的键值对的数量
modCount：HashMap扩容和结构改变的次数。
threshold：扩容的临界值，=容量*填充因子
loadFactor：填充因子

Node 类的定义，它是 HashMap 中的一个静态内部类，哈希表中的每一个节点都是 Node 类型。我们可以看到，Node 类中有 4 个属性，其中除了 key 和 value 之外，还有 hash 和 next 两个属性。hash 是用来存储 key 的哈希值的，next 是在构建链表时用来指向后继节点的。

那么HashMap什么时候进行扩容和树形化呢？

当HashMap中的元素个数超过数组大小(数组总大小length,不是数组中个数size)*loadFactor时，就会进行数组扩容，loadFactor的默认值(DEFAULT_LOAD_FACTOR)为0.75，这是一个折中的取值。也就是说，默认情况下，数组大小(DEFAULT_INITIAL_CAPACITY)为16，那么当HashMap中元素个数超过16*0.75=12（这个值就是代码中的threshold值，也叫做临界值）的时候，就把数组的大小扩展为2*16=32，即扩大一倍，然后重新计算每个元素在数组中的位置，而这是一个非常消耗性能的操作，所以如果我们已经预知HashMap中元素的个数，那么预设元素的个数能够有效的提高HashMap的性能。

当HashMap中的其中一个链的对象个数如果达到了8个，此时如果capacity没有达到64，那么HashMap会先扩容解决，如果已经达到了64，那么这个链会变成树，结点类型由Node变成TreeNode类型。当然，如果当映射关系被移除后，下次resize方法时判断树的结点个数低于6个，也会把树再转为链表。

关于映射关系的key是否可以修改？answer：不要修改

映射关系存储到HashMap中会存储key的hash值，这样就不用在每次查找时重新计算每一个Entry或Node（TreeNode）的hash值了，因此如果已经put到Map中的映射关系，再修改key的属性，而这个属性又参与hashcode值的计算，那么会导致匹配不上。

总结：JDK1.8相较于之前的变化：

1. 1.HashMap map = new HashMap();//默认情况下，先不创建长度为16的数组
2. 2.当首次调用map.put()时，再创建长度为16的数组
3. 3.数组为Node类型，在jdk7中称为Entry类型
4. 4.形成链表结构时，新添加的key-value对在链表的尾部（七上八下）
5. 5.当数组指定索引位置的链表长度>8时，且map中的数组的长度> 64时，此索引位置上的所有key-value对使用红黑树进行存储。

负载因子值的大小，对HashMap有什么影响

•     负载因子的大小决定了HashMap的数据密度。
•     负载因子越大密度越大，发生碰撞的几率越高，数组中的链表越容易长,造成查询或插入时的比较次数增多，性能会下降。
•     负载因子越小，就越容易触发扩容，数据密度也越小，意味着发生碰撞的几率越小，数组中的链表也就越短，查询和插入时比较的次数也越小，性能会更高。但是会浪费一定的内容空间。而且经常扩容也会影响性能，建议初始化预设大一点的空间。
•     按照其他语言的参考及研究经验，会考虑将负载因子设置为0.7~0.75，此时平均检索长度接近于常数。

方法

get方法

public V get(Object key) {
Node<K,V> e;
//get方法主要调用的是getNode方法，所以重点要看getNode方法的实现
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}

final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
//如果哈希表不为空 && key对应的桶上不为空
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {
	//是否直接命中
        if (first.hash == hash && // always check first node
            ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
	//判断是否有后续节点
        if ((e = first.next) != null) {
            //如果当前的桶是采用红黑树处理冲突，则调用红黑树的get方法去获取节点
            if (first instanceof TreeNode)
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
	//不是红黑树的话，那就是传统的链式结构了，通过循环的方法判断链中是否存在该key
            do {
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}

实现步骤大致如下：

1、通过hash值获取该key映射到的桶。

2、桶上的key就是要查找的key，则直接命中。

3、桶上的key不是要查找的key，则查看后续节点：

（1）如果后续节点是树节点，通过调用树的方法查找该key。

（2）如果后续节点是链式节点，则通过循环遍历链查找该key。

put方法

public V put(K key, V value) {
//put方法的具体实现也是在putVal方法中，所以我们重点看下面的putVal方法
    return putVal(hash(key), key, value, false, true);
}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
//如果哈希表为空，则先创建一个哈希表
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
//如果当前桶没有碰撞冲突，则直接把键值对插入，完事
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
//如果桶上节点的key与当前key重复，那你就是我要找的节点
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
//如果是采用红黑树的方式处理冲突，则通过红黑树的putTreeVal方法去插入这个键值对
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
//否则就是传统的链式结构
        else {
//采用循环遍历的方式，判断链中是否有重复的key
            for (int binCount = 0; ; ++binCount) {
//到了链尾还没找到重复的key，则说明HashMap没有包含该键
                if ((e = p.next) == null) {
//创建一个新节点插入到尾部
                    p.next = newNode(hash, key, value, null);
//如果链的长度大于TREEIFY_THRESHOLD这个临界值，则把链变为红黑树
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }//找到了重复的key
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
//这里表示在上面的操作中找到了重复的键，所以这里把该键的值替换为新值
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
++modCount;
//判断是否需要进行扩容
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}
put方法比较复杂，实现步骤大致如下： 
1、先通过hash值计算出key映射到哪个桶。 
2、如果桶上没有碰撞冲突，则直接插入。 
3、如果出现碰撞冲突了，则需要处理冲突： 
	（1）如果该桶使用红黑树处理冲突，则调用红黑树的方法插入。 
	（2）否则采用传统的链式方法插入。如果链的长度到达临界值，则把链转变为红黑树。
4、如果桶中存在重复的键，则为该键替换新值。 
5、如果size大于阈值，则进行扩容。

remove方法

理解了put方法之后，remove已经没什么难度了，所以重复的内容就不再做详细介绍了。 
//remove方法的具体实现在removeNode方法中，所以我们重点看下面的removeNode方法
public V remove(Object key) {
    Node<K,V> e;
    return (e = removeNode(hash(key), key, null, false, true)) == null ?
        null : e.value;
}

final Node<K,V> removeNode(int hash, Object key, Object value,
                           boolean matchValue, boolean movable) {
Node<K,V>[] tab; Node<K,V> p; int n, index;
//如果当前key映射到的桶不为空
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (p = tab[index = (n - 1) & hash]) != null) {
        Node<K,V> node = null, e; K k; V v;
//如果桶上的节点就是要找的key，则直接命中
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            node = p;
        else if ((e = p.next) != null) {
//如果是以红黑树处理冲突，则构建一个树节点 
            if (p instanceof TreeNode)
                node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
//如果是以链式的方式处理冲突，则通过遍历链表来寻找节点
            else {
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key ||
                         (key != null && key.equals(k)))) {
                        node = e;
                        break;
                    }
                    p = e;
                } while ((e = e.next) != null);
            }
        }//比对找到的key的value跟要删除的是否匹配
        if (node != null && (!matchValue || (v = node.value) == value ||
                             (value != null && value.equals(v)))) {
//通过调用红黑树的方法来删除节点             
if (node instanceof TreeNode)
                ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
//使用链表的操作来删除节点
            else if (node == p)
                tab[index] = node.next;
            else
                p.next = node.next;
            ++modCount;
            --size;
            afterNodeRemoval(node);
            return node;
        }
    }
    return null;
}

hash方法

 

在get方法和put方法中都需要先计算key映射到哪个桶上，然后才进行之后的操作，计算的主要代码如下： 
(n - 1) & hash 
	上面代码中的n指的是哈希表的大小，hash指的是key的哈希值，
hash是通过下面这个方法计算出来的，采用了二次哈希的方式，其中key的hashCode方法是一个native方法： 
static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
	这个hash方法先通过key的hashCode方法获取一个哈希值，
再拿这个哈希值与它的高16位的哈希值做一个异或操作来得到最后的哈希值，
计算过程可以参考下图。为啥要这样做呢？注释中是这样解释的：如果当n很小，
假设为64的话，那么n-1即为63（0x111111），这样的值跟hashCode()直接做与操作，
实际上只使用了哈希值的后6位。如果当哈希值的高位变化很大，低位变化很小，
这样就很容易造成冲突了，所以这里把高低位都利用起来，从而解决了这个问题。 

正是因为与的这个操作，决定了HashMap的大小只能是2的幂次方，想一想，如果不是2的幂次方，会发生什么事情？即使你在创建HashMap的时候指定了初始大小，HashMap在构建的时候也会调用下面这个方法来调整大小： 
static final int tableSizeFor(int cap) {
    int n = cap - 1;
    n |= n >>> 1;
    n |= n >>> 2;
    n |= n >>> 4;
    n |= n >>> 8;
    n |= n >>> 16;
    return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
	这个方法的作用看起来可能不是很直观，它的实际作用就是把cap变成第一个大于等于2的幂次方的数。例如，16还是16，13就会调整为16，17就会调整为32。

resize方法

HashMap在进行扩容时，使用的rehash方式非常巧妙，因为每次扩容都是翻倍，
与原来计算（n-1）&hash的结果相比，只是多了一个bit位，所以节点要么就在原来的位置，要么就被分配到“原位置+旧容量”这个位置。 
例如，原来的容量为32，那么应该拿hash跟31（0x11111）做与操作；
在扩容扩到了64的容量之后，应该拿hash跟63（0x111111）做与操作。新容量跟原来相比只是多了一个bit位，假设原来的位置在23，那么当新增的那个bit位的计算结果为0时，那么该节点还是在23；
相反，计算结果为1时，则该节点会被分配到23+31的桶上。
正是因为这样巧妙的rehash方式，保证了rehash之后每个桶上的节点数必定小于等于原来桶上的节点数，即保证了rehash之后不会出现更严重的冲突。
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);
    }//新的resize阈值
    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;
}
在这里有一个需要注意的地方，有些文章指出当哈希表的桶占用超过阈值时就进行扩容，这是不对的；
实际上是当哈希表中的键值对个数超过阈值时，才进行扩容的。

总结

通过红黑树的方式来处理哈希冲突是我第一次看见！学过哈希，学过红黑树，就是从来没想到两个可以结合到一起这么用 ！

按照原来的拉链法来解决冲突，如果一个桶上的冲突很严重的话，是会导致哈希表的效率降低至O（n），而通过红黑树的方式，可以把效率改进至O（logn）。相比链式结构的节点，树型结构的节点会占用比较多的空间，所以这是一种以空间换时间的改进方式。

Map实现类之二：LinkedHashMap

LinkedHashMap是HashMap的子类

在HashMap存储结构的基础上，使用了一对双向链表来记录添加元素的顺序

与LinkedHashSet类似，LinkedHashMap可以维护Map 的迭代顺序：迭代顺序与Key-Value 对的插入顺序一致

HashMap中的内部类：Node

static class Node<K,V> implements Map.Entry<K,V> {
	final int hash;
	final K key;
	V value;
	Node<K,V> next;
}

LinkedHashMap中的内部类：Entry

static class Entry<K, V> extends HashMap.Node<K, V> {
       Entry<K, V> before, after;

      Entry(int hash, K key, V value, Node<K, V> next) {
            super(hash, key, value, next);
      }
}

Map实现类之三：TreeMap

• TreeMap存储Key-Value 对时，需要根据key-value 对进行排序。TreeMap可以保证所有的Key-Value 对处于有序状态。
• TreeSet底层使用红黑树结构存储数据
• TreeMap的Key 的排序：
• 自然排序：TreeMap的所有的Key 必须实现Comparable 接口，而且所有的Key 应该是同一个类的对象，否则将会抛出ClasssCastException
• 定制排序：创建TreeMap时，传入一个Comparator 对象，该对象负责对TreeMap中的所有key 进行排序。此时不需要Map 的Key 实现Comparable 接口
• TreeMap判断两个key相等的标准：两个key通过compareTo()方法或者compare()方法返回0。

Map实现类之四：Hashtable

• Hashtable是个古老的Map 实现类，JDK1.0就提供了。不同于HashMap，Hashtable是线程安全的。
• Hashtable实现原理和HashMap相同，功能相同。底层都使用哈希表结构，查询速度快，很多情况下可以互用。
• 与HashMap不同，Hashtable不允许使用null 作为key 和value
• 与HashMap一样，Hashtable也不能保证其中Key-Value 对的顺序
•  Hashtable判断两个key相等、两个value相等的标准，与HashMap一致。

Map实现类之五：Properties

Properties 类是Hashtable的子类，该对象用于处理属性文件

由于属性文件里的key、value 都是字符串类型，所以Properties 里的key 和value 都是字符串类型

存取数据时，建议使用setProperty(String key,Stringvalue)方法和getProperty(String key)方法

Properties pros= newProperties();
pros.load(newFileInputStream("jdbc.properties"));
String user= pros.getProperty("user");
System.out.println(user); 

Collections：

• 它的出现给集合操作提供了更多的功能。这个类不需要创建对象，内部提供的都是静态方法。是针对集合进行操作的工具类
• Collections 是一个操作Set、List和Map 等集合的工具类
• Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法

排序操作：（均为static方法）

• reverse(List)：反转List 中元素的顺序
• shuffle(List)：对List集合元素进行随机排序
• sort(List)：根据元素的自然顺序对指定List 集合元素按升序排序
• sort(List，Comparator)：根据指定的Comparator 产生的顺序对List 集合元素进行排序
• swap(List，int，int)：将指定list 集合中的i处元素和j 处元素进行交换

静态方法：

Collections.sort(list);//list集合进行元素的自然顺序排序。
Collections.sort(list,new ComparatorByLen());//按指定的比较器方法排序。
class ComparatorByLen  implements Comparator<String>{
		public int compare(String s1,String s2){
			int temp = s1.length()-s2.length();
			return temp==0?s1.compareTo(s2):temp;
		}
}
Collections.max(list); //返回list中字典顺序最大的元素。
int index = Collections.binarySearch(list,"zz");//二分查找，返回角标。
Collections.reverseOrder();//逆向反转排序。
Collections.shuffle(list);//随机对list中的元素进行位置的置换。

Collection 和 Collections的区别：

• Collections是个java.util下的类，是针对集合类的一个工具类,提供一系列静态方法,实现对集合的查找、排序、替换、线程安全化（将非同步的集合转换成同步的）等操作。
• Collection是个java.util下的接口，它是各种集合结构的父接口，继承于它的接口主要有Set和List,提供了关于集合的一些操作,如插入、删除、判断一个元素是否其成员、遍历等。

Collections常用方法：同步控制

将非同步集合转成同步集合的方法：

Collections中的  XXX synchronizedXXX(XXX);
List synchronizedList(list);
Map synchronizedMap(map);

原理：定义一个类，将集合所有的方法加同一把锁后返回。

查找、替换

max(Collection <? extends T> coll)：
    根据元素的自然顺序，返回给定集合元素中的最大元素
min(Collection <? extends T> coll)：
    根据元素的自然顺序，返回给定集合元素中的最小元素
sort(List<T> list) ：
    根据元素的自然顺序 对指定列表按升序进行排序。列表中的所有元素都必须实现 Comparable 接口。
sort(List<T> list, Comparator<? super T> c)  ： 
    根据指定比较器产生的顺序对指定列表进行排序
reverse(List<?> list)：
    反转指定列表中元素的顺序
swap(List<?> list, int i, int j)：
    在指定列表的指定位置处交换元素，如果指定位置相同，则调用此方法不会更改列表。
binarySearch(List<? extends Comparable<? super T>> list, T key) ：
    返list集合元素按照自然顺序升序排序后，使用二分搜索法搜索list集合，返回指定对象的索引，如果没找到返回-1。

。

Arrays：

用于操作数组对象的工具类，里面都是静态方法。

asList方法：将数组转换成list集合。

String[] arr = {"abc","kk","qq"};

List<String> list = Arrays.asList(arr);//将arr数组转成list集合。

将数组转换成集合，有什么好处呢？用aslist方法，将数组变成集合；

• 可以通过list集合中的方法来操作数组中的元素：isEmpty()、contains、indexOf、set；
• 注意（局限性）：数组是固定长度，不可以使用集合对象增加或者删除等，会改变数组长度的功能方法。比如add、remove、clear。（会报不支持操作异常Unsupported Operation Exception）；
• 如果数组中存储的引用数据类型，直接作为集合的元素可以直接用集合方法操作。
• 如果数组中存储的是基本数据类型，asList会将数组实体作为集合元素存在。

集合变数组：

• 用的是Collection接口中的方法：toArray();
• 如果给toArray传递的指定类型的数据长度小于了集合的size，那么toArray方法，会自定再创建一个该类型的数据，长度为集合的size。
• 如果传递的指定的类型的数组的长度大于了集合的size，那么toArray方法，就不会创建新数组，直接使用该数组即可，并将集合中的元素存储到数组中，其他为存储元素的位置默认值null。
• 所以，在传递指定类型数组时，最好的方式就是指定的长度和size相等的数组。

将集合变成数组后有什么好处？

限定了对集合中的元素进行增删操作，只要获取这些元素即可。

---------------------------------------------------------------------------------------------------------------------------------