java基础：13.7 集合框架 - Map（HashMap、LinkedHashMap 、TreeMap）

映射表
可以使用三个具体的类来创建一个映射表: HashMap 、LinkedHashMap 、TreeMap 。
HashMap 、LinkedHashMap 、TreeMap 类是Map接口的三个具体实现。
 
Map 接口存储一组键值对象，提供key（键）到value（值）的映射。
 
实现Map 接口的所有具体类至少有两种构造方法:
一种是无参构造方法，它可用来创建一个空映射表，
另一种构造方法是从Map 的一个实例来创建映射表。Map <String,Integer> treemap = new TreeMap<>(hashmap)

1、Map

Map的集合视角方法使Map可以像Collection一样进行操作元素

• KeySet–返回Map集合中键的Set集合
• Values–返回Map集合中值的Collection集合
• entrySet–返回Map集合中键值对对象的Set集合.在Map中提供了一个小的嵌套接口Map.Entry,它就是Map的键值对对象.

Map没有实现Iterable接口，所以集合视角是Map集合遍历的唯一手段，并且每次获取Map集合视角的时候，返回的是相同的对象。集合视角支持removal类型操作，但是任何情况下都不支持addition，对集合视角的removal操作会影响到Map集合本身，比如map.keySet().clear()将会清空map，反之亦然，这和Set,List的视图一样。

使用集合视角有一些有意思的用法,比如判断一个Map是否是另一个Map的子集
if (m1.entrySet().containsAll(m2.entrySet())) {}

类似,也可以判断两个Map的是否拥有相同的键
if (m1.keySet().equals(m2.keySet())) {}

 

2、子接口

Map和Set接口从形式上有些类似,类比与SortedSet和NavigableSet,Map也有SortedMap和NavigableMap两个接口,实际上Set的实现底层就是使用的Map存储数据.

SortedMap将元素的键以自然排序,或者依照给定的排序器来进行排序,同SortedSet,SortedMap提供了以下几种操作.

• 视图–允许从SortedMap截取并返回任意范围的元素视图
• 端点操作—可以直接获取集合头或尾的元素
• 排序器—返回用于排列元素的排序器

Map集合并无法直接实现遍历,而是通过它的集合视角遍历元素,所以SortedMap在返回的集合视角中,集合视角的迭代器也将会按SortedMap的顺序进行排序,同理的SortedMap中toArray方法返回的数组也是如此,toString方法会返回一个包含所有元素,并排序好的字符串.
 

3、实现

Map的实现可以分成通用实现,专用实现,并发实现

通用实现有三个：HashMap、TreeMap、LinkedHashMap.

如果我们想要对元素进行一些排序操作,那么应当使用TreeMap,

如果我们想要最好的性能而不在乎是否排序,应当使用HashMap,

如果需要和HashMap接近的性能,并且可以以插入顺序遍历,那么应当使用LinkedHashMap.这和Set的通用实现很类似.

此外LinkedHashMap不仅提供了插入排序(insert order),同时还提供访问排序(access order),这样LinkedHashMap非常适用做本地缓存类(LRU)

专用实现也有三个：Enummap、WeakHashMap、IdentityHashMap.　　
　　
EnumMap是一个高性能的以枚举为键的Map集合,它内部是以数组实现.EnumMap将Map集合的丰富功能和安全性与数组的快速访问结合起来,如果想要实现一个用枚举映射值得结构,应当使用EnumMap.

WeakHashMap只存储弱引用类型的key,当它内部的元素的键不再被外界引用时,其键值对就可以被垃圾回收期(GC)回收,被从WeakHashMap中移除.WeakHashMap提供最简单利用弱引用的方法,这对实现”registry-like”数据结构非常有用.

IdentityHashMap存储元素时,不使用equal方法比较键对象,而是使用==来对比,适用于实现对象拓扑结构转换,比如对象序列化或深度拷贝时,作为一个”节点表”来跟踪处理那些已经处理过的对象引用.

