第一章 Map集合

1.1 概述

• Collection中的集合，元素是孤立存在的，向集合中存储元素采用一个个元素的方式存储。
• Map中的集合，元素是成对存在的。每个元素由键与值两部分组成，通过键可以找对所对应的值。
• Collection中的集合称为单列集合，Map中的集合称为双列集合。
• 需要注意的是，Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。

（1）、Map集合的特点：

1. Map集合是一个双列集合，一个元素包含两个值（一个key，一个value）。
2. Map集合中的元素，key和value的数据类型可以相同，也可以不同。
3. Map集合中的元素，key是不允许重复的，value是可以重复的。
4. Map集合中的元素，key和value是 一 一 对应的。

1.2 Map常用子类

通过查看Map接口描述，看到Map有多个子类，这里我们主要讲解常用的HashMap集合、LinkedHashMap集合。

• HashMap<K,V>：存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。
• LinkedHashMap<K,V>：HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

tips：Map接口中的集合都有两个泛型变量<K,V>,在使用时，要为两个泛型变量赋予数据类型。两个泛型变量<K,V>的数据类型可以相同，也可以不同。

（1）、HashMap集合的特点：

1. HashMap集合底层是哈希表，查询的速度特别的快。JDK1.8之前：数组+单向链表，JDK1.8之后：数组+单向链表/红黑树（链表的长度超过8）；提高查询的速度。
2. HashMap集合是一个无序的集合，存储元素和取出元素的顺序有可能不一样。

（2）、LinkedHashMap集合特点：

1. LinkedHashMap集合底层是哈希表+链表（保证迭代的顺序）。
2. LinkedHashMap集合是一个有序的集合，存储元素和取出元素的顺序是一致的。

1.3 Map接口中的常用方法

Map接口中定义了很多方法，常用的如下：

• public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。

• 返回值：
  ①、存储键值对的时候，key不重复，返回值value是null.
  ②、存储键值对的时候，key重复，会使用新的value替换map中重复的value，返回被替换的value值

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

public class Main {
    public static void main(String[] args) {
        show01();
    }
    private static void show01(){
        //创建Map集合对象，多态
        Map<String,String> map = new HashMap<>();

        String v1 = map.put("工藤新一", "毛利兰1");
        System.out.println("v1:"+v1);//没有重复的返回null；v1:null
        String v2 = map.put("工藤新一", "毛利兰2");
        System.out.println("v2:"+v2);//重复时，返回的是被替换的；v2:毛利兰1
        System.out.println(map);//{工藤新一=毛利兰2}

        map.put("冷锋","龙小云");
        map.put("杨过","小龙女");
        map.put("尹志平","小龙女");
        System.out.println(map);//{杨过=小龙女, 尹志平=小龙女, 工藤新一=毛利兰2, 冷锋=龙小云}
    }
}

• public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
• 返回值：
  ①、key存在,value返回被删除的值。
  ②、key不存在,value返回null。

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

public class Main {
    public static void main(String[] args) {
        show02();
    }

    private static void show02(){
        //创建Map集合对象，多态
        Map<String,Integer> map = new HashMap<>();
        map.put("路飞",168);
        map.put("索隆",165);
        map.put("娜美",178);
        System.out.println(map);//{娜美=178, 索隆=165, 路飞=168}

        Integer v1 = map.remove("娜美");
        System.out.println("v1:"+v1);//v1:178

        System.out.println(map);//{索隆=165, 路飞=168}

        //Int v2 = map.remove("乌索普");使用int类型，自动拆箱，报NullPointerException
        Integer v2 = map.remove("乌索普");//null可以赋值给包装类Integer,但是不能赋值给int类型
        System.out.println("v2:"+v2);//v2:null

        System.out.println(map);//{索隆=165, 路飞=168}
    }
}

• public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
• 返回值：
  ①、key存在,value返回对应的值。
  ②、key不存在,value返回null。

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

public class Main {
    public static void main(String[] args) {
        show03();
    }

    private static void show03(){
        //创建Map集合对象，多态
        Map<String,Integer> map = new HashMap<>();
        map.put("路飞",168);
        map.put("索隆",165);
        map.put("娜美",178);

        Integer v1 = map.get("索隆");
        System.out.println("v1:"+v1);//v1:165

        Integer v2 = map.get("乌索普");
        System.out.println("v2:"+v2);//v2:null
    }
}

