Java集合——HashMap、TreeMap、Hashtable

Map接口有很多常用的类，较常用的有HashMap和TreeMap。

1.哈希映射类：HashMap类

Java 7（数组+链表）和Java 8（数组+链表（但大于一定值会转化为红黑树））
不是线程安全的，因为没有锁（但是效率高（因为这个锁要与系统交互）），会导致并发问题（扩容的时候有影响）

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

HashMap类是实现的Map集合，对于元素的添加和删除有着较高的效率，因为HashMap类是基于哈希表的Map接口实现的，HashMap类允许使用null值和null键；

数组默认大小为16（数组的长度必须是2的次方） ，因为：在HashMap中我们需要的是用key的一个hashcode值来进行一个计算位置，尽量去依赖hashcode，而当比如容量是15，那会去取01110(14)的一个膜，此时hashcode的最后一位无论是0还是1 ，结果都是 0 ，与它自身的值无关，所以java中规定容量必须是2的平方数，这样取模时低位都是1，取出来的位置完全依赖hashcode，
这里写图片描述

每次2倍扩容，加载因子0.75 ，数组到了阈值（容量*加载因子）16*0.75=12就扩容，插入删除算法的时间复杂度趋近于O(1)，

1.向Map集合中添加和获取集合中的内容
put(K key, V value) 插入元素
get(Object key) 获取元素
Map集合中，key和value是一一对应的，所以可以通过指定的key获取其对应的value

import java.util.Map;
import java.util.HashMap;
public class HashMapDemo01 {
    public static void main(String[] args) {
        Map<Integer,String> map=new HashMap<Integer,String>();  //通过HashMap实例化Map
        map.put(1,"清华大学");                                  //添加内容
        map.put(2,"北京大学");                                  //添加内容
        map.put(3,"复旦大学");                                  //添加内容
        map.put(4,"武汉大学");                                  //添加内容
        map.put(5,"中国科技大学");                                //添加内容
        map.put(6,"中国矿业大学");                                //添加内容
        System.out.println("获取内容："+map.get(6));         //获取内容
    }
}

中国矿业大学

2.获取Map集合中的全部的key和value

keySet() 获取Map集合中的全部的key，keySet() 将Map集合中的所有值转换为Set集合，再使用Iterator输出；
values() 获取Map集合中的全部的value， values() 返回的是Collection集合，同样以Iterator输出；

import java.util.Collection;
import java.util.Set;
import java.util.Iterator;
import java.util.Map;
import java.util.HashMap;
public class HashMapDemo02 {
    public static void main(String[] args) {
        Map<Integer,String> map=new HashMap<Integer,String>();  //通过HashMap实例化Map
        map.put(1,"清华大学");                                  //添加内容
        map.put(2,"北京大学");                                  //添加内容
        map.put(3,"复旦大学");                                  //添加内容
        map.put(4,"武汉大学");                                  //添加内容
        map.put(5,"中国科技大学");                                //添加内容
        map.put(6,"中国矿业大学");                                //添加内容
        Set<Integer> set = map.keySet();                        //将集合中全部的key转换为Set集合
        Iterator<Integer> itKey = set.iterator();               //实例化Iterator
        System.out.println("Map集合中全部的key：");
        while (itKey.hasNext()){                                //判断是否还有key
            System.out.print(itKey.next()+"  ");                //输出key
        }
        System.out.println();
        Collection<String> c = map.values();                    //将集合中全部的value转换为Collection集合
        Iterator<String> itValue =c.iterator();                 //实例化Iterator
        System.out.println("Map集合中全部的value：");
        while (itValue.hasNext()){                              //判断是否还有value
            System.out.print(itValue.next()+"  ");              //输出value
        }
    }
}

Map集合中全部的key：
1  2  3  4  5  6  
Map集合中全部的value：
清华大学  北京大学  复旦大学  武汉大学  中国科技大学  中国矿业大学

