第34讲 双列集合

二、双列集合

双列集合特点

• 双列集合一次需要存一对数据，分别为键和值。
• 键不能重复，值可以重复。
• 键和值是一一对应的，每一个键只能找到唯一对应的值。
• 键和值的整体称之为“键值对”或“键值对对象”，在Java中叫“Entry对象”。

双列集合继承体系

红色：接口

蓝色：实现类

双列集合的选择

条件	选择
默认	HashMap，效率高
存取有序	LinkedHashMap
需要排序	TreeMap

1 Map

Map是所有双列集合的父接口，因此在Map中定义了双列集合通用的一些方法，这些方法可用于操作所有的双列集合。

• JDK不提供此接口的任何直接实现，它提供更具体的子接口实现

Map集合的特点都是由其键决定的，与其值无关。

Map接口：public Interface Map<K,V>

• K 键的类型
• V 值的类型

Map方法及说明

方法名	说明
V put(K key, V value)	添加（覆盖）元素
V remove(Object key)	根据键删除键值对,将值返回
void clear()	移除所有的键值对
boolean containsKey(Object key)	判断集合是否包含指定的键
boolean containsValue(Object value)	判断集合是否包含指定的值
boolean isEmpty()	判断集合是否为空
int size()	集合的长度

注意：

1. 方法put(K key, V value)

• 添加数据时，如果集合中没有该键，则直接添加键值对,并返回null
• 如果集合中有该键，则会覆盖原有键值对，并返回被覆盖的值

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

public class MapDemo1 {
    public static void main(String[] args) {
        Map<String, String> m = new HashMap<>();
        //如果集合中没有该键，则直接添加键值对,并返回null
        String put1 = m.put("Hello", "World");
        System.out.println("put1 = " + put1);	//put1 = null

        //如果集合中有该键，则会覆盖原有键值对，并返回被覆盖的值
        String put2 = m.put("Hello", "Java");
        System.out.println("put2 = " + put2);	//put2 = World
        
        System.out.println(m);	//{Hello=Java}
    }
}

Map遍历方式

1 键找值

1. 将Map集合中的所有键放到一个单列集合Set当中；方法keySet()
2. 遍历单列集合Set。
3. 利用Map集合的键获取对应的值；方法get(Object key)

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

public class MapDemo2 {
    public static void main(String[] args) {
        Map<String, String> m = new HashMap<>();
        m.put("a", "A");
        m.put("b", "B");
        m.put("c", "C");

        //1.将集合中的键添加到Set集合中
        Set<String> keySet = m.keySet();
        //2.遍历Set集合
        keySet.forEach(key -> {
            //3.通过键获取值
            String value = m.get(key);

            System.out.println(key + "=" + value);
        });
    }
}

2 键值对Entry

1. 获取所有的键值对对象，该方法返回一个Set集合；方法Set<Map.Entry<K, V>> entrySet()
2. 遍历Set集合。
3. 获取每一个键和每一个值；方法getKey(), getValue()

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

public class MapDemo3 {
    public static void main(String[] args) {
        Map<String, String> m = new HashMap<>();
        m.put("a", "A");
        m.put("b", "B");
        m.put("c", "C");

        //1.获取所有的键值对对象，该方法返回一个Set集合
        Set<Map.Entry<String, String>> entries = m.entrySet();
        //2.遍历Set集合。
        entries.forEach(entry -> {
            //3.获取每一个键和每一个值
            String key = entry.getKey();
            String value = entry.getValue();

            System.out.println(key + "=" + value);
        });
    }
}

3 Lambda表达式

方法： default void forEach(BiConsumer<? super K, ? super V> action)

• 接口BiConsumer是函数式接口，可用Lambda表达式简写。
• 方法底层：其实就是利用第 2 种遍历方式遍历得到键值对，再调用accept。

import java.util.HashMap;
import java.util.Map;
import java.util.function.BiConsumer;

public class MapDemo4 {
    public static void main(String[] args) {
        Map<String, String> m = new HashMap<>();
        m.put("a", "A");
        m.put("b", "B");
        m.put("c", "C");

        //匿名内部类
        m.forEach(new BiConsumer<String, String>() {
            @Override
            public void accept(String key, String value) {
                System.out.println(key + "=" + value);
            }
        });

        //Lambda表达式
        m.forEach((key, value) -> System.out.println(key + "=" + value));
    }
}

