HashMap、LinkedHashMap和TreeMap的区别

1、有序性

HashMap                无序

LinkedHashMap      有序(存值的顺序)

TreeMap                  有序(键值的顺序)

2、实现及效率

HashMap                是基于散列表，基于哈希表实现，时间复杂度平均能达到O(1)。

LinkedHashMap      HashMap和双向链表合二为一即是LinkedHashMap时间复杂度O(1)。

TreeMap                  基于红黑树（一种自平衡二叉查找树）实现的，时间复杂度平均能达到O(log n)。

HashMap与TreeMap 比较，HashMap查询效率高但是无序，TreeMap有序但是查询效率低。LinkedHashMap保证有序和查询效率。

3、线程安全

HashMap              非线程安全

LinkedHashMap   非线程安全

TreeMap               线程安全

4、key是否可以为null

HashMap              可以

LinkedHashMap   可以

TreeMap               不可以(会报错java.lang.NullPointerException)

代码如下：

package com.soecode.lyf.web.test;

import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.TreeMap;

public class MapTest {
	public static void main(String[] args) {
		System.out.println("input          1 : 1     3 : 3     2 : 2     4 : 4     5 : 5");
		
		//HashMap
		Map<String,String> hashMap = new HashMap<String,String>();
		hashMap.put("1", "1");
		hashMap.put("3", "3");
		hashMap.put("2", "2");
		hashMap.put("4", "4");
		hashMap.put("5", "5");
		System.out.print("HashMap        ");
		for(String key : hashMap.keySet()){
			System.out.print(key+" : "+hashMap.get(key)+"     ");
		}
		System.out.println();
		
		
		
		
		//LinkedHashMap
		Map<String,String> linkedHashMap = new LinkedHashMap<String,String>();
		linkedHashMap.put("1", "1");
		linkedHashMap.put("3", "3");
		linkedHashMap.put("2", "2");
		linkedHashMap.put("4", "4");
		linkedHashMap.put("5", "5");
		System.out.print("LinkedHashMap  ");
		for(String key:linkedHashMap.keySet()){
			System.out.print(key+" : "+linkedHashMap.get(key)+"     ");
		}
		System.out.println();
		
		
		
		
		
		//TreeMap
		Map<String,String> treeMap = new TreeMap<String,String>();
		treeMap.put("1", "1");
		treeMap.put("3", "3");
		treeMap.put("2", "2");
		treeMap.put("4", "4");
		treeMap.put("5", "5");
		System.out.print("TreeMap        ");
		for(String key:treeMap.keySet()){
			System.out.print(key+" : "+treeMap.get(key)+"     ");
		}
		System.out.println();
		
		//TreeMap重写Comparator 顺序
		Map<String,String> treeMapCompare1 = new TreeMap<String,String>(
				new Comparator<String>() {
					@Override
					public int compare(String o1, String o2) {
						//顺序
						return o1.compareTo(o2);
					}
				});
		treeMapCompare1.put("1", "1");
		treeMapCompare1.put("3", "3");
		treeMapCompare1.put("2", "2");
		treeMapCompare1.put("4", "4");
		treeMapCompare1.put("5", "5");
		System.out.print("TreeMapCompare ");
		for(String key:treeMapCompare1.keySet()){
			System.out.print(key+" : "+treeMapCompare1.get(key)+"     ");
		}
		System.out.println();
		
		
		//TreeMap重写Comparator 倒序
		Map<String,String> treeMapCompare = new TreeMap<String,String>(
				new Comparator<String>() {
					@Override
					public int compare(String o1, String o2) {
						//倒序
						return o2.compareTo(o1);
					}
				});
		treeMapCompare.put("1", "1");
		treeMapCompare.put("3", "3");
		treeMapCompare.put("2", "2");
		treeMapCompare.put("4", "4");
		treeMapCompare.put("5", "5");
		System.out.print("TreeMapCompare ");
		for(String key:treeMapCompare.keySet()){
			System.out.print(key+" : "+treeMapCompare.get(key)+"     ");
		}
		System.out.println();
		
	}
}

打印结果如下：

input          1 : 1     3 : 3     2 : 2     4 : 4     5 : 5
HashMap        3 : 3     2 : 2     1 : 1     5 : 5     4 : 4     
LinkedHashMap  1 : 1     3 : 3     2 : 2     4 : 4     5 : 5     
TreeMap        1 : 1     2 : 2     3 : 3     4 : 4     5 : 5     
TreeMapCompare 1 : 1     2 : 2     3 : 3     4 : 4     5 : 5     
TreeMapCompare 5 : 5     4 : 4     3 : 3     2 : 2     1 : 1 

按照打印结果可以看出HashMap是无序的，LinkedHashMap是按照存入的顺序，TreeMap是按照Comparator比较的顺序。

另外如果允许多线程访问可以用ConcurrentHashMap,ConcurrentHashMap的目标是实现支持高并发、高吞吐量的线程安全的HashMap。当然不能直接对整个hashtable加锁，所以在ConcurrentHashMap中，数据的组织结构和HashMap有所区别。一个ConcurrentHashMap由多个segment组成，每一个segment都包含了一个HashEntry数组的hashtable， 每一个segment包含了对自己的hashtable的操作，比如get，put，replace等操作，这些操作发生的时候，对自己的hashtable进行锁定。由于每一个segment写操作只锁定自己的hashtable，所以可能存在多个线程同时写的情况，性能无疑好于只有一个hashtable锁定的情况。ConcurrentHashMap塞值如下：

Map<String,String> cMap = new ConcurrentHashMap<String,String>();
		cMap.put("a1", "1");
		cMap.put("a3", "3");
		cMap.put("a2", "2");
		cMap.put("a4", "4");
		cMap.put("a5", "5");
		for(String key:cMap.keySet()){
			System.out.print(key+" : "+cMap.get(key)+"     ");
		}

打印的结果是:

a5 : 5     a2 : 2     a3 : 3     a1 : 1     a4 : 4     

由此可见ConcurrentHashMap是无序的。