Java.util.concurrent 包含ConcurrentMap接口,它继承自Map,其putIfAbsent,remove,和replace方法是原子性的.ConcurrentHashMap是它的实现.

ConcurrentHashMap 是一个高并发高性能的基于哈希表的实现,当检索元素时永不会阻塞,并且当执行update允许客户端选定执行并发级别更新.它是HashMap的替代,ConcurrentHashMap除了实现ConcurrentMap还支持HashTable所有遗留的独有的操作.
 
 

4、HashMap概念

HashMap 是一个散列表，它存储的内容是键值对(key-value) 的映射。
该类实现了Map接口，根据键的HashCode值存储数据，具有很快的访问速度，最多允许一条记录的键为null，不支持线程同步。
HashMap类中的条目是没有顺序。
对于定位一个值、插入一个条目以及删除一个条目而言， HashMap 类是高效的。
在遍历拍好顺序的键时，TreeMap是高效的。（键可以使用COmparable接口或Comparator接口来排序）

LinkedHashMap支持条目排序，
 
 

4.1、主要实现方法

get ：进行值的读取 String vlaues = map.get(“key”);//获取map中键值为“key”的值

更新方法
clear() ： 删除所有的条目

put(K key,V value) ：参数和值的存储 map.put(“key”,“value”);
如果这个映射表原来就包含该键的一个条目，则原来的值将被新的值所替代，并且返回与这个键相关联的原来的值。

putAll(Map m) ：将m 中的所有条目添加到这个映射表中

remove（Object key) ：把指定键对应的条目从映射表删除

查询方法
containsKey()bject key) ：映射表中是否含有指定键的条目

containsValue()bject value) ：映射表中是否含有指定值的条目

isEmpty() ：映射表中是否含有条目

size() ：返回条目个数

keySet() ：获得一个包含映射表中键的集合
values() ：获得一个包含映射表中值的集合
entrySet() ：返回一个所有条目的集合
 
 

4.2、主要的参数

capacity 桶的容量
load factor 加载因子,默认load factor为0.75是在时间和空间上性能最优的。
 
 

4.3、哈希值

以Entry[]数组实现的哈希桶数组，用Key的哈希值取模桶数组的大小可得到数组下标。

插入元素时，如果两条Key落在同一个桶(比如哈希值1和17取模16后都属于第一个哈希桶)，Entry用一个next属性实现多个Entry以单向链表存放，后入桶的Entry将next指向桶当前的Entry。

查找哈希值为17的key时，先定位到第一个哈希桶，然后以链表遍历桶里所有元素，逐个比较其key值。

当Entry数量达到桶数量的75%时(很多文章说使用的桶数量达到了75%，但看代码不是)，会成倍扩容桶数组，并重新分配所有原来的Entry，所以这里也最好有个预估值。

取模用位运算(hash & (arrayLength-1))会比较快，所以数组的大小永远是2的N次方， 你随便给一个初始值比如17会转为32。默认第一次放入元素时的初始值是16。

iterator()时顺着哈希桶数组来遍历，看起来是个乱序。

在JDK8里，新增默认为8的閥值，当一个桶里的Entry超过閥值，就不以单向链表而以红黑树来存放以加快Key的查找速度。

        HashMap<String,Integer> hm1 = new HashMap<>();
        hm1.put("Computer", 500);
        hm1.put("Apple",20);
        hm1.put("egg",3);
        System.out.println(hm1.get("Apple"));  
        System.out.println(hm1);

20
{Apple=20, egg=3, Computer=500}
 
 

5、练习1

统计文本中各单词出现的次数，不区分大小写。

public class TestHashSet {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String text = "hava a good day." + "HAVA A GOOD CLASS!HAVE FUN." + "enjoy~your~time";
		Map<String,Integer> treemap = new TreeMap<>();
		String[] words = text.split("[ \n\t\r.,;!?(){}~]");
		for(int i=0; i<words.length;i++) {
			String key=words[i].toLowerCase();
			if(key.length()>0) {
				if(!treemap.containsKey(key))
					treemap.put(key, 1);
				else {
					int value = treemap.get(key);
					value++;
					treemap.put(key, value);
				}
			}	
		}
				