2 HashMap

导包：java.util.HashMap

HashMap集合特点

特点是由键决定的：

• 无序
• 元素不能重复
• 无索引

HashMap没有特有方法，直接使用Map接口里的方法即可。

HashMap底层原理

HashMap源码超详细解析

HashMap底层原理与HashSet一样，都是哈希表结构。

依赖hashCode方法和equals方法保证键的唯一，跟值没有关系。

所以，如果键的位置是自定义类型，需要在自定义类型内重写hashCode方法和equals方法，而不需要实现Compareable接口或者比较器对象。

1. 刚创建对象时，不会创建存储元素的数组，只会做一件事：将默认加载因子置为0.75。

   ​ 当集合长度到达 16 * 加载因子 时，数组会扩容。

2. 添加第一个元素时，会创建一个默认长度16的数组table。

2. 根据键和值创建Entry对象。

3. 根据Entry对象中的键的哈希值（跟值无关）与数组的长度，计算出该元素应存入的位置。

   ​ 计算公式： int index = (数组长度 - 1) & 哈希值

4. 判断计算出的索引位置是否为null

5. 如果是null，直接添加。

6. 如果不是null，调用equals方法比较Entry对象中键属性值：

• 键一样：新添加的Entry对象的值覆盖原有Entry对象的值。（最后还是原Entry对象，只是值被替换了）

• 键不一样：在该索引形成链表（或红黑树），将元素存入。

  • JDK7以前：将新元素存入数组，老元素挂在新元素下面。

  • JDK8以后：将新元素挂在老元素下面。

JDK7以前

JDK8以后

当链表长度大于8，且数组长度大于等于64时，该链表会转换为红黑树（JDK8以后）。

HashMap统计

• 如果统计的数比较多，使用计数器不方便。可以选择使用Map系列集合统计。

要求	使用集合
只统计，别无要求	HashMap，效率高
统计，且排序	TreeMap，可排序

例：某班80名学生，现秋游，有ABCD四个景点。每个学生只能选一个景点，统计哪个景点想去的人最多。

import java.util.*;

public class HashMapDemo2 {
    public static void main(String[] args) {
        //1.模拟投票，并将结果放到ArrayList集合中。
        ArrayList<String> list = new ArrayList<>();
        Random r = new Random();
        String nameArr[] = {"A", "B", "C", "D"};
        for (int i = 0; i < 80; i++) {
            int index = r.nextInt(nameArr.length);
            list.add(nameArr[index]);
        }

        //2.定义Map系列集合，值代表投票个数。 <"景点", 计数器>
        HashMap<String, Integer> hm = new HashMap<>();

        //3.遍历ArrayList集合，将其作为键添加在Map集合中，并统计个数
        for (String name : list) {
            if (hm.containsKey(name)) {
                //如果Map集合里有这个键，就增加一次值（计数器）
                Integer count = hm.get(name);
                count++;
                hm.put(name, count);
            } else {
                //如果Map集合里没有这个键，就添加这个键
                hm.put(name, 1);
            }
        }
        System.out.println(hm);

        //4.遍历Map集合，寻找最大值
        int max = 0;
        Set<Map.Entry<String, Integer>> entries = hm.entrySet();
        for (Map.Entry<String, Integer> entry : entries) {
            int value = entry.getValue();
            max = max > value ? max : value;
        }

        //5.遍历Map集合，寻找最大值对应的键
        for (Map.Entry<String, Integer> entry : entries) {
            int value = entry.getValue();
            if (max == value) {
                System.out.println(entry.getKey());
            }
        }
    }
}
//{A=20, B=19, C=14, D=27}
//D

3 LinkedHashMap

导包：java.util.LinkedHashMap

LinkedHashMap集合特点

特点是由键决定的：

• 有序

  ​ 保证存储和取出的顺序一致。

• 元素不能重复

• 无索引

LinkedHashMap没有特有方法，直接使用Map接口里的方法即可。

LinkedHashMap底层原理

在HashMap基础上多了一条记录顺序的双向链表,

在遍历时会根据该链表记录的顺序遍历,从而保证了存储和取出的元素顺序一致。