• boolean containsKey(Object key) 判断集合中是否包含指定的键。包含返回true，不包含返回false

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

public class Main {
    public static void main(String[] args) {
        show04();
    }
    private static void show04(){
        //创建Map集合对象，多态
        Map<String,Integer> map = new HashMap<>();
        map.put("路飞",168);
        map.put("索隆",165);
        map.put("娜美",178);

        boolean b1 = map.containsKey("路飞");
        System.out.println("b1:"+b1);//b1:true

        boolean b2 = map.containsKey("山治");
        System.out.println("b2:"+b2);//b2:false
    }
}

• public Set<K> keySet(): 获取Map集合中所有的键，存储到Set集合中。
• public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。

Map接口的方法演示

public class MapDemo {
    public static void main(String[] args) {
        //创建 map对象
        HashMap<String, String>  map = new HashMap<String, String>();

        //添加元素到集合
        map.put("黄晓明", "杨颖");
        map.put("文章", "马伊琍");
        map.put("邓超", "孙俪");
        System.out.println(map);

        //String remove(String key)
        System.out.println(map.remove("邓超"));
        System.out.println(map);

        // 想要查看 黄晓明的媳妇 是谁
        System.out.println(map.get("黄晓明"));
        System.out.println(map.get("邓超"));    
    }
}

tips:

使用put方法时，若指定的键(key)在集合中没有，则没有这个键对应的值，返回null，并把指定的键值添加到集合中；

若指定的键(key)在集合中存在，则返回值为集合中键对应的值（该值为替换前的值），并把指定键所对应的值，替换成指定的新值。

1.4 Map集合遍历键找值方式

（1）、Map集合的第一种遍历方式：通过键找值得方式

• Map集合中的方法：Set< K > keySet():返回此映射中包含的键的Set视图。
• 实现步骤：
  ①、使用Map集合中的方法keySet(),把Map集合所有的key取出来，存储到一个Set集合中
  ②、遍历Set集合,获取Map集合中的每一个key
  ③、通过Map集合中的方法get(key),通过key找到value

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

public class Main {
    public static void main(String[] args) {
        //创建Map集合对象
        Map<String,Integer> map = new HashMap<>();
        map.put("赵丽颖",168);
        map.put("杨颖",165);
        map.put("林志玲",178);

        //1.使用Map集合中的方法keySet(),把Map集合所有的key取出来,存储到一个Set集合中
        Set<String> set = map.keySet();

        //2.遍历set集合,获取Map集合中的每一个key
        //使用迭代器遍历Set集合
        Iterator<String> it = set.iterator();
        while (it.hasNext()){
            String key = it.next();
            //3.通过Map集合中的方法get(key),通过key找到value
            Integer value = map.get(key);
            System.out.println(key+"="+value);
        }
        System.out.println("-----------------------------");
        //使用增强for遍历Set
        for (String key : set) {
            //3.通过Map集合中的方法get(key),通过key找到value
            Integer value = map.get(key);
            System.out.println(key+"="+value);
        }
    }
}
运算结果：
林志玲=178
赵丽颖=168
杨颖=165
------------
林志玲=178
赵丽颖=168
杨颖=165

遍历图解：

（2）、Map集合遍历的第二种方式：使用Entry对象遍历

我们已经知道，Map中存放的是两种对象，一种称为key(键)，一种称为value(值)，它们在在Map中是一一对应关系，这一对对象又称做Map中的一个Entry(项)。Entry将键值对的对应关系封装成了对象。即键值对对象，这样我们在遍历Map集合时，就可以从每一个键值对（Entry）对象中获取对应的键与对应的值。

既然Entry表示了一对键和值，那么也同样提供了获取对应键和对应值得方法：

• public K getKey()：获取Entry对象中的键。
• public V getValue()：获取Entry对象中的值。

在Map集合中也提供了获取所有Entry对象的方法：

• public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。

遍历方法：

键值对方式：即通过集合中每个键值对(Entry)对象，获取键值对(Entry)对象中的键与值。

