Map

1.Map的概述和使用

Map在java.util包下使用Map集合需要导包，alt+enter一键导包
集合是一个接口，Interface Map，Map集合的泛型有两部分组成
K - 是Map集合键的类型 —> Key 是键
V - 是Map集合的值类型 —> Value 是值
Map 地图不能包含重复的键，每个键只能对应一个值
举例：学生的学号和姓名
001 李畅
002 张三
003 李四
学号是键 姓名是值
一个学号只能对应一个姓名

常见集合对象：

  1.         1. 因为Map是集合所以无法直接实例
  2.         1. 通过多态继承HashMap<>子类实例
  3.         1. Map集合和List集合不同，**Map集合的添加方法是put(),List集合的添加方法是add();**

public class MapDemo {
_public static void main(String[] args) {
// 常见Map集合对象
Map<_String,String_> m = new HashMap<>()_;

  1.     // put(K key,V value) 将指定的值与该映射中的指定键相关联<br />        m.put_(_"001","李畅"_)_;<br />        m.put_(_"002","张三"_)_;<br />        m.put_(_"003","李四"_)_;<br />        m.put_(_"003","王五"_)_;
  3. /*   输出集合对象<br />         其中HashMap重写toString方法，将键值对用=拼接<br />         {001=李畅, 002=张三, 003=李四}<br />         Map中不能包含重复的键，如果键重复，后面的值将替换前面的值<br />         Map不能包含重复键的主要原有是因为HashMap底层是哈希表保证Map的键是唯一的<br />         {001=李畅, 002=张三, 003=王五}   */<br />        System._out_.println_(_m_)_;    _}    }_

2.Map的基本功能

方法名 说明
V put (K key,V value) 添加元素
V remove(Object key) 根据建删除值对元素
void clear() 移除所有的键值对元素
boolean containsKey(Object key) 判断集合是否包含指定的键
boolean containsKey(Object value) 判断集合是否包含指定的值
boolean isEmpty() 判断集合是否为空
int size() 集合的长度,也就是集合中键值对的个数
代码实现:
public class MapDemo {
_public static void main(String[] args) {
// 常见Map集合对象
Map<_String,String_> m = new HashMap<>();
// put(K key,V value) 将指定的值与该映射中的指定键相关联
m.put(“001”,”李畅”);
m.put(“002”,”张三”);
m.put(“003”,”李四”);
m.put(“003”,”王五”);
System._out.println(_m); // {001=李畅, 002=张三, 003=王五}
// V remove(Object key) 根据建删除值对元素,如果没有该值则返回null
m.remove(“003”);
System._out.println(_m); // {001=李畅, 002=张三}
// boolean containsKey(Object key) 判断集合是否包含指定的键
System._out.println(_m.containsKey(“003”)); // false
// boolean containsValue(Object value) 判断集合是否包含指定的值
System._out.println(_m.containsValue(“王五”)); // false
// boolean isEmpty() 判断集合是否为空
System._out.println(_m.isEmpty());// false
// int size() 集合的长度,也就是集合中键值对的个数
System._out.println(_m.size()); // 2
// void clear() 移除所有的键值对元素
m.clear(); } }_

3.Map集合的获取功能

方法名 说明
V get(Object key) 根据键获取值
Set keySet() 获取所有键的集合
Collection values() 获取所有值的集合
Set>entrySet() 获取所有键值对的集合
// 创建Map集合对象
Map<_Integer,String> map = new HashMap<>();
// 使用Map集合中特有的添加put()方法
map.put(1,”李畅”);
map.put(2,”张三”);
map.put(3,”李四”);
map.put(4,”王五”);
// V get(Object key) 根据键获取值
System._out.println(_map.get(1)); // 李畅
// Set keySet() 获取所有键的集合
// Map集合的键是唯一的所以返回的集合是一个Set集合,保证键的唯一性
Set<_Integer_> keyset = map.keySet();
for (Integer i: keyset) { System._out.println(_i); }// 1 2 3 4
// Collection values() 获取所有值的集合
// Map集合没有对值的唯一性做判断,所以返回的是一个Collection集合
Collection<_String_> values = map.values();
for (String s : values){ System._out.println(_s);}// 李畅 张三 李四 王五
// Set>entrySet() 获取所有键值对的集合
Set<_Map.Entry_<_Integer, String_>> set = map.entrySet();
for (Map.Entry<_Integer, String_> ms : set){ System._out.println(_ms); }_

4.Map集合的遍历(方法1)

