18:集合-----Map接口_map集合使用按下图输出结果对数据进行储存林志颖-CSDN博客

本文链接：https://blog.csdn.net/Hhytyq/article/details/104338988

一:Map接口概述

Collection接口，定义了单列集合的规范
每次存储一个元素单个元素。
在这里插入图片描述
1::Collection中的集合，元素是孤立存在的(理解为单身),向集合中存储元素采用一个个元素的方式存储。
2:Map中的集合,元素是成对存在的(理解为夫妻).每个元素由键与值两部分组成，通过键可以找对所对应的值。
3:Collection中集合称为单列集合，Map中集合称为双列集合。

特点:

java.util.Map<k,V>集合特点
Map集合的特点:
	1：Map集合是一个双列集合，一个元素包含两个值(一个key,一个value）
	2：Map集合中的元素，key和value的数据类型可以相同，也可以不同。
	3：Map集合中元素，key是不允许重复的，value是可以重复的。
	4：Map集合中的元素，key和value是一一对应的。

二:Map常用子类

   java.util.HashMap<k,v>集合 implements Map<k,v>接口
    HashMap集合的特点:
        1:HashMap集合底层是哈希表:查询的速度特别快。
            JDK1.8之前:数组+单向链表。
            JDK1.8之后:数组+单向链表/红黑树(链表的长度超过8),提高查询的速度。
        2:HashMap集合是一个无序的集合。存储元素和取出的顺序有可能不一致。
    java.util.LinkedHashMap<k,v>集合 extends HashMap<k,v>集合
    LinkedHashMap的特点:
        1:LinkedHashMap集合底层是哈希表+链表。(保证迭代的顺序)
        2:LinkedHashMap集合是一个有序的集合。存储元素和取出元素的顺序是一致的。

三:Map接口中的常用方法

package cn.itcast.day10.Demo10;

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

/*
    java.util.HashMap<k,v>集合 implements Map<k,v>接口
    HashMap集合的特点:
        1:HashMap集合底层是哈希表:查询的速度特别快。
            JDK1.8之前:数组+单向链表。
            JDK1.8之后:数组+单向链表/红黑树(链表的长度超过8),提高查询的速度。
        2:HashMap集合是一个无序的集合。存储元素和取出的顺序有可能不一致。
    java.util.LinkedHashMap<k,v>集合 extends HashMap<k,v>集合
    LinkedHashMap的特点:
        1:LinkedHashMap集合底层是哈希表+链表。(保证迭代的顺序)
        2:LinkedHashMap集合是一个有序的集合。存储元素和取出元素的顺序是一致的。
*/
public class Demo1Map {
    public static void main(String[] args) {
        show4();
    }
    /*
          boolean containsKey(Object key) 判断集合中是否包含指定的键。
      */
    private static void show4() {
        //创建Map集合对象。
        Map<String,Integer> map =new HashMap<>();
        map.put("赵丽颖", 168);
        map.put("杨颖", 165);
        map.put("林志颖", 178);
        boolean b1 =map.containsKey("赵丽颖");
        System.out.println("b1:"+b1);//b1:true
        boolean b2 =map.containsKey("赵颖");
        System.out.println("b2="+b2);//b2=false
    }
    /*
        public V get(Object key)根据指定的值，在Map集合中获取对应的值。
            返回值：
                key存在，返回对应的value值。
                key不存在，，返回null
    */
    private static void show3() {
        //创建Map集合对象。
        Map<String,Integer> map =new HashMap<>();
        map.put("赵丽颖", 168);
        map.put("杨颖", 165);
        map.put("林志颖", 178);
        Integer v1=map.get("杨颖");
        System.out.println("v1:"+v1);//v1:165
        Integer v2 =map.get("迪丽热巴");
        System.out.println("v2="+v2);//v2=null
    }

    /*
        public V remove(Object key);  把指定的值所对应的键值对元素，在Map集合中删除。返回该删除元素的值。
            返回值：V
                ket存在，v返回该删除的值。
                key不存在，v返回null
    */
    private static void show2(){
        //创建Map集合对象。
        Map<String,Integer> map =new HashMap<>();
        map.put("赵丽颖", 168);
        map.put("杨颖", 165);
        map.put("林志颖", 178);
        System.out.println(map);//{赵丽颖=168, 杨颖=165, 林志颖=178}
        Integer v1 =map.remove("林志颖");
        System.out.println("v1="+v1);
        System.out.println(map);//{赵丽颖=168, 杨颖=165}
        //int v2 =map.remove("林志颖");//自动拆箱  NullPointerException
        Integer v2 =map.remove("林志颖");
        System.out.println("v2="+v2);
        System.out.println(map);//{赵丽颖=168, 杨颖=165}

    }
    /*
        public V put(k key,V value);把指定的键与指定的值添加到Map集合中。
            返回值;V
                存储键值对的时候，key不重复，返回值V是null
                存储键值对的时候。key重复，会使用新的value替换Map中重复的value,返回被替换的value值。
    */
    private static void show01(){
        //创建Map集合对象，多态
        Map<String,String> map =new HashMap<>();
        String v1 = map.put("李晨", "范冰冰");
        System.out.println("v1="+v1);

        String v2 =map.put("李晨", "范冰冰");
        System.out.println("v2="+v2);
    }
}

在这里插入图片描述

四:Map集合遍历找值方式

键找值的方式:即通过元素的键，获取键所对应的值。
分析步骤:
1:获取Map中所有的键，由于键是唯一的，所以返回一个Set集合存储的所有的键，方法提示:Keyset()
2:遍历键的Set集合，得到每一个键。
3:根据键，获取键所对应的值。方法提示get(K key）

Map遍历的第一种方式:

package cn.itcast.day10.Demo10;

import com.sun.org.apache.xpath.internal.SourceTree;

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

/*
    Map集合的第一种遍历方式:通过键找值的方式
    Map集合的方法:
        Set <K> KeySet()返回此映射中包含的键的Set视图。
    完成步骤:
        1:使用Map集合中的方法KeySet()，把Map集合所有的key取出来，存储到Set集合中。
        2:遍历Set集合，获取Map集合中每一个key
        3:通过Map集合中的方法get(key），通过key找到value
*/
public class Demo02KeySet {
    public static void main(String[] args) {
        //创建Map集合对象。
        Map<String,Integer> map =new HashMap<>();
        map.put("赵丽颖", 168);
        map.put("杨颖", 165);
        map.put("林志颖", 178);

        //1:使用Map集合中的方法KeySet()，把Map集合所有的key取出来，存储到Set集合中。
        Set<String> set =map.keySet();
       // 2:遍历Set集合，获取Map集合中每一个key
        //使用迭代器遍历Set集合
        Iterator<String> iterator =set.iterator();
        while (iterator.hasNext()){
            String key=iterator.next();
            //3:通过Map集合中的方法get(key），通过key找到value
            Integer value = map.get(key);
            System.out.println(key+"="+value);
        }

        System.out.println("===============");
        //使用增强for遍历Set集合
        for (String key:map.keySet()){
            //3:通过Map集合中的方法get(key），通过key找到value
            Integer value =map.get(key);
            System.out.println(key+"="+value);
        }
    }
}

在这里插入图片描述

五:Entry键值对对象

我们已经知道，Map中存放的两种对象，一种称为key(键),一种称为value(值)。它们在Map中是一种对应关系，这一对对象又称之为Map中的一个Entry(项),Entry将键值对的对应关系封装成了对象，即键值对对象，这样我们在遍历Map集合时，就可以从每一个键值对(Entry)对象获取对应的键与对应的值。
Entry表示了一对键和值，那么也同样提供了获取对应键和对应值的方法:

public K getKey();获取Entry对象的键
public V getValue();获取Entry对象的值。

在Map集合也提供了获取所有Entry对象的方法:

public Set<Map.Entry<K,V> entrySet();获取到Map集合所有的键值对对象的集合(Set集合).

在这里插入图片描述
Map集合遍历键值对的第二种方式：

package cn.itcast.day10.Demo10;

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

/*
    Map集合遍历的第二种方式:使用Entry对象遍历。
    Map集合中的方法:
        Set<Map.Entry<K,V> entrySet() 返回此映射中包含的映射关系的Set视图
    实现步骤:
        1:使用Map集合中的方法entrySet()，把Map集合多个Entry对象取出来，存储到一个Set集合中。
        2:遍历Set集合，获取每一个Entry对象。
        3:使用Entry对象中的方法getKey()和getValue获取key和value

* */
public class Demo03EntrySet {
    public static void main(String[] args) {
        //创建Map集合对象。
        Map<String,Integer> map =new HashMap<>();
        map.put("赵丽颖", 168);
        map.put("杨颖", 165);
        map.put("林志颖", 178);

        //1.使用Map集合中的方法entrySet(),把Map集合中多个Entry对象取出来，存储到Set集合中。
        Set<Map.Entry<String,Integer>> set =map.entrySet();

        //2:遍历Set集合，获取每一个Entry对象。
        //使用迭代器遍历Set集合
        Iterator<Map.Entry<String,Integer>> it =set.iterator();
        while (it.hasNext()){
            Map.Entry<String,Integer> entry =it.next();
            //3:使用Entry对象中的方法getKey()和getValue获取key和value
            String key =entry.getKey();
            Integer value =entry.getValue();
            System.out.println(key+"="+value);
        }
        System.out.println("=======================");
        for (Map.Entry<String,Integer> entry:set){
            //3:使用Entry对象中的方法getKey()和getValue获取key和value
            String key =entry.getKey();
            Integer value =entry.getValue();
            System.out.println(key+"="+value);
        }

    }
}

在这里插入图片描述

六:HashMap存储自定义类型键值

package cn.itcast.day10.Demo10;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/*
    HashMap存储自定义类型键值
    Map集合保证key是唯一的:
        作为key的元素，必须重写hashCode方法和equals方法，以保证key唯一。
*/
public class Demo01HashMapSavePerson {
    public static void main(String[] args) {
        show2();
    }
    /*
    HashMap存储自定义类型键值
        key：String类型
            String类重写hashCode方法和equals方法，可以保证key唯一
        value:Person类型
            value可以重复
    */
    private static void show2() {
        //创建HashMap集合
        HashMap<Person,String> map = new HashMap<>();
        //往集合中添加元素。
        map.put(new Person("女王",18), "英国");
        map.put(new Person("秦始皇",18), "秦国");
        map.put(new Person("普京",30), "俄罗斯");
        map.put(new Person("女王",18), "毛里求斯");
        //使用entrySet和增强for循环Map集合
        Set<Map.Entry<Person,String>> set =map.entrySet();
        for (Map.Entry<Person,String> entry:set){
            Person key =entry.getKey();
            String value =entry.getValue();
            System.out.println(key+"--->"+value);
        }
    }

    /*
        HashMap存储自定义类型键值
        key：String类型
            String类重写hashCode方法和equals方法，可以保证key唯一
        value:Person类型
            value可以重复(同名同年龄的人视为同一个人)
    */
    private static void show1(){
        //创建HashMap集合
        HashMap<String,Person> map =new HashMap<>();
        //往集合中添加元素。
        map.put("北京", new Person("张三",18));
        map.put("上海",new Person("李四",19) );
        map.put("广州", new Person("王五",20));
        map.put("北京", new Person("赵六",18));

        //使用keySet加强for遍历Map集合
        Set<String> set =map.keySet();
        for(String key:set){
            Person value=map.get(key);
            System.out.println(key+"="+value);
        }
    }
}

在这里插入图片描述

七:LinkedHashMap

我们知道HashMap保证成对元素唯一，并且查询速度很快，可是成对元素存放进去是没有顺序的，那么我们要保证有序，还要速度快怎么办？
在HashMap下面有一个子类LinkedHashMap，它是链表和哈希表组合的一个数据存储结构。

package cn.itcast.day10.Demo10;

import java.util.HashMap;
import java.util.LinkedHashMap;

/*
    java.util.LinkedHashMap<K,V> extends HashMap<K,V>
    Map接口的的哈希表和链接列表实现，具有可预知顺序。
    底层原理：
        哈希表+链表(记录元素的顺序)
*/
public class Demo01LinkedHashMap {
    public static void main(String[] args) {
        HashMap<String,String> map =new HashMap<>();
        map.put("a", "a");
        map.put("c", "c");
        map.put("b", "b");
        map.put("a", "d");
        System.out.println(map);//key不允许重复，无序{a=d, c=c, d=d}

        LinkedHashMap<String,String> linked =new LinkedHashMap<>();
        linked.put("a", "a");
        linked.put("c", "c");
        linked.put("b", "b");
        linked.put("a", "d");
        System.out.println(linked);//key不允许重复，有序{a=d, c=c, b=b}
    }
}

在这里插入图片描述

八:Hashtable<K,V>

package cn.itcast.day10.Demo10;

import java.util.HashMap;
import java.util.Hashtable;

/*
    java.util.Hahtable<K,V>集合 implements Map<K,V>接口
    Hashtable：底层也是哈希表，是一个线程安全的集合，是单线程集合，速度慢。
    HashMap：底层是一个哈希表，是一个线程不安全的集合，是多线程的集合，速度快。
    HashMap集合:可以存储null值，null键
    Hashtable集合，不能存储null值，null键

    Hashtable和Vector集合一样，在jdk1.2版主之后被更加先进的集合（HashMap,ArrayList）取代了。
    Hashtable的子类Properties依然经常使用。
*/
public class Demo02Hashtable {
    public static void main(String[] args) {
        HashMap<String,String> map =new HashMap<>();
        map.put(null, "a");
        map.put("b", null);
        map.put(null, null);
        System.out.println(map);//{null=null, b=null}
        Hashtable<String,String> table =new Hashtable<>();
       // table.put(null, "a");//NullPointerException
        //table.put("b", null);//NullPointerException
        //table.put(null, null)//NullPointerException
    }
}

在这里插入图片描述

九:Map集合练习

需求:
计算一个字符串中每个字符出现的次数。

分析:
1:获取一个字符串对象。
2:创建一个Map集合，键代表字符，值代表次数。
3:遍历字符串所得到每个字符。
4:判断Map中是否有该键
5:如果没有，第一次出现，存储次数为1；如果有，则说明出现过，获取到对应的进行++，再次存储，
6:打印最终结果。

package cn.itcast.day10.Demo10;

import java.util.HashMap;
import java.util.Scanner;

/*
    练习
        计算一个字符串中每个字符出现的次数。
    分析:
        1:使用Scanner获取用户输入的字符串。
        2:创建Map集合，key是字符串中字符，value是字符的个数。
        3:遍历字符串，获取每一个字符。
        4:使用获取到的字符，去Map集合判断key是否存在。
            key存在:
                通过字符(key,获取value（字符个数).
                value++
                put(key,value)把新的value存储到Map集合中
            key不存在:
                put(key,1)
         5：遍历Map集合，输出结果。
*/
public class Demo03MapTest {
    public static void main(String[] args) {
        //1:使用Scanner获取用户输入的字符串。
        Scanner scc =new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String str = scc.next();
        //2:创建Map集合，key是字符串中字符，value是字符的个数。
        HashMap<Character,Integer> map =new HashMap<>();
        //3:遍历字符串，获取每一个字符。
        for(char c:str.toCharArray()){
            //4:使用获取到的字符，去Map集合判断key是否存在。
            if(map.containsKey(c)){
                //key存在
                Integer value =map.get(c);
                value++;
                map.put(c,value );
            }else {
                // key不存在:
                map.put(c, 1);
            }
        }
        //5：遍历Map集合，输出结果。
        for (Character key:map.keySet()){
            Integer value=map.get(key);
            System.out.println(key+"="+value);
        }
    }
}

在这里插入图片描述

十:JDK9对集合添加的优化

Java9,添加了几种集合工厂方法，更加方便创建少量元素的集合，Map实例。新的List，Set，Map的静态工厂方法可以更加方便创建集合的不可变实例。

package cn.itcast.day10.Demo10;

import com.sun.org.apache.xpath.internal.SourceTree;

import java.util.List;
import java.util.Map;
import java.util.Set;

/*
    JDK9的新特性:
        List接口，Map接口里面增加了一个静态方法of，可以一次性给集合添加多个
        static <E> List<E> of(E...elements)
        使用前提:
            当集合中存储的元素个数已经确定了，不在改变使用。
        注意：
            1:of方法只适用于List接口，Set接口，Map接口，不适用于接口的实现类。
            2:of方法的返回值是一个不能改变的集合，集合不能再使用add,put方法添加元素，如果再使用，会抛出异常。
            3:Set接口和Map接口在调用of方法的时候，不能有重复的元素，否则会抛出异常。
*/
public class Demo01JDK9 {
    public static void main(String[] args) {
        List<String> list =list.of("a","b","a","c","d");
        System.out.println(list);//{a,b,a,c,d,]
        list.add("w");//UnsupportedOperationException：不支持操作异常。
        Set<String> set =set.of("a","b","c","d");//IllegalArgumentException：非法参数异常，有重复的元素。

        Map<String,Integer> map =Map.of("张三",18,"李四",19,"王五",20,"张三",19);IllegalArgumentException：非法参数异常，有重复的元素。
        System.out.println(map);
        map.put("赵四", 30);UnsupportedOperationException：不支持操作异常。
    }
}