Java Map集合详解-优快云博客

本文链接：https://blog.youkuaiyun.com/u014401141/article/details/71030229

1:Map
   (1)将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。
   (2)Map和Collection的区别?
       A:Map 存储的是键值对形式的元素，键唯一，值可以重复。夫妻对

B:Collection 存储的是单独出现的元素，子接口Set元素唯一，子接口List元素可重复。

2.Map接口功能概述

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/*
 Java就提供了一种新的集合 Map。
 * 通过查看API，我们知道Map集合的一个最大的特点，就是它可以存储键值对的元素。这个时候存储我们上面的需求，就可以这样做
 * 		学号1		姓名1
 * 		学号2 	姓名2
 * 		学号3		姓名3
 * 		学号2(不行)姓名4
 * 		学号4               姓名4
 * Map集合的特点：
 * 		将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。 
 * 
 * Map集合和Collection集合的区别?
 * 		Map集合存储元素是成对出现的，Map集合的键是唯一的，值是可重复的。可以把这个理解为：夫妻对
 * 		Collection集合存储元素是单独出现的，Collection的儿子Set是唯一的，List是可重复的。可以把这个理解为：光棍(11.11)
 * 
 * 注意：
 * 		Map集合的数据结构值针对键有效，跟值无关	
 * 			HashMap，TreeMap等。
 *		Collection集合的数据结构是针对元素有效
 * 
 * Map集合的功能概述：
 * 1:添加功能
 * 		V put(K key,V value):添加元素。这个其实还有另一个功能?先不告诉你，等会讲
 * 			如果键是第一次存储，就直接存储元素，返回null
 * 			如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值
 * 2:删除功能
 * 		void clear():移除所有的键值对元素
 * 		V remove(Object key)：根据键删除键值对元素，并把值返回
 * 3:判断功能
 * 		boolean containsKey(Object key)：判断集合是否包含指定的键
 * 		boolean containsValue(Object value):判断集合是否包含指定的值
 * 		boolean isEmpty()：判断集合是否为空
 * 4:获取功能
 * 		Set<Map.Entry<K,V>> entrySet()：返回的是键值对对象的集合
 * 		V get(Object key):根据键获取值
 * 		Set<K> keySet():获取集合中所有键的集合
 * 		Collection<V> values():获取集合中所有值的集合
 * 5：长度功能
 * 		int size()：返回集合中的键值对的对数
 */
public class MapDemo {
	public static void main(String[] args) {
		// 创建集合对象
		Map<String, String> map = new HashMap<String, String>();

		// 添加元素
		// V put(K key,V value):添加元素。这个其实还有另一个功能?先不告诉你，等会讲
		// System.out.println("put:" + map.put("文章", "马伊俐"));
		// System.out.println("put:" + map.put("文章", "姚笛"));

		map.put("邓超", "孙俪");
		map.put("黄晓明", "杨颖");
		map.put("周杰伦", "蔡依林");
		map.put("刘恺威", "杨幂");

		// void clear():移除所有的键值对元素
		// map.clear();

		// V remove(Object key)：根据键删除键值对元素，并把值返回
		// System.out.println("remove:" + map.remove("黄晓明"));
		// System.out.println("remove:" + map.remove("黄晓波"));

		// boolean containsKey(Object key)：判断集合是否包含指定的键
		// System.out.println("containsKey:" + map.containsKey("黄晓明"));
		// System.out.println("containsKey:" + map.containsKey("黄晓波"));

		// boolean isEmpty()：判断集合是否为空
		// System.out.println("isEmpty:"+map.isEmpty());
		
		//int size()：返回集合中的键值对的对数
		System.out.println("size:"+map.size());

		// 输出集合名称
		System.out.println("map:" + map);

		// 获取所有键值对对象的集合
		Set<Map.Entry<String, String>> set = map.entrySet();
		// 遍历键值对对象的集合，得到每一个键值对对象
		for (Map.Entry<String, String> me : set) {
					// 根据键值对对象获取键和值
					String key = me.getKey();
					String value = me.getValue();
					System.out.println(key + "---" + value);
				}
			}
	}
}

3.Map集合的遍历
       A:键找值
           a:获取所有键的集合
           b:遍历键的集合,得到每一个键
           c:根据键到集合中去找值
       B:键值对对象找键和值
           a:获取所有的键值对对象的集合
           b:遍历键值对对象的集合，获取每一个键值对对象
           c:根据键值对对象去获取键和值

代码体现：

   Map<String,String> hm = new HashMap<String,String>();
            
            hm.put("it002","hello");
            hm.put("it003","world");
            hm.put("it001","java");
            
            //方式1 键找值
            Set<String> set = hm.keySet();
            for(String key : set) {
                String value = hm.get(key);
                System.out.println(key+"---"+value);
            }
            
            //方式2 键值对对象找键和值
            Set<Map.Entry<String,String>> set2 = hm.entrySet();
            for(Map.Entry<String,String> me : set2) {
                String key = me.getKey();
                String value = me.getValue();
                System.out.println(key+"---"+value);

            }

