java 之集合体系（四 Map）

最新推荐文章于 2022-05-10 14:04:29 发布

启之灵

最新推荐文章于 2022-05-10 14:04:29 发布

阅读量260

点赞数

分类专栏： java 文章标签： map

本文链接：https://blog.csdn.net/z_x_Qiang/article/details/79188594

版权

java 专栏收录该内容

14 篇文章 1 订阅

订阅专栏

1.Map接口概述

查看API可以知道：
        * 将键映射到值的对象
        * 一个映射不能包含重复的键
        * 每个键最多只能映射到一个值
Map接口和Collection接口的不同
    * Map是双列的,Collection是单列的
    * Map的键唯一,Collection的子体系Set是唯一的

* Map集合的数据结构值针对键有效，跟值无关;Collection集合的数据结构是针对元素有效

2.基本使用

因为底层是hash算法，所以存储无序；

* a:添加功能
* V put(K key,V value):添加元素。返回被覆盖的value，如果没有就返回null；
* 如果键是第一次存储，就直接存储元素，返回null
* 如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值

* b:删除功能
* void clear():移除所有的键值对元素
* V remove(Object key)：根据键删除键值对元素，并把值返回

* c:判断功能
* boolean containsKey(Object key)：判断集合是否包含指定的键
* boolean containsValue(Object value):判断集合是否包含指定的值
* boolean isEmpty()：判断集合是否为空

* d:获取功能
* Set<Map.Entry<K,V>> entrySet():
* V get(Object key):根据键获取值
* Set<K> keySet():获取集合中所有键的集合
* Collection<V> values():获取集合中所有值的集合
* e:长度功能
* int size()：返回集合中的键值对的个数

3.map集合的遍历

第一种：Map没有迭代器interator，但是可以经map的键值转成set结合，通过set的迭代器去遍历：

	/**
	 * 通过查看Map集合的api发现没有iterator方法,那么双列集合如何迭代呢?
	 * 根据键获取值
	 */
	public static void main(String[] args) {
		Map<String, Integer> map = new HashMap<>();
		map.put("张三", 23);
		map.put("李四", 24);
		map.put("王五", 25);
		map.put("赵六", 26);
		
//		Integer i = map.get("张三");					//根据键获取值
//		System.out.println(i);
		
		//获取所有的键
		/*Set<String> keySet = map.keySet();			//获取所有键的集合
		Iterator<String> it = keySet.iterator();	//获取迭代器
		while(it.hasNext()) {						//判断集合中是否有元素
			String key = it.next();					//获取每一个键
			Integer value = map.get(key);			//根据键获取值
			System.out.println(key + "=" + value);
		}*/
		
		//使用增强for循环遍历
		for(String key : map.keySet()) {			//map.keySet()是所有键的集合
			System.out.println(key + "=" + map.get(key));
		}
	}

第二种：Map集合的遍历之键值对对象找键和值

			HashMap<String, Integer> hm = new HashMap<>();
			hm.put("张三", 23);
			hm.put("李四", 24);
			hm.put("王五", 25);
			hm.put("赵六", 26);
			/*Set<Map.Entry<String, Integer>> entrySet = hm.entrySet();	//获取所有的键值对象的集合
			Iterator<Entry<String, Integer>> it = entrySet.iterator();//获取迭代器
			while(it.hasNext()) {
				Entry<String, Integer> en = it.next();				//获取键值对对象
				String key = en.getKey();								//根据键值对对象获取键
				Integer value = en.getValue();							//根据键值对对象获取值
				System.out.println(key + "=" + value);
			}*/
			
			for(Entry<String,Integer> en : hm.entrySet()) {
				System.out.println(en.getKey() + "=" + en.getValue());
			}

4.HashMap：复杂数据类型（对象）做键的时候：

底层会掉那个hash算法对键进行计算，然后通过计算出来的值才能找到value；所以对象作为键的话根据地址值计算出来的hash值是不同的；所以要对这个键对象进行重写hashcode和equals方法；

5.LinkedHashMap

这个是有序的，怎么存怎么显现；底层是链表实现的；其他和Hashmap是一样的；增删快，查找慢；

6.TreeMap

排序，二叉树

进行键值对排序，当对象作为键的是，要指定排序的规则，实现comparable接口，重写ConpareTo方法，存储方式和compareTo的返回值有关；

也可使用比较器comparator进行比较；

案例：统计字符串中每个字符出现的次数

通过hashmap是否包含键，计数为value；

			String str = "aaaabbbcccccccccc";
			char[] arr = str.toCharArray();						//将字符串转换成字符数组
			HashMap<Character, Integer> hm = new HashMap<>();	//创建双列集合存储键和值
			
			for(char c : arr) {									//遍历字符数组
				/*if(!hm.containsKey(c)) {						//如果不包含这个键
					hm.put(c, 1);								//就将键和值为1添加
				}else {											//如果包含这个键
					hm.put(c, hm.get(c) + 1);					//就将键和值再加1添加进来
				}
				
				//hm.put(c, !hm.containsKey(c) ? 1 : hm.get(c) + 1);
				Integer i = !hm.containsKey(c) ? hm.put(c, 1) : hm.put(c, hm.get(c) + 1);
						}
			
			for (Character key : hm.keySet()) {					//遍历双列集合
				System.out.println(key + "=" + hm.get(key));
			}

7.HashMap和HashTable的区别：

* HashMap是JDK1.2版本出现的,是线程不安全的,效率高；

* Hashtable是JDK1.0版本出现的,是线程安全的,效率低；
* Hashtable不可以存储null键和null值,HashMap可以存储null键和null值

HashMap已经取代了HashTable

8.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) //重新洗牌，随机的，每次遍历结果都不同；

集合大总结：

	/**
	 * Collection
	 * 		List(存取有序,有索引,可以重复)
	 * 			ArrayList
	 * 				底层是数组实现的,线程不安全,查找和修改快,增和删比较慢
	 * 			LinkedList
	 * 				底层是链表实现的,线程不安全,增和删比较快,查找和修改比较慢
	 * 			Vector
	 * 				底层是数组实现的,线程安全的,无论增删改查都慢
	 * 			如果查找和修改多,用ArrayList
	 * 			如果增和删多,用LinkedList
	 * 			如果都多,用ArrayList
	 * 		Set(存取无序,无索引,不可以重复)
	 * 			HashSet
	 * 				底层是哈希算法实现
	 * 				LinkedHashSet
	 * 					底层是链表实现,但是也是可以保证元素唯一,和HashSet原理一样
	 * 			TreeSet
	 * 				底层是二叉树算法实现
	 * 			一般在开发的时候不需要对存储的元素排序,所以在开发的时候大多用HashSet,HashSet的效率比较高
	 * 			TreeSet在面试的时候比较多,问你有几种排序方式,和几种排序方式的区别
	 * Map
	 * 		HashMap
	 * 			底层是哈希算法,针对键
	 * 			LinkedHashMap
	 * 				底层是链表,针对键
	 * 		TreeMap
	 * 			底层是二叉树算法,针对键
	 * 		开发中用HashMap比较多
	 */