7. Map接口及其实现类

文章目录

  • Map接口及其实现类
    • 1. Map接口介绍
    • 2. Map接口中常用方法
      • 2.1 元素的添加 、 删除、修改操作
      • 2.2 元素查询的操作
      • 2.3 遍历Map的三种方式☆
    • 3. Map接口的实现类
      • 3.1 HashMap集合
          • HashMap源码中的重要常量☆
          • HashMap的储存结构☆☆
            • JDK7
            • JDK8
            • 小结
          • HashMap存储自定义类型键值
            • Student.java
            • 测试类HashMapTest
          • LinkedHashMap集合☆
            • LinkedHashMap的静态内部类Entry
      • 3.2 TreeMap集合
      • 3.3 HashTable集合
          • Properties类

Map接口及其实现类

1. Map接口介绍

  1. 现实生活中,我们常会看到这样的一种集合:IP地址与主机名,身份证号与个人,系统用户名与系统用户对象等,这种一一对应的关系,就叫做映射。Java提供了专门的集合类用来存放这种对象关系的对象,即 java.util.Map 接口。
  2. Map与Collection并列存在。用于保存具有映射关系的数据:key-value。
  3. Map 中的 key 和 value 都可以是任何引用类型的数据
  4. Map 中的 key 用Set来存放, 不允许重复,即同一个 Map 对象所对应的类,须重写hashCode()和equals()方法
    • 常用String类作为Map的“键”。
    • 7. Map接口及其实现类_第1张图片
  5. key 和 value 之间存在单向一对一关系,即通过指定的 key 总能找到唯一的、确定的 value。
  6. Map接口中的集合都有两个泛型变量,在使用时,要为两个泛型变量赋予数据类型。两个泛型变量的数据类型可以相同,也可以不同。
  7. Map接口的常用实现类:HashMapTreeMapLinkedHashMapProperties其中HashMap是 Map 接口使用频率最高的实现类

7. Map接口及其实现类_第2张图片

2. Map接口中常用方法

2.1 元素的添加 、 删除、修改操作

  1. Object put(Object key,Object value):将指定key-value添加到(或修改)当前map对象中。

  2. void putAll(Map m):将m中的所有key-value对存放到当前map中。

  3. Object remove(Object key):移除指定key的key-value对,并返回value。

  4. void clear():清空当前map中的所有数据。

2.2 元素查询的操作

  1. Object get(Object key):获取指定key对应的value。

  2. boolean containsKey(Object key):是否包含指定的key。

  3. boolean containsValue(Object value):是否包含指定的value。

  4. int size():返回map中key-value对的个数。

  5. boolean isEmpty():判断当前map是否为空。

  6. boolean equals(Object obj):判断当前mp和参数对象obj是否相等。

2.3 遍历Map的三种方式☆

public Set keySet() : 获取Map集合中所有的键,存储到Set集合中。

  • 获取Map中所有的键,由于键是唯一的,所以返回一个Set集合存储所有的键。方法提示: keyset()

  • 遍历键的Set集合,得到每一个键。

  • 根据键,获取键所对应的值。方法提示: get(K key)

Collection values():返回所有value构成的Collection集合

public Set> entrySet() : 获取到Map集合中所有的键值对对象的集合(Set集合)。

  • 我们已经知道, Map 中存放的是两种对象,一种称为key(键),一种称为value(值),它们在在 Map 中是一一对应关系,这一对对象又称做 Map 中的一个 Entry(项) 。 Entry 将键值对的对应关系封装成了对象。即键值对对象,这样我们在遍历 Map 集合时,就可以从每一个键值对( Entry )对象中获取对应的键与对应的值。既然Entry表示了一对键和值,那么也同样提供了获取对应键和对应值得方法:
  • Map集合不能直接使用迭代器或者foreach进行遍历。但是转成Set之后就可以使用了。
    • public K getKey() :获取Entry对象中的键。

    • public V getValue() :获取Entry对象中的值。