4.HashMap

HashMap是基于哈希表的Map接口的非同步实现，继承自AbstractMap，AbstractMap是部分实现Map接口的抽象类。在平时的开发中，HashMap的使用还是比较多的。我们知道ArrayList主要是用数组来存储元素的，LinkedList是用链表来存储的，那么HashMap的实现原理是什么呢？先看下面这张图：

HashMap原理.jpg

在之前的版本中，HashMap采用数组+链表实现，即使用链表处理冲突，同一hash值的链表都存储在一个链表里。但是当链表中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。而JDK1.8中，HashMap采用数组+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减少了查找时间。put(K key,V value)方法中可知，当要存储Key---->Value对时，实际上是存储在一个Entry的对象e中，程序通过key计算出Entry对象的存储位置。换句话说，Key---->Value的对应关系是通过key----Entry----value这个过程实现的，所以就有我们表面上知道的key存在哪里，value就存在哪里。在Map接口中，有一个Entry接口，该接口用于处理key和value的set()和get()方法，所以在Map中存储数据，实际上是将Key---->value的数据存储在Map.Entry接口的实例中，再在Map集合中插入Map.Entry的实例化对象，如图示：

import java.util.HashMap;
import java.util.Set;

/*
 * HashMap:是基于哈希表的Map接口实现。
 * 哈希表的作用是用来保证键的唯一性的。
 * 
 * HashMap<String,String>
 * 键：String
 * 值：String
 */
public class HashMapDemo {
	public static void main(String[] args) {
		// 创建集合对象
		HashMap<String, String> hm = new HashMap<String, String>();

		// 创建元素并添加元素
		// String key1 = "it001";
		// String value1 = "马云";
		// hm.put(key1, value1);

		hm.put("it001", "马云");
		hm.put("it003", "马化腾");
		hm.put("it004", "乔布斯");
		hm.put("it005", "张朝阳");
		hm.put("it002", "裘伯君"); // wps
		hm.put("it001", "比尔盖茨");

		// 遍历
		Set<String> set = hm.keySet();
		for (String key : set) {
			String value = hm.get(key);
			System.out.println(key + "---" + value);
		}
	}
}


import java.util.LinkedHashMap;
import java.util.Set;

/*
 * LinkedHashMap:是Map接口的哈希表和链接列表实现，具有可预知的迭代顺序。
 * 由哈希表保证键的唯一性
 * 由链表保证键盘的有序(存储和取出的顺序一致)
 */
public class LinkedHashMapDemo {
    public static void main(String[] args) {
        // 创建集合对象
        LinkedHashMap<String, String> hm = new LinkedHashMap<String, String>();

        // 创建并添加元素
        hm.put("2345", "hello");
        hm.put("1234", "world");
        hm.put("3456", "java");
        hm.put("1234", "javaee");
        hm.put("3456", "android");

        // 遍历
        Set<String> set = hm.keySet();
        for (String key : set) {
            String value = hm.get(key);
            System.out.println(key + "---" + value);
        }
    }
}

5.TreeMap

TreeMap基于红黑树数据结构的实现，键值可以使用Comparable或Comparator接口来排序。TreeMap继承自AbstractMap，同时实现了接口NavigableMap，而接口NavigableMap则继承自SortedMap。SortedMap是Map的子接口，使用它可以确保图中的条目是排好序的。

在实际使用中，如果更新图时不需要保持图中元素的顺序，就使用HashMap，如果需要保持图中元素的插入顺序或者访问顺序，就使用LinkedHashMap，如果需要使图按照键值排序，就使用TreeMap。

import java.util.Set;
import java.util.TreeMap;

/*
 * TreeMap:是基于红黑树的Map接口的实现。
 * 
 * HashMap<String,String>
 * 键：String
 * 值：String
 */
public class TreeMapDemo {
	public static void main(String[] args) {
		// 创建集合对象
		TreeMap<String, String> tm = new TreeMap<String, String>();

		// 创建元素并添加元素
		tm.put("hello", "你好");
		tm.put("world", "世界");
		tm.put("java", "爪哇");
		tm.put("world", "世界2");
		tm.put("javaee", "爪哇EE");

		// 遍历集合
		Set<String> set = tm.keySet();
		for (String key : set) {
			String value = tm.get(key);
			System.out.println(key + "---" + value);
		}
	}
}

6.HashTable

HashTable和前面介绍的HashMap很类似，它也是一个散列表，存储的内容是键值对映射，不同之处在于，HashTable是继承自Dictionary的，HashTable中的函数都是同步的，这意味着它也是线程安全的，另外，HashTable中key和value都不可以为null。

import java.util.Hashtable;

/*
 * 1:Hashtable和HashMap的区别?
 * Hashtable:线程安全，效率低。不允许null键和null值
 * HashMap:线程不安全，效率高。允许null键和null值
 * 
 * 2:List,Set,Map等接口是否都继承子Map接口?
 * List，Set不是继承自Map接口，它们继承自Collection接口
 * Map接口本身就是一个顶层接口
 */