Map存储的元素都是键值对成对出现的
遍历思路:

  1.         1. 我们把Map集合看成一个夫妻对的集合
  2.         1. 把所有的丈夫(键)集中起来
  3.         1. 然后遍历所有丈夫(键),获取每一个丈夫
  4.         1. 根据获取丈夫(键)去找对应的妻子

实现Map集合的操作:

  1.         1. 获取所有键的集合,使用keySet()方式实现
  2.         1. 遍历键的集合,获取每一个键,使用增强for实现
  3.         1. 根据键去找值,使用get(Object key)实现<br />public class MapDemo01 _{<br />    _public static void main_(_String_[] _args_) {<br />        _// 创建Map集合对象<br />        Map_<_Integer, String_> _map = new HashMap_<>()_;<br />        // 使用Map集合中特有的添加put()方法<br />        map.put_(_1, "李畅"_)_;<br />        map.put_(_2, "张三"_)_;<br />        map.put_(_3, "李四"_)_;<br />        map.put_(_4, "王五"_)_;<br />        Set_<_Integer_> _set = map.keySet_()_;<br />        for _(_Integer i : set_) { _System._out_.println_(_i + "=" + map.get_(_i_))_; _} } }_

5.Map集合的遍历(方法2)

Map存储的元素通常都是一对键值对出现 , 同时我们也可以把这一对键值对看成是一个完整的集合
遍历思路:

  1.         1. 将夫妻对看成一个完整的集合
  2.         1. 获取所有结婚证的集合
  3.         1. 遍历结婚证的集合, 得到每一个结婚证
  4.         1. 根据结婚证获取丈夫和妻子

转换为Map集合中的操作:

  1.         1. 获取所有键值对对象的集合
  2.            1. ** Set<Map.Entry<K,V>>entrySet()    获取所有键值对的集合**
  3.         2. 遍历键值对对象的集合, 得到每一个键值对对象
  4.            1. 用增强for实现, 得到每一个Map.Entry<K ,V>
  5.         3. 根据键值对对象获取键和值
  6.            1. 用getKey()得到键
  7.            1. 用getValue()得到值

// Set>entrySet() 获取所有键值对的集合
// Map的方法使用entrySet() 获得所有键值对集合
// 用Set方法将Map.Entry这个元素类型看成是一个整体
Set<_Map.Entry<_Integer, String_>> set = map.entrySet();
for (Map.Entry<_Integer, String_> ms : set) {
// 通过这个ms的变量(本质是对象名)调用Map的getKey()以及getValue()方法
System._out.println(_ms.getKey() + “,” + ms.getValue()); }_

案例: HashMap集合存储学生对象并遍历（键是String类型）

  1.  需求:  创建一个HashMap集合, 键是学号(String), 值是学生对象(Student) <br />  存储三个键值对元素, 并遍历<br />思路:
  3.               1. 定义学生类
  4.               1. 创建HashMap集合对象
  5.               1. 创建学生对象
  6.               1. 将学生对象添加到Map集合中
  7.               1. 遍历集合 :
  8.                  1. 通过键获取值
  9.                  1. 将每一个键值对看成一个集合对象，然后遍历该集合

代码实现：
// 定义学生类
public class Student {
_private int number;
private String name;
public Student() { }
public Student(int number, String name) {
this.number = number;
this.name = name; }
public int getNumber() { return number; }
public void setNumber(int number) { this.number = number; }
public String getName() { return name; }
public void setName(String name) { this.name = name; } }
——————————————————————-
public class HashMapDemo {
public static void main(String[] args) {
// 创建HashMap集合对象
HashMap<_String, Student_> hm = new HashMap<>();
// 创建学生对象
Student s1 = new Student(1, “李畅”);
Student s2 = new Student(2, “张三”);
Student s3 = new Student(3, “李四”);
// 将学生对象添加到Map集合中
hm.put(“1”, s1);
hm.put(“2”, s2);
hm.put(“3”, s3)_;

  1.     // 遍历集合 1. 通过键获取值 -> 通过map.keySet(key)方法获取每个键，遍历每个键的集合<br />        Set_<_String_> _set = hm.keySet_()_;<br />        for _(_String s : set_) {<br />            _System._out_.println_(_s + "," + hm.get_(_s_)_.getName_())_;<br />            Student student = hm.get_(_s_)_;<br />            System._out_.println_(_student.getName_() _+ "," + student.getNumber_())_;      _}<br />        _// 遍历集合 2. 将每一个键值对看成一个集合对象，然后遍历该集合<br />        Set_<_Map.Entry_<_String, Student_>> _entrySet = hm.entrySet_()_;<br />        for _(_Map.Entry_<_String, Student_> _me : entrySet_) {<br />            _String key = me.getKey_()_;<br />            Student value = me.getValue_()_;<br />            System._out_.println_(_key + "," + value.getName_() _+ "," + value.getNumber_())_;        _}    }    }_

案例: HashMap集合存储学生对象并遍历（键是学生对象）

  1.  需求：创建一个HashMap集合 ，键是学生对象(Student)，值是居住地(String)。存储多个键值对元素，并遍历。<br />     要求保证键的唯一性： 
  3.            1. 如果学生对象的成员变量值相同，我们就认为是同一个对象
  4.            1. 保证键的唯一性，因为HashMap的底层是哈希表
  5.            1. 哈希表通过hashCode()以及equals()判断元素是否相同
  6.            1. 所以要重写类中的equals()方法以及hashCode()方法

思路:

  1.               1. 定义学生类
  2.               1. 创建HashMap集合对象
  3.               1. 创建学生对象
  4.               1. 将学生对象添加到Map集合中
  5.               1. 遍历集合 :
  6.               1. 在学生类中重写两个方法
  7.                  1. hashCode()
  8.                  1. equals()

// 创建学生类— 重写hashCode()以及equals()
public class Student01 {
_private String name;
private int age;
public Student01(String name, int age) {
this.name = name;
this.age = age; }
public Student01() { }
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; }
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student01 student01 = (Student01) o;
if (age != student01.age) return false;
return name != null ? name.equals(student01.name) : student01.name == null; }
@Override
public int hashCode() {
int result = name != null ? name.hashCode() : 0;
result = 31 * result + age;
return result; }}
——————————————————————————
public class HashMapDemo01 {
public static void main(String[] args) {
// 创建HashMap集合，键是学生对象
HashMap<_Student01, String_> hs = new HashMap<>();
Student01 s01 = new Student01(“李畅”, 21);
Student01 s02 = new Student01(“张三”, 29);
Student01 s03 = new Student01(“李四”, 13);
Student01 s04 = new Student01(“王五”, 41);
Student01 s05 = new Student01(“王五”, 41)_;

  1.     hs.put_(_s01, "濮阳"_)_;<br />        hs.put_(_s02, "成都"_)_;<br />        hs.put_(_s03, "达州"_)_;<br />        hs.put_(_s04, "郑州"_)_;<br />        hs.put_(_s05, "北京"_)_;
  3.     Set_<_Student01_> _keySet = hs.keySet_()_;<br />        for _(_Student01 ss : keySet_) {<br />            _String s = hs.get_(_ss_)_;<br />            System._out_.println_(_s + "," + ss.getName_() _+ "," + ss.getAge_())_;     _}<br />        _Set_<_Map.Entry_<_Student01, String_>> _entrySet = hs.entrySet_()_;<br />        for _(_Map.Entry_<_Student01, String_> _me : entrySet_) {<br />            _Student01 key = me.getKey_()_;<br />            String value = me.getValue_()_;<br />            System._out_.println_(_key.getName_() _+ "," + key.getAge_() _+ "," + value_)_;        _}    }    }_

案例：ArrayList集合存储HashMap元素并遍历

需求： 创建一个ArrayList集合，存储三个元素，每一个元素HashMap的键和值都是String，并遍历
思路：
① 创建ArrayList集合
② 创建HashMap集合，并添加键值对元素
③ 把HashMap作为元素添加到ArrayList集合
④ 遍历ArrayList集合
public class ArrayListDemo {
_public static void main(String[] args) {
// 创建ArrayList集合
ArrayList<_HashMap_<_String, String_>> am = new ArrayList<>();
// 添加三个元素
// 第一个元素
HashMap<_String, String_> hm = new HashMap<>();
hm.put(“1”, “李1畅”);
hm.put(“2”, “李2畅”);
am.add(hm);
// 第二个元素
HashMap<_String, String_> hm1 = new HashMap<>();
hm1.put(“3”, “李3畅”);
hm1.put(“4”, “李4畅”);
am.add(hm1);
// 第三个元素
HashMap<_String, String_> hm2 = new HashMap<>();
hm2.put(“5”, “李5畅”);
hm2.put(“6”, “李6畅”);
am.add(hm2);
// 遍历ArrayList集合
for (HashMap<_String, String_> hm3 : am) {
Set<_String_> set = hm3.keySet();
for (String key : set) {
String value = hm3.get(key);
System._out.println(_key + “,” + value); } } } }_

案例：HashMap集合存储ArrayList元素并遍历

需求： 创建一个HashMap集合，存储三个元素，每一个元素ArrayList的键是String，值是ArrayList，每一个ArrayList的元素是String，并遍历
思路：
① 创建HashMapt集合
② 创建ArrayList集合，并添加键值对元素
③ 把ArrayList作为元素添加到HashMap集合
④ 遍历HashMap集合
public class HashMapDemo {
_public static void main(String[] args) {
HashMap<_String, ArrayList_<_String_>> hashMap = new HashMap<>();
ArrayList<_String_> a = new ArrayList<>();
a.add(“诸葛亮”);
a.add(“赵云”);
ArrayList<_String_> a1 = new ArrayList<>();
a1.add(“唐僧”);
a1.add(“孙悟空”);
ArrayList<_String_> a2 = new ArrayList<>();
a2.add(“宋江”);
a2.add(“武松”);
hashMap.put(“三国演艺”, a);
hashMap.put(“西游记”, a1);
hashMap.put(“水浒传”, a2);
Set<_String_> set = hashMap.keySet();
for (String s : set) {
ArrayList<_String_> value = hashMap.get(s);
System._out.println(“《” + s + “》”);
for (_String s1 : value) {
System._out.println(“\t” + s1); } } } }

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

需求: 键盘录入一个字符串,要求统计字符串中每个字符串出现的次数
举例: 键盘录入 : “aababcabcdabcde” 在控制太输出:”a(5)b(4)c(3)d(2)e(1)”
分析:
① 我们可以把结果分成几个部分来看: a(5)b(4)c(3)d(2)e(1)
② 每一个部分都是有: 字符和自负队员的次数组成
③ 这样的数据, 我们可以通过HashMap集合来存储, 键是字符, 值是字符出现的次数
注意: 键是字符, 类型应该是Character ; 值是字符出现的次数, 类型应该是Integer
思路:
① 键盘录入一个字符串
② 创建HashMap集合,键是Character , 值是Integer
③ 遍历字符串, 得到每一个字符
④ 拿得到的每一个字符作为键到HashMap集合汇总去找对应的值, 看返回值
⑤ 判断字符的次数, 根据返回值是否为null判断
如果返回值是null: 说明该字符在HashMap集合中不存在, 把该字符作为键, 1作为值
如果返回值不是null : 说明该字符在HashMap集中存在,把该键的值+1,然后重新存储该字符的键和对应的值
⑥ 遍历HashMap集合, 得到键和值, 按照要求进行拼接
⑦ 输出结果
Tips复习:
HashMap的键是Set集合,Set集合是无序且不重复的 — > HashSet集合
TreeMap的键是Comparable自然排序的,是有序的 —> TreeSet 集合
Comparable : 自然排序:Comparable自然排序是重写compareTo()
Comparator : 比较器接口,是创建一个类,实现该接口的compare()方法
public class MapDemo {
_public static void main(String[] args) {
// 键盘录入一个字符串
Scanner scanner = new Scanner(System._in);
System.out.println(“请输入一个字符串: “);
String line = scanner.nextLine();
// 创建HashMap集合,键是Character , 值是Integer
// HashMap的键底层是Set,Set是无序且不重复的
// HashMap hm = new HashMap<>();
// TreeMap的键底层是Comparable自然排序
TreeMap<_Character, Integer> hm = new TreeMap<>();
// 遍历字符串, 得到每一个字符
for (int i = 0; i < line.length(); i++) {
// charAt() 方法用于返回指定索引处的字符
char key = line.charAt(i);
// 拿得到的每一个字符作为键到HashMap集合汇总去找对应的值, 看返回值
Integer value = hm.get(key);// 这里有个基本装箱的动作把int自动装箱为Integer
if (value == null) {
// 如果返回值是null: 说明该字符在HashMap集合中不存在, 把该字符作为键, 1作为值
hm.put(key, 1);
} else {
// 如果返回值不是null : 说明该字符在HashMap集中存在,把该键的值+1
value++; // 有一个自动拆箱的过程,将Integer转换为int 做加法
// 然后重新存储该字符的键和对应的值
hm.put(key, value); } }
// 遍历HashMap集合, 得到键和值,按照要求进行拼接
// 使用StringBuilder 字符串拼接
StringBuilder sb = new StringBuilder();
// 通过keySet()方法获取Map的键
Set<_Character_> keySet = hm.keySet();
for (Character key : keySet) {
// 使用get()方法存入遍历的每个键获取对应的值
Integer value = hm.get(key);
// 使用StringBuilder的append()方法进行字符串的串联拼接
sb.append(key).append(“(“).append(value).append(“)”); }
// 因为是StringBuilder类型需要转换为String
String result = sb.toString();
// 输出结果
System._out.println(_result); } }_