Map集合的学习

Map集合

概述

● Map集合称为双列集合,格式:{keyl=value1,key2=value2,key3=value3, ... },一次需要存一对数据做为一个元素.

● Map集合的每个元素“key=value”称为一个键值对/键值对对象/一个Entry对象,Map集合也被叫做“键值对集合”
● Map集合的所有键是不允许重复的,但值可以重复,键和值是一一对应的,每一个键只能找到自己对应的值

应用场景：需要存储一一对应的数据时，就可以 使用Map集合。

Map(接口)集合体系的特点

注意:Map系列集合的特点都是由键决定的,值只是一个附属品,值是不做要求的

实现类

● HashMap(由键决定特点):无序、不重复、无索引;
● LinkedHashMap(由键决定特点):由键决定的特点:有序、不重复、无索引。
● TreeMap(由键决定特点):按照大小默认升序排序、不重复、无索引。
(用的最多)

    Map<String,Integer> map = new HashMap<>(); // 一行经典代码，按照键，不重复，无索引，无序
        Map<String,Integer> map = new HashMap<>(); // 有序，不重复，无索引
        map.put("联想小新",20);
        map.put("联想小新",25);
        map.put("iPhone15",25); // 后面重复的数据会覆盖前面的数据（这里的重复是指重复的键）
        map.put("13i9",5);
        map.put(null,null);
        System.out.println(map);  // {null=null, 13i9=5, iPhone15=25, 联想小新=25}

        Map<Integer,String> map1 = new TreeMap<>(); // 排序，不重复，无索引
        map1.put(23,"java");
        map1.put(23,"MySQL");
        map1.put(19,"数据库");
        map1.put(20,"python");
        System.out.println(map1); // {19=数据库, 20=python, 23=MySQL}
    }

常用方法

Map是双列集合的祖宗,它的功能是全部双列集合都可以继承过来使用的。

// 1,public V put(K key,V value) // 添加元素

//2.public int size():获取集合的大小
// 3、public void clear():清空集合
// 4.public boolean isEmpty():判断集合是否为空,为空返回true,反之!
// 5.public V get(Object key):根据键获取对应值
// 6. public V remove(Object key):根据键删除整个元素(删除键会返回键的值):
// 7.public boolean containsKey(Object key):判断是否包含某个键,包含返回true,反之
// 8.public boolean containsValue(Object value):判断是否包含某个值。
// 9.public Set<K> keySet():获取Map集合的全部键。把集合装进一个Set集合
// 10.public Collection<V> values();获取Map集合的全部值。
I// 11，public void putAll( Map<? extends K, ? extends V> m); // 把其他map集合中的数据导入自己的集合

  Map<String,Integer> map = new HashMap<>(); // 有序，不重复，无索引
        map.put("联想小新",20);
        map.put("联想小新",25);
        map.put("iPhone15",25); // 后面重复的数据会覆盖前面的数据（这里的重复是指重复的键）
        map.put("13i9",5);
        map.put(null,null);
        System.out.println(map);  // {null=null, 13i9=5, iPhone15=25, 联想小新=25}
        //2.public int size():获取集合的大小
        System.out.println(map.size());
// 3、public void clear():清空集合
      //  map.clear();
        System.out.println(map);
// 4.public boolean isEmpty():判断集合是否为空,为空返回true,反之!
        System.out.println(map.isEmpty());
// 5.public V get(Object key):根据键获取对应值
      int v1 = map.get("联想小新");
        System.out.println(v1);
        System.out.println(map.get("iPhone15")); // 25
        System.out.println(map.get("iPhone"));  // null
// 6. public V remove(Object key):根据键删除整个元素(删除键会返回键的值):
        System.out.println(map.remove("null"));
        System.out.println(map);  // 删不掉null
// 7.public boolean containsKey(Object key):判断是否包含某个键,包含返回true,反之
        System.out.println(map.containsKey("13i9"));
// 8.public boolean containsValue(Object value):判断是否包含某个值。
        System.out.println(map.containsValue(20));
// 9.public Set<K> keySet():获取Map集合的全部键。
        Set<String> set = map.keySet();
        System.out.println(set);
// 10.public Collection<V> values();获取Map集合的全部值。
        Collection<Integer> va = map.values();
        System.out.println(va);
        // 11,把其他map集合的数据倒进自己的集合  （拓展）
        Map<String,Integer> map1 = new HashMap<>();
        map1.put("python",12);
        map1.put("css",13);
        Map<String,Integer> map2 = new HashMap<>();
        map2.put("css",17);
        map2.put("java1",99);
        map2.putAll(map1);
        System.out.println(map2);  // 拷贝一份map1送到map2
        System.out.println(map1);

遍历方式

01键找值：先获取Map集合的全部键，再通过遍历键来找值