/**
 * @Date 2020/11/13 17:29
 * @Version 10.21
 * @Author DuanChaojie
 */
public class TestMap {
    public static void main(String[] args) {
        // 集合初始化时,指定集合初始值大小
        // 说明:HashMap使用如下构造方法进行初始化,如果暂时无法确定集合大小,那么指定默认值(16)即可
        Map map = new HashMap();
        //map.put(..,..)省略
        
        System.out.println("map的所有key:");
        // HashSet
        Set keys = map.keySet();
        for (Object key : keys) {
            System.out.println(key + "->" + map.get(key));
        }
        
        System.out.println("map的所有的value:");
        Collection values = map.values();
        Iterator iter = values.iterator();
        while (iter.hasNext()) {
            System.out.println(iter.next());
        }
        
        System.out.println("map所有的映射关系:");
        // 映射关系的类型是Map.Entry类型,它是Map接口的内部接口
        Set mappings = map.entrySet();
        for (Object mapping : mappings) {
            Map.Entry entry = (Map.Entry) mapping;
            System.out.println("key是:" + entry.getKey() + ",value是:" + entry.getValue());
        }
    }
}

3. Map接口的实现类

3.1 HashMap集合

  1. HashMap是 Map 接口 使用频率最高的实现类。
  2. 允许使用null键和null值,与HashSet一样,不保证映射的顺序。
  3. 所有的key构成的集合是Set:无序的、不可重复的。所以,key所在的类要重写:equals()和hashCode()。
  4. 所有的value构成的集合是Collection:无序的、可以重复的。所以,value所在的类要重写:equals()。
  5. 一个key-value构成一个entry
  6. 所有的entry构成的集合是Set:无序的、不可重复的
  7. HashMap 判断两个 key 相等的标准是:两个 key 通过 equals() 方法返回 true,hashCode 值也相等。
    • 因为key不允许有重复。
  8. HashMap 判断两个 value 相等的标准是:两个 value 通过 equals() 方法返回 true。
HashMap源码中的重要常量☆
  1. DEFAULT_INITIAL_CAPACITY : HashMap的默认容量,16

  2. MAXIMUM_CAPACITY : HashMap的最大支持容量,2^30

  3. DEFAULT_LOAD_FACTOR :HashMap的默认加载因子0.75

  4. TREEIFY_THRESHOLD :Bucket中链表长度大于该默认值8,转化为红黑树

  5. UNTREEIFY_THRESHOLD :Bucket中红黑树存储的Node小于该默认值6,转化为链表。

  6. MIN_TREEIFY_CAPACITY :桶中的Node被树化时最小的hash表容量。(当桶中Node的数量大到需要变红黑树时,若hash表容量小于MIN_TREEIFY_CAPACITY时,此时应执行resize扩容操作这个MIN_TREEIFY_CAPACITY的值(默认为64)至少是TREEIFY_THRESHOLD的4倍。)

  7. table :存储元素的数组,总是2的n次幂

  8. entrySet: 存储具体元素的集

  9. size :HashMap中存储的键值对的数量

  10. modCount :HashMap扩容和结构改变的次数。

  11. threshold :扩容的临界值(吞吐临界值)12=容量*填充因子

  12. loadFactor: 填充比(负载因子)。

    1. 负载因子值的大小,对HashMap有什么影响?

      • 负载因子的大小决定了HashMap的数据密度。

      • 负载因子越大密度越大,发生碰撞的几率越高,数组中的链表越容易长,造成查询或插入时的比较次数增多,性能会下降。

      • 负载因子越小,就越容易触发扩容,数据密度也越小,意味着发生碰撞的几率越小,数组中的链表也就越短,查询和插入时比较的次数也越小,性能会更高。但是会浪费一定的内容空间。而且经常扩容也会影响性能,建议初始化预设大一点的空间。

      • 按照其他语言的参考及研究经验,会考虑将负载因子设置为0.7~0.75,此时平均检索长度接近于常数。

