【JavaDS】集合Map和Set及其相关实现类

✨博客主页: 心荣~
✨系列专栏:【Java实现数据结构】
✨一句短话: 难在坚持,贵在坚持,成在坚持!

一. Map和Set的概述

Map和Set是一种专门用来进行搜索的容器或者数据结构，其搜索的效率与其具体的实例化子类有关。

以前常见的搜索方式有：

1. 直接遍历，时间复杂度为O(N)，元素如果比较多效率会非常慢
2. 二分查找，时间复杂度为O(logN) ,但搜索前必须要求序列是有序的

上述排序比较适合静态类型的查找，即一般不会对区间进行插入和删除操作了，而现实中的查找比如：

1. 根据姓名查询考试成绩
2. 通讯录，即根据姓名查询联系方式
3. 不重复集合，即需要先搜索关键字是否已经在集合中

可能在查找时进行一些插入和删除的操作，即动态查找，那上述两种方式就不太适合了，这里介绍的Map和Set是一种适合动态查找的集合容器。

两种模型 :

一般把搜索的数据称为关键字（Key），和关键字对应的称为值（Value），将其称之为Key-value的键值对，所以模型会有两种：

1. 纯 key 模型(Set就是一个纯key模型)，比如 :

• 有一个英文词典，快速查找一个单词是否在词典中。
• 快速查找某个名字在不在通讯录中。

2. Key-Value 模型(Map就是一个key-val模型)，比如 :

• 统计文件中每个单词出现的次数，统计结果是每个单词都有与其对应的次数：<单词，单词出现的次数>。
• 梁山好汉的江湖绰号：每个好汉都有自己的江湖绰号。

二. Map

Map没有继承自Collection/Iterable接口，所以Map不能使用迭代器去遍历, 实现该接口的实现类中存储的是结构的键值对，并且K一定是唯一的，不能重复。

1. 注意事项

1. Map是一个接口，不能直接实例化对象，如果要实例化对象只能实例化其实现类TreeMap或者HashMap
2. Map中存放键值对的Key是唯一的，value是可以重复的
3. Map中的Key可以全部分离出来，存储到Set中来进行访问(因为Key不能重复)。
4. Map中的value可以全部分离出来，存储在Collection的任何一个子集合中(value可能有重复)。
5. Map中键值对的Key不能直接修改，value可以修改，如果要修改key，只能先将该key删除掉，然后再来进行重新插入。

2. 关于Map.Entry的说明

Map.Entry是Map内部实现的用来存放键值对映射关系的内部类，该内部类中主要提供了的获取，value的设置以及Key的比较方式 :

方法	解释
K getKey();	返回 entry 中的 key
V getValue();	返回 entry 中的 value
V setValue(V value);	将键值对中的value替换为指定value

注意：Map.Entry并没有提供设置Key的方法

3. Map接口中常用方法

方法	解释
int size();	获取map中键值对个数
boolean isEmpty();	判断map是否为空表
boolean containsKey(Object key);	判断map中是否包含关键字key
boolean containsValue(Object value);	判断map中是否包含值value
V get(Object key);	根据关键字key获取value
V put(K key, V value);	增加键值对，如果已经存在则更新value值
V remove(Object key);	根据关键字key删除键值对
void putAll(Map m);	根据传入的map插入键值对
void clear();	清空map
Set keySet();	获取map中所有的key并放入set集合中
Collection values();	获取map中所有的value，并放入collection集合中，可重复
Set> entrySet();	将map中所有的键值对以Map.Entry类型打包到set中
default V getOrDefault(Object key, V defaultValue)	返回 key 对应的 value，key 不存在，返回默认值
default V replace(K key, V value)	修改key关键字对应的value
default boolean replace(K key, V oldValue, V newValue)	将关键字对应的oldValue修改为newValue

通过下面的代码区分get()和 getOrDefault()两个方法的细节

当我们通过get 获取的是Integer类型的值，让他赋值给整形会发生拆包，这里map中没有key，那么会返回null，此时拆包，就会发生空指针异常;

而使用 getOrDefault() , 如果map中没有key , 就会返回我们设置的默认值, 就不会进行拆包操作了 .