		Set<Map.Entry<String, Integer>> entrySet = treemap.entrySet();  // 程序获取集合中映射表的条目
		
		for(Map.Entry<String, Integer> entry: entrySet)
			System.out.println(entry.getKey() + "\t" + entry.getValue());
	}

}

5、练习2

准备一个ArrayList其中存放3000000(三百万个)Hero对象，其名称是随机的,格式是hero-[4位随机数]
hero-3229
hero-6232
hero-9365
…
因为总数很大，所以几乎每种都有重复，把名字叫做 hero-5555的所有对象找出来
要求使用两种办法来寻找
1.不使用HashMap，直接使用for循环找出来，并统计花费的时间
2.借助HashMap，找出结果，并统计花费的时间

好晕啊这个知识点！！思考很久终于懂了！！！
（下面是我的理解，应该木有错吧？？？？ ）
创建了一个三百万个Hero对象的ArrayList后，把它“整理“放在一个hashMap里。
比如： (假如三百万对象里hero-1165有3个，hero-8105有1个)

key （String)	value(ArrayList)
hero-1165	hero-165(1) 同一个ArrayList ，里面有三个不同的Hero对象（但名字相同）
	hero-165(2) 同一个ArrayList ，里面有三个不同的Hero对象（但名字相同）
	hero-165(3) 同一个ArrayList ，里面有三个不同的Hero对象（但名字相同）
hero-8105	hero-8105（1) 一个ArrayList ，里面有一个Hero对象

    public static void getlistHeros(){
    	
    	int total = 300 * 10000;
    	List<Hero> heros = new ArrayList<>();
    	System.out.println("初始化开始");
    	for(int i=0;i<total;i++) {
    		int num = (int) (Math.random()*9000+1000);
    		Hero h = new Hero("hero-" + num);
    		heros.add(h);
    	}
    	
    	/*	创建一个 HashMap ： 英雄名字 <----> 相同名字的英雄放在一个list里  作为映射
    		英雄的名字作为 key     
    		名字相同的Hero 放在一个List中 作为value
    	 */
        HashMap<String,List<Hero>> heroMap = new HashMap<>(); 	 
        for(Hero h:heros) {  // 遍历三百万个已经创建好的英雄
            List<Hero> list = heroMap.get(h.name);     // 首先在heroMap里找key=h.name的钥匙，把对应的value给list
            										   // get获取heroMap中key=h.name的英雄！！！
            										   //用一个list来接收在HashMap中key为 h.name的value
            if( list == null) {    //如果没有这个英语名字的list
            	list = new ArrayList<>();   //那么就创建一个
            	heroMap.put(h.name, list);  //然后把这新的key（本轮for中的英雄的名字) 和value（这个英雄）放入 HashMap
            }
            list.add(h);  //然后就将这个名为h.name的放入这个list
        }
        System.out.println("初始化结束");
        System.out.println("开始查找");
        
        findByIteration(heros);
        findByMap(heroMap);
    }
    
    
    //Map查找
    private static List<Hero> findByMap(HashMap<String,List<Hero>> m) {
        long start =System.currentTimeMillis();
        List <Hero>result= m.get("hero-5555");
        long end =System.currentTimeMillis();
        System.out.printf("通过map查找，一共找到%d个英雄，耗时%d 毫秒%n",result.size(),end-start);
        return result;
    }
    
    //for循环查找
    private static List<Hero> findByIteration (List<Hero> hs) {
        long start =System.currentTimeMillis();
        List<Hero> result =new ArrayList<>();
        for (Hero h : hs) {
            if(h.name.equals("hero-5555")){
                result.add(h);
            }
        }
        long end =System.currentTimeMillis();
        System.out.printf("通过for查找，一共找到%d个英雄，耗时%d 毫秒%n", result.size(),end-start);
        return result;
    }