HashMap的储存结构☆☆
  1. JDK 7及以前版本:HashMap是数组+链表结构(即为链地址法)。
  2. JDK 8版本发布以后:HashMap是数组+链表+红黑树实现。
JDK7

7. Map接口及其实现类_第3张图片

  1. HashMap的内部存储结构其实是 数组和链表的结合。当实例化一个HashMap时,系统会创建一个长度为Capacity的Entry数组,这个长度在哈希表中被称为容量(Capacity),在这个数组中可以存放元素的位置我们称之为“桶”(bucket),每个bucket都有自己的索引,系统可以根据索引快速的查找bucket中的元素。

  2. 每个bucket中存储一个元素,即一个Entry对象,但每一个Entry对象可以带一个引用变量,用于指向下一个元素,因此,在一个桶中,就有可能生成一个Entry链。而且新添加的元素作为链表的head。

  3. HashMap静态内部类Entry

     static class Entry<K,V> implements Map.Entry<K,V> {
            final K key;
            V value;
            final int hash;
            Entry<K,V> next;
         	// ....
     }
    
  4. 添加元素的过程:

    1. 向HashMap中添加entry1(key,value),需要首先计算entry1中key的哈希值(根据key所在类的hashCode()计算得到),此哈希值经过处理以后,得到在底层Entry[]数组中要存储的位置i
    2. 如果位置i上没有元素,则entry1直接添加成功。如果位置i上已经存在entry2(或还有链表存在的entry3,entry4),则需要通过循环的方法,依次比较entry1中key和其他的entry。如果彼此hash值不同,则直接添加成功。
    3. 如果hash值不同,继续比较二者是否equals。如果返回值为true,则使用entry1的value
      去替换equals为true的entry的value。
    4. 如果遍历一遍以后,发现所有的equals返回都为false,则entry1仍可添加成功。entry1指向原有的entry元素。
  5. HashMap 的扩容:

    1. 当HashMap中的元素越来越多的时候,hash冲突的几率也就越来越高,因为数组的长度是固定的。所以为了提高查询的效率,就要对HashMap的数组进行扩容,而在HashMap数组扩容之后,最消耗性能的点就出现了:原数组中的数据必须重新计算其在新数组中的位置,并放进去,这就是resize。
    2. 那么HashMap 什么时候进行扩容呢 ?
      1. 当HashMap中的元素个数超过数组大小(数组总大小length,不是数组中个数size)loadFactor 时 , 就 会 进 行 数 组 扩 容 , loadFactor 的 默 认 值(DEFAULT_LOAD_FACTOR)为0.75,这是一个折中的取值。
      2. 也就是说,默认情况下,数组大小(DEFAULT_INITIAL_CAPACITY)为16,那么当HashMap中元素个数超过16*0.75=12(这个值就是代码中的threshold值,也叫做临界值)的时候,就把数组的大小扩展为 2*16=32,即扩大一倍,然后重新计算每个元素在数组中的位置,而这是一个非常消耗性能的操作,所以如果我们已经预知HashMap中元素的个数,那么预设元素的个数能够有效的提高HashMap的性能。
JDK8

