一、Map集合

1.1 概述

我们通过查看Map接口描述，发现Map接口下的集合与Collection接口下的集合，它们存储数据的形式不同（类似py的字典）

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

1.2 Map常用子类

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

  • HashMap：存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。
    1.底层是哈希表，查询速度快
    2.HashMap集合是无序的集合,存取顺序不一致
  • LinkedHashMap：HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。
    1.LinkedHashMap集合底层是哈希表+链表
    2.LinkedHashMap集合是一个有序的集合，存取顺序一致

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

1.3 Map接口中的常用方法

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

  • public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。
  • public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
  • public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
  • boolean containsKey(Object key) 判断集合中是否包含指定的键。
  • public Set<K> keySet(): 获取Map集合中所有的键，存储到Set集合中。
  • public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。
  • getOrDefault(Object key, V defaultValue) Java8新特性，如果哈希表中有这个key则获取这个值，如果没有则初始化key的值喂defaultValue
    • 例： map.getOrDefault(1,"none"); :如果map中已经有key为1的了则返回1对应的value值，没有则设置key的value值为none。

Map接口的方法演示

  1. public class MapDemo {
  2.     public static void main(String[] args) {
  3.         //创建 map对象
  4.         HashMap<String, String>  map = new HashMap<String, String>();
  6.         //添加元素到集合
  7.         map.put("黄晓明", "杨颖");
  8.         map.put("文章", "马伊琍");
  9.         map.put("邓超", "孙俪");
  10.         System.out.println(map);
  12.         //String remove(String key)
  13.         System.out.println(map.remove("邓超"));
  14.         System.out.println(map);
  16.         // 想要查看 黄晓明的媳妇 是谁
  17.         System.out.println(map.get("黄晓明"));
  18.         System.out.println(map.get("邓超"));    
  19.     }
  20. }

tips: 使用put方法时，若指定的键(key)在集合中没有，则没有这个键对应的值，返回null，并把指定的键值添加到集合中； 若指定的键(key)在集合中存在，则返回值为集合中键对应的值（该值为替换前的值），并把指定键所对应的值，替换成指定的新值。

1.4 Map集合遍历

键找值方式：即通过元素中的键，获取键所对应的值

分析步骤：

  1. 获取Map中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键。方法提示:keyset()
  2. 遍历键的Set集合，得到每一个键。
  3. 根据键，获取键所对应的值。方法提示:get(K key)
  1. //创建Map集合
  2. Map<String,String> map=new HashMap<>();
  3. map.put("CT","AUG");
  4. map.put("T","SG553");
  5. map.put("CT/T","awp");
  7. //传递key到Set集合
  8. Set<String> set = map.keySet();
  9. //遍历Set集合 (迭代器/增强for循环)
  10. Iterator<String> it=set.iterator();
  11. while(it.hasNext())
  12. {
  13.     String key=it.next();//获取key值
  14.     //通过Map集合中的方法get(k,v)，遍历value值
  15.     String value=map.get(key);
  16.     System.out.println(key+":"+value);
  17. }
  18. System.out.println("----------------------");
  19. //增强for循环(简化版，直接用KeySet方法遍历)
  20. for (String key : map.keySet()) {
  21.     String value=map.get(key);
  22.     System.out.println(key+":"+value);
  23. }
  25. 输出结果：
  26.     CT:AUG
  27.     T:SG553
  28.     CT/T:awp

1.5 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)对象中的键与值。

操作步骤：

  1. 获取Map集合中，所有的键值对(Entry)对象，以Set集合形式返回。方法提示:entrySet()。
  2. 遍历包含键值对(Entry)对象的Set集合，得到每一个键值对(Entry)对象。
  3. 通过键值对(Entry)对象，获取Entry对象中的键与值。 方法提示:getkey() getValue()
  1. public static void main(String[] args) {
  2.         Map<String,String> map=new HashMap<>();
  3.         map.put("SG553","意式拉力");
  4.         map.put("AWP","雷击");
  5.         map.put("AK47","血腥行动");
  7.         //获取 所有 entry对象存入Set集合
  8.         Set<Map.Entry<String,String>> entrySet=map.entrySet();
  10.         //遍历entry对象
  11.         for (Map.Entry<String, String> entry : entrySet) {
  12.             //解析
  13.             String key=entry.getKey();
  14.             String value=entry.getValue();
  15.             System.out.println(key+":"+value);
  16.         }
  17.     }
  19. 输出结果
  20. AK47:血腥行动
  21. AWP:雷击
  22. SG553:意式拉力

1.6 HashMap存储自定义类型对象键值对

创建一个Person类包含姓名、年龄，将Person类对象和地址存储到Map集合中，Person为key，地址为value；