public Set<K> keySet()获取集合的全部键

public V get(Object key)获取键对应的值

  Map<String,Double> map1 = new HashMap<>();
        map1.put("刘德华",176.2);
        map1.put("张学友",174.2);
        map1.put("郭富城",175.2);
        map1.put("林俊杰",176.3);
        System.out.println(map1); // {林俊杰=176.3, 郭富城=175.2, 张学友=174.2, 刘德华=176.2}

        // 获取Map集合的全部键
        Set<String> str = map1.keySet();
        // 2，遍历全部键，获取对应的值
        for (String s : str) {
            Double value = map1.get(s);
            System.out.println(s+"---->"+ value);

02键值对：把”键值对“看成一个整体进行遍历（难度较大）

Map提供的方法
Set<Map.Entry<K, V>> entrySet() // 获取所有“键值对”的集合
Map.Entry提供的方法
K getKey() 获取键
V getValue() // 获取值

// entries= {(林俊杰=176.3), (郭富城=175.2), (张学友=174.2), (刘德华=176.2)}
        // 调用Map集合提供的entrySet方法，把集合Map转换成键值对类型的Set集合
        Set<Map.Entry<String, Double>> entries = map1.entrySet(); // ctrl+Alt+V
            // 增强for循环
        for (Map.Entry<String, Double> entry : entries) {
            String key = entry.getKey();
            Double value = entry.getValue();
            System.out.println(key +"===>"+value);

03Lambda表达式：JDK8之后的新技术，非常简单

● 需要用到Map的如下方法
default void forEach(BiConsumer <? super K, ? super V> action)
结合lambda遍历Map集合

//        map1.forEach((k,v) ->{
//            System.out.println(k +"-->"+ v);
//        });
         // Lambda表达式底层代码是键值对的代码方法  @FunctionalInterface 函数式注解 BiConsumer 可以简化
        map1.forEach( new BiConsumer <String, Double>() {
            @Override
            public void accept(String k, Double v) {
                          System.out.println(k +"-->"+ v);
            }
        });

Random函数包前不包后，只需对他进行数学运算，就可以指定范围生成随机数 如 Random r = new Random();

r.nextInt(bound: 4)+2就生成[2,6)

HashMap

HashMap集合的底层原理

● HashMap跟HashSet的底层原理是一模一样的,都是基于哈希表实现的。
实际上:原来学的Set系列集合的底层就是基于Map实现的,只是Set集合中的元素只要键数据,不要值数据而已。
public HashSet() { map = new HashMap<>(); }

● HashMap集合是一种增删改查数据,性能都较好的集合
● 但是它是无序,不能重复,没有索引支持的(由键决定特点)
● HashMap的键依赖hashCode方法和equals方法保证键的唯一
● 如果键存储的是自定义类型的对象,可以通过重写hashCode和equals方法,这样
可以保证多个对象内容一样时,HashMap集合就能认为是重复的。

LinkedHashMap

LinkedHashMap集合的原理

● 底层数据结构依然是基于哈希表实现的,只是每个键值对元素又额外的多了一个双链表的机制记录元素顺序(保证有序)。
实际上:原来学习的LinkedHashSet集合的底层原理就是LinkedHashMap。

TreeMap

● 特点:不重复、无索引、可排序(按照键的大小默认升序排序,只能对键排序)
● 原理:TreeMap跟TreeSet集合的底层原理是一样的,都是基于红黑树实现的排序。
TreeMap集合同样也支持两种方式来指定排序规则
● 让类实现Comparable接口,重写比较规则。
● TreeMap集合有一个有参数构造器,支持创建Comparator比较器对象,以便用来指定比较规则。

补充知识：集合的嵌套

指的是集合中的元素又是一个集合

代码块

  // 定义一个Map集合存储全部的省份信息，和其对应的城市信息
        Map<String, List<String>> map = new HashMap<>();

        List<String> cities1 = new ArrayList<>();
        Collections.addAll(cities1,"南京市","扬州市","苏州市","无锡市","常州市");
        map.put("江苏省",cities1);

        List<String> cities2 = new ArrayList<>();
        Collections.addAll(cities2,"武汉市","孝感市","十堰市","宜昌市","鄂州市");
        map.put("湖北省",cities2);

        List<String> cities3 = new ArrayList<>();
        Collections.addAll(cities3,"石家庄市","唐山市","邢台市","保定市","张家口市");
        map.put("河北省",cities3);

        System.out.println(map);
        System.out.println(map.get("湖北省")); // [武汉市, 孝感市, 十堰市, 宜昌市, 鄂州市]
        List<String> cities = map.get("江苏省");
        System.out.println(cities);

        map.forEach((P,C)->{
            System.out.println(P +"--->" + C);
        });

结语

集合是重点内容，一定要多敲代码，巩固一下。