JAVA数据结构之Map和Set

达斯米奇430

已于 2022-10-30 23:33:51 修改

阅读量1.1k

点赞数 1

文章标签： java 数据结构

于 2022-10-30 23:20:36 首次发布

本文链接：https://blog.csdn.net/qq_66530223/article/details/127603023

版权

一、什么是Map和Set

1.1、概念及使用场景

Map和set是一种专门用来进行搜索的容器或者数据结构，其搜索的效率与其具体的实例化子类有关。以前常见的
搜索方式有：
1. 直接遍历，时间复杂度为O(N)，元素如果比较多效率会非常慢
2. 二分查找，时间复杂度为O( ${log_{2}}^{}N$ ) ,但搜索前必须要求序列是有序的

上述排序比较适合静态类型的查找，即一般不会对区间进行插入和删除操作了，而现实中的查找比如：
1. 根据姓名查询考试成绩
2. 通讯录，即根据姓名查询联系方式
3. 不重复集合，即需要先搜索关键字是否已经在集合中
可能在查找时进行一些插入和删除的操作，即动态查找，那上述两种方式就不太适合了，本文介绍的Map和Set是一种适合动态查找的集合容器。

1.2、模型

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

1. 纯 key 模型，比如：
有一个英文词典，快速查找一个单词是否在词典中
快速查找某个名字在不在通讯录中
2. Key-Value 模型，比如：
统计文件中每个单词出现的次数，统计结果是每个单词都有与其对应的次数：<单词，单词出现的次数>
梁山好汉的江湖绰号：每个好汉都有自己的江湖绰号
而Map中存储的就是key-value的键值对，Set中只存储了Key。

二、Map 的使用

Map的官方文档

2.1、Map的说明

Map是一个接口类，该类没有继承自Collection，该类中存储的是<K,V>结构的键值对，并且K一定是唯一的，不能重复。

2.2、Map.Entry<K, V>的说明

Map.Entry<K, V> 是Map内部实现的用来存放<key, value>键值对映射关系的内部类，

该内部类中主要提供了<key, value>的获取，value的设置以及Key的比较方式。

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

注意：Map.Entry<K,V>并没有提供设置Key的方法

2.3、Map 的常用方法说明

方法	解释
V get(Object key)	返回key对应的value
V getOrDefault(Object key, V defaultValue)	返回 key 对应的 value，key 不存在，返回默认值
V put(K key, V value)	设置 key 对应的 value
V remove(Object key)	删除 key 对应的映射关系
Set<K> keySet()	返回所有 key 的不重复集合
Collection<V> values()	返回所有 value 的可重复集合
Set<Map.Entry<K, V>> entrySet()	返回所有的 key-value 映射关系
boolean containsKey(Object key)	判断是否包含 key
boolean containsValue(Object value)	判断是否包含 value

注意：

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

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

2.4HashMap的使用案例

public class Main {
    Map<String,String> map = new HashMap<>();
        // put(key, value):插入key-value的键值对
        // 如果key不存在，会将key-value的键值对插入到map中,返回null
        map.put("奥特曼","早田进");
        map.put("奥特赛文","诸星团");
        map.put("归来的奥特曼","乡秀树");
        map.put("艾斯奥特曼","北斗星司与南夕子");
        map.put("泰罗奥特曼","东光太郎");
        String str = map.put("雷欧奥特曼","凤源");
        System.out.println(map.size());
        System.out.println(map);
}
}

我们可以看到返回的长度是6，但是顺序是乱的，因为存储的时候涉及到了哈希值，本文先不讲关于哈希值的东西。

        // put(key,value): 注意key不能为空，但是value可以为空
        // key如果为空，会抛出空指针异常
        str = map.put("戴拿奥特曼",null);
        System.out.println(map.size());

可以看到数组长度从6变成了7

        // put(key, value):
        // 如果key存在，会使用value替换原来key所对应的value，返回旧value
        str = map.put("奥特曼", "神永新二");
        System.out.println(map);

进入调试我们可以看到，此时还没有运行到代码第33行，奥特曼对应的还是早田进

当代码运行过第33行的时候，奥特曼变成了神永新二，这个时候新的val就替换了老的val。