• Map集合遍历的第二种方式：使用Entry对象遍历
• Map集合中的方法：Set<Map.Entry<K,V>> entrySet():返回此映射中包含的映射关系的Set视图。
• 实现步骤：
  ①、使用Map集合中的方法entrySet(),把Map集合中多个Entry对象取出来，存储到一个Set集合中。
  ②、遍历Set集合,获取每一个Entry对象。
  ③、使用Entry对象中的方法getKey()和getValue获取键与值。

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

public class Main {
    public static void main(String[] args) {
        //创建Map集合对象
        Map<String,Integer> map = new HashMap<>();
        map.put("赵丽颖",168);
        map.put("杨颖",165);
        map.put("林志玲",178);


        //1.使用Map集合中的方法entrySet(),把Map集合中多个Entry对象取出来，存储到一个Set集合中。
        Set<Map.Entry<String, Integer>> set = map.entrySet();

        //2.遍历Set集合,获取每一个Entry对象。
        //使用迭代器遍历Set集合
        Iterator<Map.Entry<String, Integer>> it = set.iterator();
        while (it.hasNext()){
            Map.Entry<String,Integer> entry = it.next();
            //3.使用Entry对象中的方法getKey()和getValue获取键与值。
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key+"="+value);
        }
        System.out.println("--------------------");
        for (Map.Entry<String, Integer> entry : set) {
            //3.使用Entry对象中的方法getKey()和getValue获取键与值。
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key+"="+value);
        }
    }
}
运行结果：
林志玲=178
赵丽颖=168
杨颖=165
----------
林志玲=178
赵丽颖=168
杨颖=165

tips：Map集合不能直接使用迭代器或者foreach进行遍历。但是转成Set之后就可以使用了。

1.5 HashMap存储自定义类型键值

练习：每位Person类（姓名，年龄）都有自己的家庭住址。那么，既然有对应关系，则将学生对象和家庭住址存储到map集合中。学生作为键, 家庭住址作为值。

注意，学生姓名相同并且年龄相同视为同一名学生。

编写Person类：

public class Person{
    private String name;
    private int age;

    public Person() {
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", 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;
    }
}

编写测试类：

public class Main {
    public static void main(String[] args) {
        show01();
    }
    /**
     * HashMap存储自定义类型键值
     * key:String类型
     *     String类重写hashCode方法和equals方法,可以保证key唯一
     * value:Person类型
     *     value可以重复(同名同年龄的人视为同一个人)
     */
    private static void show01(){
        //创建HashMap集合
        HashMap<String,Person> map = new HashMap<>();
        //往集合中添加元素
        map.put("北京",new Person("张三",18));
        map.put("上海",new Person("李四",19));
        map.put("广州",new Person("王五",20));
        map.put("北京",new Person("赵六",18));

        //使用keySet+增强for遍历Map集合
        Set<String> set = map.keySet();
        for (String key : set) {
            Person value = map.get(key);
            System.out.println(key+"--->"+value);
        }
    }
}
运行结果：
上海--->Person{name='李四', age=19}
广州--->Person{name='王五', age=20}
北京--->Person{name='赵六', age=18}

• 当给HashMap中存放自定义对象时，如果自定义对象作为key存在，这时要保证对象唯一，必须复写对象的hashCode和equals方法。
• 如果要保证map中存放的key和取出的顺序一致，可以使用java.util.LinkedHashMap集合来存放。

public class Main {
    public static void main(String[] args) {
        show02();
    }
    /**
     * HashMap存储自定义类型键值
     * key:Person类型
     *      Person类型就必须重写hashCode方法和equals方法，以保证key唯一。
     * value:String类型
     *      可以重复
     */
    private static void show02(){
        //创建HashMap集合
        HashMap<Person,String> map = new HashMap<>();
        //往集合中添加元素
        map.put(new Person("女王",18),"英国");
        map.put(new Person("秦始皇",18),"秦国");
        map.put(new Person("普京",18),"俄罗斯");
        map.put(new Person("女王",18),"毛里求斯");
        //使用entrySet和增强for遍历Map集合
        Set<Map.Entry<Person, String>> set = map.entrySet();
        for (Map.Entry<Person, String> entry : set) {
            Person key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+"--->"+value);
        }
    }
}
运行结果：
Person{name='女王', age=18}--->英国
Person{name='女王', age=18}--->毛里求斯
Person{name='秦始皇', age=18}--->秦国
Person{name='普京', age=18}--->俄罗斯