4 TreeMap

底层是红黑树。

导包：java.util.TreeMap

TreeMap集合特点

• 可排序：键可以按照一定的规则排序，默认升序，可指定。

• 元素不可重复

• 无索引

​ 没有带索引的方法，不能使用普通for循环遍历。

TreeMap添加元素的时候，是不需要重写键的hashCode和equals方法的。因为集合底层没有用到这两个方法，用的是Compareable接口或者比较器对象。

TreeMap排序规则

键类型	排序规则
数值类型：Integer，Double等	默认按照从小到大的顺序排序。
字符类型	默认按照字符在ASCLL码表中对应的值从小到大排序。
字符串类型	默认排序规则与字符串长度无关，是从首个字符开始往后按字符ASCLL码表中对应的值比。
自定义数据类型（或要指定规则）	需要手动指定排序规则。方法1：自然排序/默认排序；方法2：比较器排序

优先选择方法1，当方法1不能满足要求时，再用方法2

当方法1和方法2同时存在时，以方法2为准。

自然排序

步骤:

1. 让元素所属的JavaBean类实现泛型接口Comparable。导包：java.lang.Comparable

2. 重写compareTo(T o1, T o2)方法指定排序规则。

重写方法时，要注意排序规则必须按照要求的主次条件来写

例：按照学生年龄升序排列，年龄一致按姓名首字母升序排列。如果都一样则认为是同一人。

import java.util.TreeMap;

public class TreeMapDemo2 {
    public static void main(String[] args) {
        TreeMap<Student, String> tm = new TreeMap<>();
        Student s1 = new Student("zhangsan", 18);
        Student s2 = new Student("lisi", 18);
        Student s3 = new Student("zhangsan", 18);
        Student s4 = new Student("wangwu", 20);

        tm.put(s1, "男");
        tm.put(s2, "女");
        tm.put(s3, "女");
        tm.put(s4, "男");
        System.out.println(tm);
        //{Student{name = lisi, age = 18}=女, Student{name = zhangsan, age = 18}=女, Student{name = wangwu, age = 20}=男}
    }
}

class Student implements Comparable<Student> {
    
    //省略JavaBean
    
    @Override
    public int compareTo(Student o) {
        int result = this.getAge() - o.getAge();
        result = result == 0 ? this.getName().compareTo(o.getName()) : result;
        return result;
    }
}

比较器排序

步骤:

1. 让集合构造方法接收比较器接口Comparator的实现类对象，

该接口是函数式接口，可用Lambda表达式简写。

2. 重写compare(T o1, T o2)指定排序规则。

例：按照商品的编号（键）升序

import java.util.TreeMap;

public class TreeMapDemo1 {
    public static void main(String[] args) {
        //Lambda表达式改写
        TreeMap<Integer, String> tm = new TreeMap<>((o1, o2) -> o2 - o1);

        tm.put(1002, "快乐水");
        tm.put(1005, "薯条");
        tm.put(1001, "薯片");
        tm.put(1003, "锅巴");
        tm.put(1004, "巧克力");

        System.out.println(tm); 
        //{1005=薯条, 1004=巧克力, 1003=锅巴, 1002=快乐水, 1001=薯片}
    }
}

TreeMap统计

例：统计字符串"aabccdaedbadeca"中每个字符的个数，并按照a(5)b(2)c(3)d(3)e(2)格式打印。

import java.util.TreeMap;

public class TreeMapDemo3 {
    public static void main(String[] args) {
        String str = "aabccdaedbadeca";
        TreeMap<Character, Integer> tm = new TreeMap<>();
        //1.遍历字符串获取每一个字符，添加到Map集合中计数
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            if (tm.containsKey(c)) {
                //如果Map集合中有该键，则加1
                int count = tm.get(c);
                count++;
                tm.put(c, count);
            } else {
                //如果Map集合中有该键，则创建
                tm.put(c, 1);
            }
        }

        //2.格式化输出
        StringBuilder sb = new StringBuilder();
        //遍历Map集合
        tm.forEach((key, value) -> sb.append(key).append("(").append(value).append(")"));
        System.out.println(sb);	
        //a(5)b(2)c(3)d(3)e(2)
    }
}