创建Person类

  1. public class Person {
  2.     private String name;
  3.     private int age;
  5.     //构造方法和Get、Set.....
  7.     @Override
  8.     public String toString() {
  9.         return "Person{" +
  10.                 "name='" + name + '\'' +
  11.                 ", age=" + age +
  12.                 '}';
  13.     }
  15.     @Override
  16.     public boolean equals(Object o) {
  17.         if (this == o) return true;
  18.         if (o == null || getClass() != o.getClass()) return false;
  19.         Person person = (Person) o;
  20.         return age == person.age &&
  21.                 Objects.equals(name, person.name);
  22.     }
  24.     @Override
  25.     public int hashCode() {
  26.         return Objects.hash(name, age);
  27.     }
  28. }

创建测试类

  1. public class Demo03HashMapObject {
  2.     public static void main(String[] args) {
  3.         Map<Person,String> map=new HashMap<>();
  5.         map.put(new Person("王亨利",44),"卡拉迪亚");
  6.         map.put(new Person("阿飞",56),"kenshi");
  7.         map.put(new Person("响当当",26),"太吾村");
  9.         //遍历
  10.         Set<Person> keySet=map.keySet();
  11.         for (Person person : keySet) {
  12.             String place=map.get(person);
  13.             System.out.println(person.toString()+"-----"+place);
  14.         }
  15.     }
  16. }
  18. 输出结果：
  19. Person{name='响当当', age=26}-----太吾村
  20. Person{name='王亨利', age=44}-----卡拉迪亚
  21. Person{name='阿飞', age=56}-----kenshi

1.7 LinkedHashMap

我们知道HashMap保证成对元素唯一，并且查询速度很快，可是成对元素存放进去是没有顺序的，那么我们要保证有序，还要速度快怎么办呢？

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

  1. public class LinkedHashMapDemo {
  2.     public static void main(String[] args) {
  3.         LinkedHashMap<String, String> map = new LinkedHashMap<String, String>();
  4.         map.put("邓超", "孙俪");
  5.         map.put("李晨", "范冰冰");
  6.         map.put("刘德华", "朱丽倩");
  7.         Set<Entry<String, String>> entrySet = map.entrySet();
  8.         for (Entry<String, String> entry : entrySet) {
  9.             System.out.println(entry.getKey() + "  " + entry.getValue());
  10.         }
  11.     }
  12. }

结果:

  1. 邓超  孙俪
  2. 李晨  范冰冰
  3. 刘德华  朱丽倩

1.8 练习

输入一串字符串，判断各个字符出现的次数

public class Demo04test {
    public static void main(String[] args) {
        System.out.println("请输入一串字符串");
        String line=new Scanner(System.in).nextLine();
        //定义一个方法，判断各字符出现的次数
        findChar(line);
    }

    private static void findChar(String line) {
        HashMap<Character,Integer> map=new HashMap<>();
        for (int i = 0; i <line.length() ; i++) {
            char temp=line.charAt(i);
            if(!map.containsKey(temp))  map.put(temp,1);
            else{
                Integer count=map.get(temp);
                map.put(temp,++count);
            }
        }
        System.out.println(map);
    }
}

结果：
请输入一串字符串
acccabbcddeeffaggg
{a=3, b=2, c=4, d=2, e=2, f=2, g=3}

LeetCode：1027 独一无二的出现次数

语雀内容

二、JDK9的集合优化方法

JDK9的新特性：

        List接口、Set接口、Map接口：里面增加了一个静态的方法of，可以给集合一次性添加多个元素

        `static <E> List<E> of(E....elements)`

        使用前提：

                    当前集合中存储的元素的个数已经确定了，不再改变

**注意：**
  • of方法只适用于List接口、Set接口、Map接口，不适用于接口的实现类
  • of方法的返回值是一个不能改变的集合，集合不能再使用add，put方法，会抛出异常
  • Set接口和Map接口在调用of方法的时候不能有重复的元素
public class Demo01Of {
    public static void main(String[] args) {
        List<String> list=List.of("a","b","c","d","e","f","g");
        System.out.println(list);//[a, b, c, d, e, f, g]
        //list.add("h");//UnsupportedOperationException:不支持异常

        //Set<String> set= Set.of("a","a","b","c","d");
        //元素重复 IllegalArgumentException:非法参数异常
        Set<String> set= Set.of("a","b","c","d");
        System.out.println(set);
        //set.add("e");//UnsupportedOperationException:不支持异常

        Map<String,Integer> map= Map.of("张三",20,"李四",23);
        System.out.println(map);
        //map.put("赵四",30);//UnsupportedOperationException:不支持异常
    }
}