3.使用Iterator输出Map集合
Map集合与Collection集合不同，其本身不能直接使用Iterator进行输出(因为Map集合使用的是二元偶对象，而Iterator一次只能输出一个值。所以，要做一下步骤处理：

Map实例通过entrySet()方法转换为Set集合；
再由Set集合实例化Iterator，这时Iterator迭代器可以输出Map.Entry对象；
最后，通过Map.Entry的getKey()和getValue方法分离Map集合的key-value

import java.util.Set;
import java.util.Iterator;
import java.util.Map;
import java.util.HashMap;
public class HashMapDemo03 {
    public static void main(String[] args) {
        Map<Integer,String> map=new HashMap<Integer,String>();          //通过HashMap实例化Map
        map.put(1,"清华大学");                                          //添加内容
        map.put(2,"北京大学");                                          //添加内容
        map.put(3,"复旦大学");                                          //添加内容
        map.put(4,"武汉大学");                                          //添加内容
        map.put(5,"中国科技大学");                                        //添加内容
        map.put(6,"中国矿业大学");                                        //添加内容
        Set<Map.Entry<Integer,String>> set = map.entrySet();            //将Map集合转换为Set集合
        Iterator<Map.Entry<Integer,String>> it = set.iterator();        //实例化Iterator
        System.out.println("Key-----Value");
        while (it.hasNext())                                            //判断是否还有元素
        {
            Map.Entry<Integer,String> mapEntry =it.next();              //实例化Map.Entry
            System.out.println(" "+mapEntry.getKey()+"----"+mapEntry.getValue());//分离key和value
        }
    }
}

Key-----Value
 1----清华大学
 2----北京大学
 3----复旦大学
 4----武汉大学
 5----中国科技大学
 6----中国矿业大学

Map集合还可以使用foreach方式输出：
使用foreach方式输出Map集合可以不用通过Set集合，只需要将集合中的每一个元素用Map.Entry类型的对象接收，再使用getKey()和getValue()分离key-value。

import java.util.Map;
import java.util.HashMap;
public class HashMapDemo04 {
    public static void main(String[] args) {
        Map<Integer,String> map=new HashMap<Integer,String>();  //通过HashMap实例化Map
        map.put(1,"清华大学");                                  //添加内容
        map.put(2,"北京大学");                                  //添加内容
        map.put(3,"复旦大学");                                  //添加内容
        map.put(4,"武汉大学");                                  //添加内容
        map.put(5,"中国科技大学");                                //添加内容
        map.put(6,"中国矿业大学");                                //添加内容
        System.out.println("Key-----Value");
        for (Map.Entry<Integer,String> mapEntry : map.entrySet()){
            System.out.println(" "+mapEntry.getKey()+"----"+mapEntry.getValue());
                                                                //分离key和value
        }
    }
}

2.有序数映射类：TreeMap类

public class TreeMap<K,V> extends AbstractMap<K,V> implements NavigableMap<K,V>,Cloneable,Serializable

TreeMap类不但实现了Map接口，还实现了SortedMap接口，因此，TreeMap集合具有有序性，与HashMap相比，TreeMap集合对元素的添加、删除的定位映射性能较低
TreeMap集合主要是对key进行排序，从而保证所有的key-value映射关系处于有序状态，其默认的排序方式是升序排序。
HashMap是无序的，若想输出有序的Map集合，可将HashMap集合中的内容添加到TreeMap集合汇总，再由其输出即可：

import java.util.Collection;
import java.util.Set;
import java.util.Iterator;
import java.util.Map;
import java.util.HashMap;
import java.util.TreeMap;
public class TreeMapDemo01 {
    public static void main(String[] args) {
        Map<String,String> hashMap=new HashMap<String,String>();            //通过HashMap实例化Map
        hashMap.put("THU","清华大学");                                      //添加内容
        hashMap.put("CUMT","中国矿业大学");                                   //添加内容
        hashMap.put("FU","复旦大学");                                       //添加内容
        hashMap.put("USTC","中国科技大学");                                   //添加内容
        hashMap.put("WHU","武汉大学");                                      //添加内容
        hashMap.put("PKU","北京大学");                                      //添加内容
        Set<Map.Entry<String,String>> hashSet = hashMap.entrySet();         //将Map集合转换为Set集合
        Iterator<Map.Entry<String,String>> hashIt = hashSet.iterator();     //实例化Iterator
        System.out.println("****使用HashMap输出：****");
        while (hashIt.hasNext())                                            //判断是否还有元素
        {
            Map.Entry<String,String> hashEntry = hashIt.next();             //实例化Map.Entry
            System.out.println(hashEntry.getKey()+"----"+hashEntry.getValue());
                                                                            //分离key和value
        }
        Map<String,String> treeMap=new TreeMap<String,String>();
        treeMap.putAll(hashMap);                                            //向TreeMap集合中添加HashMap集合
        Set<Map.Entry<String,String>> treeSet = treeMap.entrySet();         //将Map集合转换为Set集合
        Iterator<Map.Entry<String,String>> treeIt = treeSet.iterator();     //实例化Iterator
        System.out.println("\n****使用TreehMap输出：****");
        while (treeIt.hasNext())                                            //判断是否还有元素
        {
            Map.Entry<String,String> treeEntry =treeIt.next();              //实例化Map.Entry
            System.out.println(treeEntry.getKey()+"----"+treeEntry.getValue());
                                                                            //分离key和value
        }
    }
}

****使用HashMap输出：****
USTC----中国科技大学
FU----复旦大学
WHU----武汉大学
PKU----北京大学
THU----清华大学
CUMT----中国矿业大学

****使用TreehMap输出：****
CUMT----中国矿业大学
FU----复旦大学
PKU----北京大学
THU----清华大学
USTC----中国科技大学
WHU----武汉大学

3.Hashtable类

Hashtable默认的初始大小为11，之后每次扩充，容量变为原来的2n+1

public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V>,Cloneable,Serializable

Hashtable类是Map类的子类，它与Vector类型一样都是在JDK 1.0时出现的，属于元老级的操作类，Hashtable类是同步的、线程安全的，不允许存放null键和null值，其他功能与HashMap类似；

这里写图片描述

import java.util.Set;
import java.util.Iterator;
import java.util.Map;
import java.util.Hashtable;
public class HashtableDemo01 {
    public static void main(String[] args) {
        Map<String,String> map=new Hashtable<String,String>();              //通过HashMap实例化Map
        map.put("THU","清华大学");                                  //添加内容
        map.put("CUMT","中国矿业大学");                               //添加内容
        map.put("FU","复旦大学");                                       //添加内容
        map.put("USTC","中国科技大学");                               //添加内容
        map.put("WHU","武汉大学");                                  //添加内容
        map.put("PKU","北京大学");                                  //添加内容
        Set<Map.Entry<String,String>> set = map.entrySet();             //将Map集合转换为Set集合
        Iterator<Map.Entry<String,String>> it = set.iterator();                 //实例化Iterator
        System.out.println("Key-----Value");
        while (it.hasNext())                                            //判断是否还有元素
        {
            Map.Entry<String,String> mapEntry =it.next();                   //实例化Map.Entry
            System.out.println(" "+mapEntry.getKey()+"----"+mapEntry.getValue());
                                                                //分离key和value
        }
    }
}

Key-----Value
 CUMT----中国矿业大学
 WHU----武汉大学
 PKU----北京大学
 USTC----中国科技大学
 THU----清华大学
 FU----复旦大学