Map接口概述
Map：双列集合类的根接口，用于存储具有键(Key)、值(Value)映射关系的元素，每个元素都包含一对键值，在使用Map集合时可以通过指定的Key找到对应的Value，例如根据一个学生的学号就可以找到对应的学生。Map接口的主要实现类有HashMap和TreeMap。
将键映射到值的对象，一个映射不能包含重复的键，每个键最多只能映射到一个值。其实Map集合中存储的就是键值对。map集合中必须保证键的唯一性。
Map接口和Collection接口的不同
- Map是双列的,Collection是单列的
- Map的键唯一,Collection的子体系Set是唯一的
- Map集合的数据结构值针对键有效，跟值无关
- Collection集合的数据结构是针对元素有效
Map常用的子类：
- Hashtable：内部结构是哈希表，是同步的。不允许null作为键，null作为值。
- Properties：用来存储键值对型的配置文件的信息，可以和IO技术相结合。
- HashMap：内部结构式哈希表，不是同步的。允许null作为键，null作为值。
- TreeMap：内部结构式二叉树，不是同步的。可以对Map结合中的键进行排序。
- HashSet实现Set接口，由哈希表（实际上是一个HashMap实例）支持。
Map接口常用方法
方法声明 | 功能描述 |
put(K key, V value) | 有添加和替换功能 |
putAll(Map m) | 添加一个Map的元素 |
clear() | 清空集合 |
remove(Object key) | 根据键删除一个元素 |
containsKey() | 判断集合是否包含指定的键 |
containsValue() | 判断集合是否包含指定的值 |
isEmpty() | 判断集合是否为空 |
get(Object key) | 根据键获取值 |
keySet() | 获取所有的键 |
values() | 获取所有的值 |
entrySet() | 获取所有的Entry |
size() | 获取集合元素的个数 |
HashMap
键是哈希表结构，可以保证键的唯一性
LinkedHashMap
Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序。
TreeMap
键是红黑树结构，可以保证键的排序和唯一性，自然排序，比较器排序。
package com.lcy.javaMap;
import java.util.TreeMap;
//键不可以重复,值可以重复 键可以排序,有排序要注意键的类型 <String>要实现Comparable接口
public class TreeMapDemo {
public static void main(String[] args) {
TreeMap<String,String>a=new TreeMap();
a.put("a", "aa");
a.put("g", "gg");
a.put("b", "bb");
a.put("c", "cc");
a.put("e", "ee");
a.put("d", "tt");
System.out.println(a);
// 输出结果:{a=aa, b=bb, c=cc, d=tt, e=ee, g=gg}
}
}Hashtable
package com.lcy.javaMap;
import java.util.Hashtable;
//键不能重复,值可以重复 无序 是线程安全的
public class HashtableDemo {
public static void main(String[] args) {
Hashtable <String,String>s=new Hashtable();
s.put("a", "aa");
s.put("v", "vv");
s.put("l", "ll");
//s.put(null, "tt");//键和值都不能为null NullPointerException空指针异常
System.out.println(s);
// 输出结果:{l=ll, a=aa, v=vv}
}
}Map集合遍历
方式1：根据键找值。获取所有键的集合，遍历键的集合，获取到每一个键，根据键找值。
package cn.itcast;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/*
* Map集合的遍历。
* Map -- 夫妻对
* 思路：
* A:把所有的丈夫给集中起来。
* B:遍历丈夫的集合，获取得到每一个丈夫。
* C:让丈夫去找自己的妻子。
*
* 转换：
* A:获取所有的键
* B:遍历键的集合，获取得到每一个键
* C:根据键去找值
*/
public class MapDemo {
public static void main(String[] args) {
// 创建集合对象
Map<String, String> map = new HashMap<String, String>();
// 创建元素并添加到集合
map.put("杨过", "小龙女");
map.put("郭靖", "黄蓉");
map.put("杨康", "穆念慈");
map.put("陈玄风", "梅超风");
// 遍历
// 获取所有的键
Set<String> set = map.keySet();
// 遍历键的集合，获取得到每一个键
for (String key : set) {
// 根据键去找值
String value = map.get(key);
System.out.println(key + "---" + value);
}
}
}方式2：根据键值对对象找键和值。
- 获取所有键值对对象的集合
- 遍历键值对对象的集合，获取到每一个键值对对象
- 根据键值对对象找键和值
package cn.itcast;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/*
* Map集合的遍历。
* Map -- 夫妻对
*
* 思路：
* A:获取所有结婚证的集合
* B:遍历结婚证的集合，得到每一个结婚证
* C:根据结婚证获取丈夫和妻子
*
* 转换：
* A:获取所有键值对对象的集合
* B:遍历键值对对象的集合，得到每一个键值对对象
* C:根据键值对对象获取键和值
*
* 这里面最麻烦的就是键值对对象如何表示呢?
* 看看我们开始的一个方法：
* Set<Map.Entry<K,V>> entrySet()：返回的是键值对对象的集合
*/
public class MapDemo {
public static void main(String[] args) {
// 创建集合对象
Map<String, String> map = new HashMap<String, String>();
// 创建元素并添加到集合
map.put("杨过", "小龙女");
map.put("郭靖", "黄蓉");
map.put("杨康", "穆念慈");
map.put("陈玄风", "梅超风");
// 获取所有键值对对象的集合
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);
}
}
}Map集合的应用及扩展
package cn.itcast;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeMap;
/*
* 需求 ："aababcabcdabcde",获取字符串中每一个字母出现的次数要求结果:a(5)b(4)c(3)d(2)e(1)
*
* 分析：
* A:定义一个字符串(可以改进为键盘录入)
* B:定义一个TreeMap集合
* 键:Character
* 值：Integer
* C:把字符串转换为字符数组
* D:遍历字符数组，得到每一个字符
* E:拿刚才得到的字符作为键到集合中去找值，看返回值
* 是null:说明该键不存在，就把该字符作为键，1作为值存储
* 不是null:说明该键存在，就把值加1，然后重写存储该键和值
* F:定义字符串缓冲区变量
* G:遍历集合，得到键和值，进行按照要求拼接
* H:把字符串缓冲区转换为字符串输出
*
* 录入：linqingxia
* 结果：result:a(1)g(1)i(3)l(1)n(2)q(1)x(1)
*/
public class TreeMapDemo {
public static void main(String[] args) {
// 定义一个字符串(可以改进为键盘录入)
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串：");
String line = sc.nextLine();
// 定义一个TreeMap集合
TreeMap<Character, Integer> tm = new TreeMap<Character, Integer>();
// 把字符串转换为字符数组
char[] chs = line.toCharArray();
// 遍历字符数组，得到每一个字符
for (char ch : chs) {
// 拿刚才得到的字符作为键到集合中去找值，看返回值
Integer i = tm.get(ch);
// 是null:说明该键不存在，就把该字符作为键，1作为值存储
if (i == null) {
tm.put(ch, 1);
} else {
// 不是null:说明该键存在，就把值加1，然后重写存储该键和值
i++;
tm.put(ch, i);
}
}
// 定义字符串缓冲区变量
StringBuilder sb = new StringBuilder();
// 遍历集合，得到键和值，进行按照要求拼接
Set<Character> set = tm.keySet();
for (Character key : set) {
Integer value = tm.get(key);
sb.append(key).append("(").append(value).append(")");
}
// 把字符串缓冲区转换为字符串输出
String result = sb.toString();
System.out.println("result:" + result);
}
}示例2：在很多项目中，应用比较多的是一对多的映射关系，这就可以通过嵌套的形式将多个映射定义到一个大的集合中，并将大的集合分级处理，形成一个体系。
package cn.itcast;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;
class Student {
private String name;
private int age;
public Student() {
super();
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
/*
* bj 北京校区
* jc 基础班
* 林青霞 27
* 风清扬 30
* jy 就业班
* 赵雅芝 28
* 武鑫 29
* sh 上海校区
* jc 基础班
* 郭美美 20
* 犀利哥 22
* jy 就业班
* 罗玉凤 21
* 马征 23
* gz 广州校区
* jc 基础班
* 王力宏 30
* 李静磊 32
* jy 就业班
* 郎朗 31
* 柳岩 33
* xa 西安校区
* jc 基础班
* 范冰冰 27
* 刘意 30
* jy 就业班
* 李冰冰 28
* 张志豪 29
*/
public class HashMapDemo {
public static void main(String[] args) {
// 创建大集合
HashMap<String, HashMap<String, ArrayList<Student>>> czbkMap = new HashMap<String, HashMap<String, ArrayList<Student>>>();
// 北京校区数据
HashMap<String, ArrayList<Student>> bjCzbkMap = new HashMap<String, ArrayList<Student>>();
ArrayList<Student> array1 = new ArrayList<Student>();
Student s1 = new Student("林青霞", 27);
Student s2 = new Student("风清扬", 30);
array1.add(s1);
array1.add(s2);
ArrayList<Student> array2 = new ArrayList<Student>();
Student s3 = new Student("赵雅芝", 28);
Student s4 = new Student("武鑫", 29);
array2.add(s3);
array2.add(s4);
bjCzbkMap.put("基础班", array1);
bjCzbkMap.put("就业班", array2);
czbkMap.put("北京校区", bjCzbkMap);
// 西安校区数据
HashMap<String, ArrayList<Student>> xaCzbkMap = new HashMap<String, ArrayList<Student>>();
ArrayList<Student> array3 = new ArrayList<Student>();
Student s5 = new Student("范冰冰", 27);
Student s6 = new Student("刘意", 30);
array3.add(s5);
array3.add(s6);
ArrayList<Student> array4 = new ArrayList<Student>();
Student s7 = new Student("李冰冰", 28);
Student s8 = new Student("张志豪", 29);
array4.add(s7);
array4.add(s8);
xaCzbkMap.put("基础班", array3);
xaCzbkMap.put("就业班", array4);
czbkMap.put("西安校区", xaCzbkMap);
// 遍历集合
Set<String> czbkMapSet = czbkMap.keySet();
for (String czbkMapKey : czbkMapSet) {
System.out.println(czbkMapKey);
HashMap<String, ArrayList<Student>> czbkMapValue = czbkMap
.get(czbkMapKey);
Set<String> czbkMapValueSet = czbkMapValue.keySet();
for (String czbkMapValueKey : czbkMapValueSet) {
System.out.println("\t" + czbkMapValueKey);
ArrayList<Student> czbkMapValueValue = czbkMapValue
.get(czbkMapValueKey);
for (Student s : czbkMapValueValue) {
System.out.println("\t\t" + s.getName() + "---"
+ s.getAge());
}
}
}
}
}补充知识
1.HashSet中为什么不能存储重复元素,如何判断元素是否重复
在add()的底层方法中,每添加一个元素,就会判断集合中是否包含了此元素
在底层使用hashCode()和equals()方法来判断内容是否重复
hashCode()是Object类中的方法
public native int hashCode();native修饰的方法没有方法体,称为本地方法,java没有实现,是调用操作系统的方法
Object类中的hashCode()方法是用来获取对象在内存中的地址
其他类中重写hashCode()方法是用来根据对象内容计算出来的哈希值(a-->97)
Object类中的equals()是比较两个对象的地址
其他类约定equals()用来比较对象的内容是否相等
equals()效率太低,要把每个位置上的字符进行对比
在判断两个元素是否相同时,先用hashCode()方法比较两个元素内容的哈希值.
但是此种做法并不安全,2个不同的内容也可能算出同样的哈希值(比如说中文里的"通话"和"重地")
这两个元素虽然内容不同,但是算出来的哈希值相同,此时就又调用了equals()方法,来比较它们的内容是否相同。
2.HashMap的底层结构
3.HashMap中添加元素的过程
根据添加的元素计算出一个hash值(a-->97),再进行一次计算,计算出元素在数组中的位置(例如97%16=1;那么就放在第一个位置)然后继续有元素存储进来,如果存在了相同的位置,将新的元素存入一个之前元素的下一位,当链表长度达到8(并且数组长度大于64时)会把链表转化为红黑树
哈希数组长度默认是16
负载因子是0.75(16*0.75=12,有3/4的数组被存储的时候,哈希数组就会扩容)
哈希数组如果扩容每次扩容到原来的2倍
当链表长度到达8,并且哈希数组长度大于64,链表会转为红黑树
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