• HashMap存储自定义类型的值
• Map集合保证key是唯一的：
  作为key的元素,必须重写hashCode方法和equals方法，以保证key唯一。

倘若在Person类中添加重写hashCode方法和equals方法，以保证key唯一。

@Override
public boolean equals(Object o) {
     if (this == o) return true;
     if (o == null || getClass() != o.getClass()) return false;
     Person person = (Person) o;
     return age == person.age &&
            Objects.equals(name, person.name);
}

再次运行，结果为：

Person{name='女王', age=18}--->毛里求斯
Person{name='秦始皇', age=18}--->秦国
Person{name='普京', age=18}--->俄罗斯

1.8 LinkedHashMap集合

在HashMap下面有一个子类LinkedHashMap，它是链表和哈希表组合的一个数据存储结构。

• java.util.LinkedhashMap<K , V> extends HashMap<K , V>
• Map接口的哈希表和链接列表实现，具有可预知的迭代顺序。
• 底层原理：哈希表+链表（记录元素的顺序）

import java.util.HashMap;
import java.util.LinkedHashMap;

public class Main {
    public static void main(String[] args) {
        HashMap<String,String> map = new HashMap<>();
        map.put("a","a");
        map.put("c","c");
        map.put("b","b");
        map.put("a","d");
        System.out.println(map);//不允许重复,无序,{a=d, b=b, c=c}

        LinkedHashMap<String,String> linked = new LinkedHashMap<>();
        linked.put("a","a");
        linked.put("c","c");
        linked.put("b","b");
        linked.put("a","d");
        System.out.println(linked);//不允许重复,有序,{a=d, c=c, b=b}
    }
}

1.9 Hashtable集合

• java.util.Hashtable<K , V>集合 implement Map<K , V>接口
• Hashtable：底层也是一个哈希表，是一个线程安全的集合，是单线程集合，速度慢。
• HashMap：底层是一个哈希表，是一个线程不安全的集合，是多线程的集合，速度快。
• HashMap集合（之前学的所有的集合）：可以存储null值，null键。
• Hashtable集合：不能存储null值，不能存储null键。
• Hashtable和Vector集合一样，在jdk1.2版本之后被更先进的集合（HashMap和ArrayList）取代了。
• Hashtable的子类Properties依然活跃在历史的舞台，Properties集合是一个唯一和IO流相结合的集合

import java.util.HashMap;
import java.util.Hashtable;

public class Main {
    public static void main(String[] args) {
        HashMap<String,String> map = new HashMap<>();
        map.put(null,"a");
        map.put("b",null);
        map.put(null,null);
        System.out.println(map);//{null=null, b=null}

        Hashtable<String,String> table = new Hashtable<>();
//        table.put(null,"a");//NullPointerException
//        table.put("b",null);//NullPointerException
//        table.put(null,null);//NullPointerException
        System.out.println(table);
    }
}

1.10 Map集合练习

需求：
计算一个字符串中每个字符出现次数。
分析：

1. 使用Scanner获取用户输入的字符串
2. 创建Map集合，key是字符串中的字符，value是字符的个数。
3. 遍历字符串，获取每一个字符。
4. 使用获取到的字符，去Map集合判断key是否存在。
   ①、key存在：通过字符（key），获取value（字符个数），value++，put(key,value)把新的value存储到Map集合中。
   ②、key不存在：put（key，1）
5. 遍历Map集合，输出结果。
   

import java.util.HashMap;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        //1.使用Scanner获取用户输入的字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String str = sc.next();
        //2.创建Map集合，key是字符串中的字符,value是字符的个数
        HashMap<Character,Integer> map = new HashMap<>();
        //3.遍历字符串，获取每一个字符
        for(char c:str.toCharArray()){
            //4.使用获取到的字符，去Map集合判断key是否存在。
            if (map.containsKey(c)){
                //key存在
                Integer value = map.get(c);
                value++;
                map.put(c,value);
            }else {
                //key不存在
                map.put(c,1);
            }
        }
        //5.遍历Map集合，输出结果
        for(Character key:map.keySet()){
            Integer value = map.get(key);
            System.out.println(key+"="+value);
        }
    }
}

本文地址：https://blog.csdn.net/qq_44096670/article/details/107344324

如您对本文有疑问或者有任何想说的，请 点击进行留言回复，万千网友为您解惑！