7. Map接口及其实现类_第4张图片

  1. HashMap的内部存储结构其实是 数组+ 链表+ 树 的结合。当实例化一个HashMap时,会初始化initialCapacity和loadFactor,在put第一对映射关系时,系统会创建一个长度为initialCapacity的Node数组,这个长度在哈希表中被称为容量(Capacity),在这个数组中可以存放元素的位置我们称之为
    “桶”(bucket),每个bucket都有自己的索引,系统可以根据索引快速的查找bucket中的元素。

  2. 每个bucket中存储一个元素,即一个Node对象,但每一个Node对象可以带一个引用变量next,用于指向下一个元素,因此,在一个桶中,就有可能生成一个Node链。也可能是一个一个TreeNode对象,每一个TreeNode对象可以有两个叶子结点left和right,因此,在一个桶中,就有可能生成一个TreeNode树。而新添加的元素作为链表的last,或树的叶子结点。

  3. HashMap的静态内部类Node

        static class Node<K,V> implements Map.Entry<K,V> {
            final int hash;
            final K key;
            V value;
            Node<K,V> next;
    
            Node(int hash, K key, V value, Node<K,V> next) {
                this.hash = hash;
                this.key = key;
                this.value = value;
                this.next = next;
            }
    
            public final K getKey()        { return key; }
            public final V getValue()      { return value; }
            public final String toString() { return key + "=" + value; }
    
            public final int hashCode() {
                return Objects.hashCode(key) ^ Objects.hashCode(value);
            }
    
            public final V setValue(V newValue) {
                V oldValue = value;
                value = newValue;
                return oldValue;
            }
    
            public final boolean equals(Object o) {
                if (o == this)
                    return true;
                if (o instanceof Map.Entry) {
                    Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                    if (Objects.equals(key, e.getKey()) &&
                        Objects.equals(value, e.getValue()))
                        return true;
                }
                return false;
            }
        }
    
  4. 那么HashMap 什么时候进行扩容和树形化呢 ?

    1. 当HashMap中的元素个数超过数组大小(数组总大小length,不是数组中个数size)loadFactor 时 , 就会 进 行 数 组 扩 容 , loadFactor 的 默 认 值(DEFAULT_LOAD_FACTOR)为0.75,这是一个折中的取值。也就是说,默认情况下,数组大小(DEFAULT_INITIAL_CAPACITY)为16,那么当HashMap中元素个数超过16*0.75=12(这个值就是代码中的threshold值,也叫做临界值)的时候,就把数组的大小扩展为 2*16=32,即扩大一倍,然后重新计算每个元素在数组中的位置,而这是一个非常消耗性能的操作,所以如果我们已经预知HashMap中元素的个数,那么预设元素的个数能够有效的提高HashMap的性能。
    2. 当HashMap中的其中一个链的对象个数如果达到了8个,此时如果capacity没有达到64,那么HashMap会先扩容解决,如果已经达到了64,那么这个链会变成树,结点类型由Node变成TreeNode类型。当然,如果当映射关系被移除后,下次resize方法时判断树的结点个数低于6个,也会把树再转为链表。
      • 如果不理解这段,可以看一下HashMap源码中的重要常量MIN_TREEIFY_CAPACITY
  5. 关于映射关系的key 是否可以修改 ?

    • 答案是:不要修改!

    • 映射关系存储到HashMap中会存储key的hash值,这样就不用在每次查找时重新计算每一个Entry或Node(TreeNode)的hash值了,因此如果已经put到Map中的映射关系,再修改key的属性,而这个属性又参与hashcode值的计算,那么会导致匹配不上。

小结

JDK1.8相较于之前的变化:

  1. HashMap map = new HashMap();//默认情况下,先不创建长度为16的数组。
  2. 当首次调用map.put()时,再创建长度为16的数组。
  3. 数组为Node类型,在jdk7中称为Entry类型。
  4. 形成链表结构时,新添加的key-value对在链表的尾部(七上八下)。
  5. 当数组指定索引位置的链表长度>8时,且map中的数组的长度> 64时,此索引位置上的所有key-value对使用红黑树进行存储。
HashMap存储自定义类型键值
  1. 每位学生(姓名,年龄)都有自己的家庭住址。那么,既然有对应关系,则将学生对象和家庭住址存储到map集合中。学生作为键, 家庭住址作为值。
  2. 注意,学生姓名相同并且年龄相同视为同一名学生。
Student.java
public class Student {
    private String name;
    private int age;
    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.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;
    }
    @Override
    public boolean equals(Object o) {
        if (this == o)
            return true;
        if (o == null || getClass() != o.getClass())
            return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}
测试类HashMapTest
public class HashMapTest {
    