4. HashMap和TreeMap

HashMap与TreeMap都实现了Map接口, 两者的区别如下:

Map底层结构	TreeMap	HashMap
底层结构	红黑树	哈希桶（表）
插入/删除/查找时间复杂度	O(log2N)	O(1)
是否有序	关于Key有序 (因为实现了SortedMap接口)	无序 (哈希表是散列表）
线程安全	不安全	不安全
插入/删除/查找区别	需要进行元素比较	通过哈希函数计算哈希地址
比较与覆写	key必须能够比较，否则会抛出ClassCastException异常	自定义类型需要覆写equals和 hashCode方法
应用场景	需要Key有序场景下	Key是否有序不关心，需要更高的时间性能

TreeMap继承关系图如下:

TreeMap构造方法	解释
public TreeMap()	无参构造
public TreeMap(Comparator comparator)	传入比较器，能够控制Mapk的key的排序
public TreeMap(Map m)	根据传入的map对象来构造新的Treemap对象
public TreeMap(SortedMap m)	根据传入的SortedMap对象构造新的Treemap对象

HashMap继承关系图如下:

HashMap构造方法	解释
public HashMap()	无参构造
public HashMap(int initialCapacity, float loadFactor)	指定容量（必须是二的幂）和负载因子构造对象
public HashMap(int initialCapacity)	指定容量（必须是二的幂）构造对象
public HashMap(Map m)	根据map对象构造新HashMap对象

5. 遍历Map

Map当中没有实现Iterable接口, 所以遍历map的思路是将Map放到实现Iterable接口中的Set中即可;

• 通过keySet()方法

public static void main(String[] args) {
    Map<String,Integer> map = new HashMap<>();
    map.put("张三",1);
    map.put("李四",2);
    map.put("王五",3);
    Set<String> set = map.keySet();
    for (String s : set) {
        System.out.println(s+" = "+map.get(s));
    }
}

• 通过entrySet()方法

public static void main(String[] args) {
    Map<String,Integer> map = new HashMap<>();
    map.put("张三",1);
    map.put("李四",2);
    map.put("王五",3);
    Set<Map.Entry<String, Integer>> entries = map.entrySet();
    for (Map.Entry<String, Integer> entry : entries) {
        System.out.println(entry.getKey()+" = "+entry.getValue());
    }
}

• 通过Map提供的forEach(BiConsumer)方法

BiConsumer是一个函数式接口，接受两个输入参数

public static void main(String[] args) {
    Map<String,Integer> map = new HashMap<>();
    map.put("张三",1);
    map.put("李四",2);
    map.put("王五",3);
    map.forEach(new BiConsumer<String, Integer>() {
        @Override
        public void accept(String key, Integer value) {
            System.out.println(key+" = "+value);
        }
    });
}

三. Set

1. 注意事项

1. Set是继承自Collection的一个接口类
2. Set中只存储了key，并且要求key一定要唯一
3. Set的底层是使用Map来实现的，其使用key与Object的一个默认对象作为键值对插入到Map中的
4. Set最大的功能就是对集合中的元素进行去重
5. 实现Set接口的常用类有TreeSet和HashSet，还有一个LinkedHashSet，LinkedHashSet是在HashSet的基础上维护了一个双向链表来记录元素的插入次序。
6. Set中的Key不能修改，如果要修改，先将原来的删除掉，然后再重新插入

2. Set接口中常用方法

Set接口中大部分方法都是从Collection接口中扩展的，常用方法如下：

方法	解释
int size();	获取集合中元素的个数
boolean isEmpty();	判断集合是否为空表
boolean contains(Object o);	判断set是否包含对象o
Iterator iterator();	获取集合迭代器
Object[] toArray();	将set转换成Object数组
T[] toArray(T[] a);	将set转换为数组
boolean add(E e);	增加元素e
boolean remove(Object o);	删除元素o
boolean containsAll(Collection c);	判断set中是否含有collection对象中所有的元素
boolean addAll(Collection c);	插入c对象中所有的元素，可以去重
boolean retainAll(Collection c);	set中保留和两个集合的交集
boolean removeAll(Collection c);	根据c对象元素对应删除set中的元素
void clear();	清空set对象里面所有元素

3. TreeSet和HashSet

HashSet与TreeSet都实现了Set接口, 两者的区别如下:

Set底层结构	TreeSet	HashSet
底层结构	红黑树	哈希桶（表）
插入/删除/查找时间复杂度	O(log2N)	O(1)
是否有序	关于Key有序 (因为实现了SortedSet接口)	无序 (哈希表是散列表）
线程安全	不安全	不安全
插入/删除/查找区别	按照红黑树的特性来进行插入和删除	1.先计算key哈希地址2.然后进行插入和删除
比较与覆写	key必须能够比较，否则会抛出ClassCastException异常	自定义类型需要覆写equals和 hashCode方法
应用场景	需要Key有序场景下	Key是否有序不关心，需要更高的时间性能

TreeSet继承关系图如下:

TreeSet构造方法	解释
public TreeSet()	无参构造
public TreeSet(Comparator comparator)	传入比较器，控制set的排序
public TreeSet(Collection c)	根据集合c的元素创建TreeSet
public TreeSet(SortedSet s)	根据SortedSet对象的元素创建TreeSet

HashSet继承关系图如下:

HashSet构造方法	解释
public HashSet()	无参构造
public HashSet(Collection c)	根据集合对象c构造HashSet对象
public HashSet(int initialCapacity, float loadFactor)	指定容量（必须是二的幂）和负载因子构造HashSet对象
public HashSet(int initialCapacity)	指定容量（必须是二的幂）构造HashSet对象

4. 遍历Set

• 通过迭代器遍历

public static void main(String[] args) {
    Set<Integer> set = new HashSet<>();
    set.add(1);
    set.add(2);
    set.add(3);
    Iterator<Integer> it = set.iterator();
    while(it.hasNext()) {
        System.out.print(it.next()+" ");
    }
}

• foreach遍历

public static void main(String[] args) {
    Set<Integer> set = new HashSet<>();
    set.add(1);
    set.add(2);
    set.add(3);
    for (Integer integer : set) {
        System.out.print(integer+" ");
    }
}

• 通过Iterable接口中的forEach(Consumer)方法

Consumer是一个函数式接口，接受一个输入参数

public static void main(String[] args) {
    Set<Integer> set = new HashSet<>();
    set.add(1);
    set.add(2);
    set.add(3);
    set.forEach(new Consumer<Integer>() {
        @Override
        public void accept(Integer key) {
            System.out.print(key+" ");
        }
    });
}

四. 小试牛刀

解决下面的三个问题:

1. 统计10W个数据当中，不重复的数据？(去重)
2. 统计10W个数据当中，第一个重复的数据？
3. 统计10W个数据当中，每个数据出现的次数？ (对应的关系)

import java.util.*;

public class Test {
    //1、统计10W个数据当中，不重复的数据？[去重]
    public static void func1(int[] array) {
        Set<Integer> set = new HashSet<>();
        for (int i = 0; i < array.length; i++) {
            set.add(array[i]);
        }
        System.out.println(set);
    }
    //2、统计10W个数据当中，第一个重复的数据？
    public static void func2(int[] array) {
        Set<Integer> set = new HashSet<>();
        for (int i = 0; i < array.length; i++) {
            if(!set.contains(array[i])) {
                set.add(array[i]);
            }else {
                System.out.println(array[i]);
                break;
            }
        }
    }
    //3、统计10W个数据当中，每个数据出现的次数？ 对应的关系
    public static void func3(int[] array) {
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < array.length; i++) {
            int key = array[i];
            if(map.get(key) == null) {
                map.put(key, 1);
            }else {
                int val = map.get(key);
                map.put(key, val+1);
            }
        }
        for (Map.Entry<Integer, Integer> entry:map.entrySet()) {
            System.out.println("key: "+ entry.getKey()+"出现了: "+entry.getValue()+" 次");
        }
    }

    public static void main(String[] args) {
        int[] array = new int[10_0000];
        Random random = new Random();
        for (int i = 0; i < array.length; i++) {
            array[i] = random.nextInt(5_0000);
        }
        func1(array);
        func2(array);
        func3(array);
    }
}