public class HashtableDemo {
	public static void main(String[] args) {
		// HashMap<String, String> hm = new HashMap<String, String>();
		Hashtable<String, String> hm = new Hashtable<String, String>();

		hm.put("it001", "hello");
		// hm.put(null, "world"); //NullPointerException
		// hm.put("java", null); // NullPointerException

		System.out.println(hm);
	}
}

7.Collections
   (1)是针对集合进行操作的工具类
   (2)Collection和Collections的区别
       A:Collection 是单列集合的顶层接口，有两个子接口List和Set
       B:Collections 是针对集合进行操作的工具类，可以对集合进行排序和查找等
   (3)常见的几个小方法：
       A:public static <T> void sort(List<T> list)
       B:public static <T> int binarySearch(List<?> list,T key)
       C:public static <T> T max(Collection<?> coll)
       D:public static void reverse(List<?> list)
       E:public static void shuffle(List<?> list)

import java.util.Collections;
import java.util.List;
import java.util.ArrayList;

/*
 * Collections:是针对集合进行操作的工具类，都是静态方法。
 * public static <T> void sort(List<T> list)：排序 默认情况下是自然顺序。
 * public static <T> int binarySearch(List<?> list,T key):二分查找
 * public static <T> T max(Collection<?> coll):最大值
 * public static void reverse(List<?> list):反转
 * public static void shuffle(List<?> list):随机置换
 */
public class CollectionsDemo {
	public static void main(String[] args) {
		// 创建集合对象
		List<Integer> list = new ArrayList<Integer>();

		// 添加元素
		list.add(30);
		list.add(20);
		list.add(50);
		list.add(10);
		list.add(40);

		System.out.println("list:" + list);

		// public static <T> void sort(List<T> list)：排序 默认情况下是自然顺序。
		// Collections.sort(list);
		// System.out.println("list:" + list);
		// [10, 20, 30, 40, 50]

		// public static <T> int binarySearch(List<?> list,T key):二分查找
		// System.out
		// .println("binarySearch:" + Collections.binarySearch(list, 30));
		// System.out.println("binarySearch:"
		// + Collections.binarySearch(list, 300));

		// public static <T> T max(Collection<?> coll):最大值
		// System.out.println("max:"+Collections.max(list));

		// public static void reverse(List<?> list):反转
		// Collections.reverse(list);
		// System.out.println("list:" + list);
		
		//public static void shuffle(List<?> list):随机置换
		Collections.shuffle(list);
		System.out.println("list:" + list);
	}
}

8.总结

    Collection
       |--List   有序,可重复
           |--ArrayList
               底层数据结构是数组，查询快，增删慢。
               线程不安全，效率高
           |--Vector
               底层数据结构是数组，查询快，增删慢。
               线程安全，效率低
           |--LinkedList
               底层数据结构是链表，查询慢，增删快。
               线程不安全，效率高
       |--Set   无序,唯一
           |--HashSet
               底层数据结构是哈希表。
               如何保证元素唯一性的呢?
                   依赖两个方法：hashCode()和equals()
                   开发中自动生成这两个方法即可
               |--LinkedHashSet
                   底层数据结构是链表和哈希表
                   由链表保证元素有序
                   由哈希表保证元素唯一
           |--TreeSet
               底层数据结构是红黑树。
               如何保证元素排序的呢?
                   自然排序
                   比较器排序
               如何保证元素唯一性的呢?
                   根据比较的返回值是否是0来决定

Map(双列集合)存储的是键值对形式的元素，键唯一，值可以重复

Hashmap

      底层数据结构是哈希表。
                    依赖两个方法：hashCode()和equals()
                   开发中自动生成这两个方法即可
               |--Linkedmap
                    底层数据结构是链表和哈希表
                   由链表保证元素有序
                   由哈希表保证元素唯一

hashtable 线程安全的

treemap

   底层数据结构是红黑树。
               如何保证元素排序的呢?
                   自然排序
                   比较器排序
               如何保证元素唯一性的呢?
                   根据比较的返回值是否是0来决定

4:针对Collection集合我们到底使用谁呢?
   唯一吗?
       是：Set
           排序吗?
               是：TreeSet
               否：HashSet
       如果你知道是Set，但是不知道是哪个Set，就用HashSet。

       否：List
           要安全吗?
               是：Vector
               否：ArrayList或者LinkedList
                   查询多：ArrayList
                   增删多：LinkedList
       如果你知道是List，但是不知道是哪个List，就用ArrayList。

   如果你知道是Collection集合，但是不知道使用谁，就用ArrayList。

   如果你知道用集合，就用ArrayList。

5:在集合中常见的数据结构(掌握)
   ArrayXxx:底层数据结构是数组，查询快，增删慢
   LinkedXxx:底层数据结构是链表，查询慢，增删快
   HashXxx:底层数据结构是哈希表。依赖两个方法：hashCode()和equals()
   TreeXxx:底层数据结构是二叉树。两种方式排序：自然排序和比较器排序

集合框架之Map