    public static void main(String[] args) {
        //1,创建Hashmap集合对象。
        Map<Student,String>map = new HashMap<Student,String>();
        
        //2,添加元素。
        map.put(newStudent("lisi",28), "上海");
        map.put(newStudent("wangwu",22), "北京");
        map.put(newStudent("zhaoliu",24), "成都");
        map.put(newStudent("zhouqi",25),"广州");
        map.put(newStudent("wangwu",22), "南京");
        
        //3,取出元素。键找值方式
        Set<Student>keySet = map.keySet();
        for(Student key: keySet){
            Stringvalue = map.get(key);
            System.out.println(key.toString()+"....."+value);
        }
    }
}
  1. 当给HashMap中存放自定义对象时,如果自定义对象作为key存在,这时要保证对象唯一,必须复写对象的hashCodeequals方法(如果忘记,请回顾HashSet存放自定义对象)。

  2. 如果要保证map中存放的key和取出的顺序一致,可以使用 java.util.LinkedHashMap 集合来存放。

LinkedHashMap集合☆
  1. 我们知道HashMap保证成对元素唯一,并且查询速度很快,可是成对元素存放进去是没有顺序的,那么我们要保证有序,还要速度快怎么办呢?
  2. LinkedHashMap 是 HashMap 的子类,它是链表和哈希表组合的一个数据存储结构。
public class LinkedHashMapDemo {
    public static void main(String[] args) {
        LinkedHashMap<String, String> map = new LinkedHashMap<String, String>();
        map.put("邓超", "孙俪");
        map.put("李晨", "范冰冰");
        map.put("刘德华", "朱丽倩");
        Set<Entry<String, String>> entrySet = map.entrySet();
        
        for (Entry<String, String> entry : entrySet) {
            System.out.println(entry.getKey() + " " + entry.getValue());
        }
    }
}

结果:

邓超 孙俪
李晨 范冰冰
刘德华 朱丽倩
LinkedHashMap的静态内部类Entry
static class Entry<K,V> extends HashMap.Node<K,V> {
    Entry<K,V> before, after;
    Entry(int hash, K key, V value, Node<K,V> next) {
        super(hash, key, value, next);
    }
}

3.2 TreeMap集合

  1. TreeMap存储 Key-Value 对时,需要根据 key-value 对进行排序。TreeMap 可以保证所有的 Key-Value 对处于有序状态。
  2. TreeSet底层使用 红黑树 结构存储数据。
  3. TreeMap 的 Key 的排序:
    • 自然排序:TreeMap 的所有的 Key 必须实现 Comparable 接口,而且所有的 Key 应该是同一个类的对象,否则将会抛出 ClasssCastException。
    • 定制排序:创建 TreeMap 时,传入一个 Comparator 对象,该对象负责对TreeMap 中的所有 key 进行排序。此时不需要 Map 的 Key 实现Comparable 接口
  4. TreeMap判断两个key 相等的标准:两个key通过compareTo()方法或者compare()方法返回0。

3.3 HashTable集合

  1. HashTable是个古老的 Map 实现类,JDK1.0就提供了。不同于HashMap,Hashtable是线程安全的。
  2. Hashtable实现原理和HashMap相同,功能相同。底层都使用哈希表结构,查询速度快,很多情况下可以互用。
  3. 与HashMap不同,Hashtable 不允许使用 null 作为 key 和 value
  4. 与HashMap一样,Hashtable 也不能保证其中 Key-Value 对的顺序
  5. Hashtable判断两个key相等、两个value相等的标准,与HashMap一致。
Properties类
  1. Properties 类是 Hashtable 的子类,该对象用于处理属性文件由于属性文件里的 key、value 都是字符串类型,所以 Properties 里的 key和 value 都是字符串类型

  2. 存取数据时,建议使用setProperty(String key,String value)方法getProperty(String key)方法。

  3. Properties pros = new Properties();
    pros.load(new FileInputStream("jdbc.properties"));
    String user = pros.getProperty("user");
    System.out.println(user);
    

你可能感兴趣的:(#,JavaSE-集合,Map,HashMap,Entry,Node,TreeMap)