此时：如果key存在，会使用value替换原来key所对应的value，返回旧value

        // get(key): 返回key所对应的value
        // 如果key存在，返回key所对应的value
        // 如果key不存在，返回null
        System.out.println(map.get("奥特曼"));
        System.out.println(map.get("爱迪奥特曼"));

        //GetOrDefault(): 如果key存在，返回与key所对应的value，如果key不存在，返回一个默认值
        System.out.println("===================================================");
        System.out.println(map.getOrDefault("泰罗奥特曼","111东光大郎"));
        System.out.println(map.getOrDefault("梦比优斯奥特曼","日比野未来"));

我们可以看到他只管key值是否存在，不管val放什么。

并且key不存在，就返回你输入的val值。

        //containKey(key)：检测key是否包含在Map中，时间复杂度：O(logN)
        // 按照红黑树的性质来进行查找
        // 找到返回true，否则返回false
        System.out.println(map.containsKey("奥特曼"));
        System.out.println(map.containsKey("梦比优斯奥特曼"));

        // containValue(value): 检测value是否包含在Map中，时间复杂度: O(N)
        // 找到返回true，否则返回false
        System.out.println(map.containsValue("大古"));
        System.out.println(map.containsValue("东光太郎"));

        // 打印所有的key
        // keySet是将map中的key防止在Set中返回的
        System.out.println("==========================");
        for (String s: map.keySet()        ) {
           System.out.print(s+" ");
        }
        System.out.println();

        // 打印所有的value
        // values()是将map中的value放在collect的一个集合中返回的
        for (String s:map.values()) {
            System.out.print(s+" ");
        }
        System.out.println();

        // 打印所有的键值对
        // entrySet(): 将Map中的键值对放在Set中返回了
        for (Map.Entry<String,String>entry: map.entrySet()) {
            System.out.print(entry.getKey()+"--->"+entry.getValue());
        }
        System.out.println();

感兴趣的也可试试TreeMap，看看和HashMap有什么区别

三、Set的使用

Set官方文档

Set与Map主要的不同有两点：Set是继承自Collection的接口类，Set中只存储了Key。

3.1、Set常见方法说明

方法	解释
boolean add(E e)	添加元素，但重复元素不会被添加成功
void clear()	清空集合
boolean contains(Object o)	判断 o 是否在集合中
Iterator<E> iterator()	返回迭代器
boolean remove(Object o)	删除集合中的 o
int size()	返回set中元素的个数
boolean isEmpty()	检测set是否为空，空返回true，否则返回false
Object[] toArray()	将set中的元素转换为数组返回
boolean containsAll(Collection<?> c)	集合c中的元素是否在set中全部存在，是返回true，否则返回 false
boolean addAll(Collection<? extends E> c)	将集合c中的元素添加到set中，可以达到去重的效果

注意：

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不能修改，如果要修改，先将原来的删除掉，然后再重新插入
7. Set中不能插入null的key。
8. TreeSet和HashSet的区别

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

3.2、HashSet用例测试

public static void main(String[] args) {
        Set<String> set = new HashSet<>();

        // add(key): 如果key不存在，则插入，返回ture
        // 如果key存在，返回false
        boolean KamenRider = set.add("kuga");
        set.add("Agito");
        set.add("fize");
        set.add("Kabuto");
        set.add("exaid");
        System.out.println(set.size());
        System.out.println(set);
        KamenRider = set.add("kuga");
        System.out.println(KamenRider);
    }

和map一样，不能直接new，存进去的顺序也是乱的


        // contains(key): 如果key存在，返回true，否则返回false
        System.out.println(set.contains("exaid"));
        System.out.println(set.contains("zio"));

// remove(key): key存在，删除成功返回true
        // key不存在，删除失败返回false
        // key为空，抛出空指针异常
        System.out.println("====================");
        set.remove("exaid");//删除成功
        set.remove("zio");//删除失败
        System.out.println(KamenRider);
        System.out.println(set);

// remove(key): key存在，删除成功返回true
        // key不存在，删除失败返回false
        // key为空，抛出空指针异常
        System.out.println("====================");
        set.remove("exaid");//删除成功
        System.out.println(set);

        set.remove("zio");//删除失败
        System.out.println(KamenRider);
        System.out.println(set);

        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.print(iterator.next() + " ");
        }
        System.out.println();