欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识！
您现在的位置是： 首页  >  IT编程

荐 Map集合【集合特点、常用方法、集合遍历方式】以及其子类HashMap、LinkedHashMap集合的相关用法

程序员文章站 2022-06-21 13:36:52
第一章 Map集合1.1 概述Collection中的集合，元素是孤立存在的，向集合中存储元素采用一个个元素的方式存储。Map中的集合，元素是成对存在的。每个元素由键与值两部分组成，通过键可以找对所对应的值。Collection中的集合称为单列集合，Map中的集合称为双列集合。需要注意的是，Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。（1）、Map集合的特点：Map集合是一个双列集合，一个元素包含两个值（一个key，一个value）。Map集合中的元素，key和v...

第一章 Map集合

1.1 概述

  • Collection中的集合，元素是孤立存在的，向集合中存储元素采用一个个元素的方式存储。
  • Map中的集合，元素是成对存在的。每个元素由键与值两部分组成，通过键可以找对所对应的值。
  • Collection中的集合称为单列集合，Map中的集合称为双列集合。
  • 需要注意的是，Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。

（1）、Map集合的特点：

  1. Map集合是一个双列集合，一个元素包含两个值（一个key，一个value）。
  2. Map集合中的元素，key和value的数据类型可以相同，也可以不同。
  3. Map集合中的元素，key是不允许重复的，value是可以重复的。
  4. Map集合中的元素，key和value是 一 一 对应的。

1.2 Map常用子类

通过查看Map接口描述，看到Map有多个子类，这里我们主要讲解常用的HashMap集合、LinkedHashMap集合。

  • HashMap<K,V>：存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。
  • LinkedHashMap<K,V>：HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

tips：Map接口中的集合都有两个泛型变量<K,V>,在使用时，要为两个泛型变量赋予数据类型。两个泛型变量<K,V>的数据类型可以相同，也可以不同。

（1）、HashMap集合的特点：

  1. HashMap集合底层是哈希表，查询的速度特别的快。JDK1.8之前：数组+单向链表，JDK1.8之后：数组+单向链表/红黑树（链表的长度超过8）；提高查询的速度。
  2. HashMap集合是一个无序的集合，存储元素和取出元素的顺序有可能不一样。

（2）、LinkedHashMap集合特点：

  1. LinkedHashMap集合底层是哈希表+链表（保证迭代的顺序）。
  2. LinkedHashMap集合是一个有序的集合，存储元素和取出元素的顺序是一致的。

1.3 Map接口中的常用方法

Map接口中定义了很多方法，常用的如下：

  • public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。
  • 返回值：
    ①、存储键值对的时候，key不重复，返回值value是null.
    ②、存储键值对的时候，key重复，会使用新的value替换map中重复的value，返回被替换的value值
import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        show01();
    }
    private static void show01(){
        //创建Map集合对象，多态
        Map<String,String> map = new HashMap<>();

        String v1 = map.put("工藤新一", "毛利兰1");
        System.out.println("v1:"+v1);//没有重复的返回null；v1:null
        String v2 = map.put("工藤新一", "毛利兰2");
        System.out.println("v2:"+v2);//重复时，返回的是被替换的；v2:毛利兰1
        System.out.println(map);//{工藤新一=毛利兰2}

        map.put("冷锋","龙小云");
        map.put("杨过","小龙女");
        map.put("尹志平","小龙女");
        System.out.println(map);//{杨过=小龙女, 尹志平=小龙女, 工藤新一=毛利兰2, 冷锋=龙小云}
    }
}
  • public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
  • 返回值：
    ①、key存在,value返回被删除的值。
    ②、key不存在,value返回null。
import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        show02();
    }

    private static void show02(){
        //创建Map集合对象，多态
        Map<String,Integer> map = new HashMap<>();
        map.put("路飞",168);
        map.put("索隆",165);
        map.put("娜美",178);
        System.out.println(map);//{娜美=178, 索隆=165, 路飞=168}

        Integer v1 = map.remove("娜美");
        System.out.println("v1:"+v1);//v1:178

        System.out.println(map);//{索隆=165, 路飞=168}

        //Int v2 = map.remove("乌索普");使用int类型，自动拆箱，报NullPointerException
        Integer v2 = map.remove("乌索普");//null可以赋值给包装类Integer,但是不能赋值给int类型
        System.out.println("v2:"+v2);//v2:null

        System.out.println(map);//{索隆=165, 路飞=168}
    }
}
  • public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
  • 返回值：
    ①、key存在,value返回对应的值。
    ②、key不存在,value返回null。
import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        show03();
    }

    private static void show03(){
        //创建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
    }
}
  • boolean containsKey(Object key) 判断集合中是否包含指定的键。包含返回true，不包含返回false 
import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        show04();
    }
    private static void show04(){
        //创建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 Set<K> keySet(): 获取Map集合中所有的键，存储到Set集合中。
  • public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。

Map接口的方法演示

public class MapDemo {
    public static void main(String[] args) {
        //创建 map对象
        HashMap<String, String>  map = new HashMap<String, String>();

        //添加元素到集合
        map.put("黄晓明", "杨颖");
        map.put("文章", "马伊琍");
        map.put("邓超", "孙俪");
        System.out.println(map);

        //String remove(String key)
        System.out.println(map.remove("邓超"));
        System.out.println(map);

        // 想要查看 黄晓明的媳妇 是谁
        System.out.println(map.get("黄晓明"));
        System.out.println(map.get("邓超"));    
    }
}

tips:

使用put方法时，若指定的键(key)在集合中没有，则没有这个键对应的值，返回null，并把指定的键值添加到集合中；

若指定的键(key)在集合中存在，则返回值为集合中键对应的值（该值为替换前的值），并把指定键所对应的值，替换成指定的新值。

1.4 Map集合遍历键找值方式

（1）、Map集合的第一种遍历方式：通过键找值得方式

  • Map集合中的方法：Set< K > keySet():返回此映射中包含的键的Set视图。
  • 实现步骤：
    ①、使用Map集合中的方法keySet(),把Map集合所有的key取出来，存储到一个Set集合中
    ②、遍历Set集合,获取Map集合中的每一个key
    ③、通过Map集合中的方法get(key),通过key找到value
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Main {
    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> it = set.iterator();
        while (it.hasNext()){
            String key = it.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 : set) {
            //3.通过Map集合中的方法get(key),通过key找到value
            Integer value = map.get(key);
            System.out.println(key+"="+value);
        }
    }
}
运算结果：
林志玲=178
赵丽颖=168
杨颖=165
------------
林志玲=178
赵丽颖=168
杨颖=165

遍历图解：
荐 Map集合【集合特点、常用方法、集合遍历方式】以及其子类HashMap、LinkedHashMap集合的相关用法

（2）、Map集合遍历的第二种方式：使用Entry对象遍历

我们已经知道，Map中存放的是两种对象，一种称为key(键)，一种称为value(值)，它们在在Map中是一一对应关系，这一对对象又称做Map中的一个Entry(项)。Entry将键值对的对应关系封装成了对象。即键值对对象，这样我们在遍历Map集合时，就可以从每一个键值对（Entry）对象中获取对应的键与对应的值。
荐 Map集合【集合特点、常用方法、集合遍历方式】以及其子类HashMap、LinkedHashMap集合的相关用法
既然Entry表示了一对键和值，那么也同样提供了获取对应键和对应值得方法：

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

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

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

遍历方法：

键值对方式：即通过集合中每个键值对(Entry)对象，获取键值对(Entry)对象中的键与值。

  • Map集合遍历的第二种方式：使用Entry对象遍历
  • Map集合中的方法：Set<Map.Entry<K,V>> entrySet():返回此映射中包含的映射关系的Set视图。
  • 实现步骤：
    ①、使用Map集合中的方法entrySet(),把Map集合中多个Entry对象取出来，存储到一个Set集合中。
    ②、遍历Set集合,获取每一个Entry对象。
    ③、使用Entry对象中的方法getKey()和getValue获取键与值。
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Main {
    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获取键与值。
            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获取键与值。
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key+"="+value);
        }
    }
}
运行结果：
林志玲=178
赵丽颖=168
杨颖=165
----------
林志玲=178
赵丽颖=168
杨颖=165

tips：Map集合不能直接使用迭代器或者foreach进行遍历。但是转成Set之后就可以使用了。

1.5 HashMap存储自定义类型键值

练习：每位Person类（姓名，年龄）都有自己的家庭住址。那么，既然有对应关系，则将学生对象和家庭住址存储到map集合中。学生作为键, 家庭住址作为值。

注意，学生姓名相同并且年龄相同视为同一名学生。

编写Person类：

public class Person{
    private String name;
    private int age;

    public Person() {
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", 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;
    }
}

编写测试类：

public class Main {
    public static void main(String[] args) {
        show01();
    }
    /**
     * HashMap存储自定义类型键值
     * key:String类型
     *     String类重写hashCode方法和equals方法,可以保证key唯一
     * value:Person类型
     *     value可以重复(同名同年龄的人视为同一个人)
     */
    private static void show01(){
        //创建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);
        }
    }
}
运行结果：
上海--->Person{name='李四', age=19}
广州--->Person{name='王五', age=20}
北京--->Person{name='赵六', age=18}
  • 当给HashMap中存放自定义对象时，如果自定义对象作为key存在，这时要保证对象唯一，必须复写对象的hashCode和equals方法。
  • 如果要保证map中存放的key和取出的顺序一致，可以使用java.util.LinkedHashMap集合来存放。
public class Main {
    public static void main(String[] args) {
        show02();
    }
    /**
     * HashMap存储自定义类型键值
     * key:Person类型
     *      Person类型就必须重写hashCode方法和equals方法，以保证key唯一。
     * value:String类型
     *      可以重复
     */
    private static void show02(){
        //创建HashMap集合
        HashMap<Person,String> map = new HashMap<>();
        //往集合中添加元素
        map.put(new Person("女王",18),"英国");
        map.put(new Person("秦始皇",18),"秦国");
        map.put(new Person("普京",18),"俄罗斯");
        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);
        }
    }
}
运行结果：
Person{name='女王', age=18}--->英国
Person{name='女王', age=18}--->毛里求斯
Person{name='秦始皇', age=18}--->秦国
Person{name='普京', age=18}--->俄罗斯
  • HashMap存储自定义类型的值
  • Map集合保证key是唯一的：
    作为key的元素,必须重写hashCode方法和equals方法，以保证key唯一。

倘若在Person类中添加重写hashCode方法和equals方法，以保证key唯一。

@Override
public boolean equals(Object o) {
     if (this == o) return true;
     if (o == null || getClass() != o.getClass()) return false;
     Person person = (Person) o;
     return age == person.age &&
            Objects.equals(name, person.name);
}

再次运行，结果为：

Person{name='女王', age=18}--->毛里求斯
Person{name='秦始皇', age=18}--->秦国
Person{name='普京', age=18}--->俄罗斯

1.8 LinkedHashMap集合

在HashMap下面有一个子类LinkedHashMap，它是链表和哈希表组合的一个数据存储结构。

  • java.util.LinkedhashMap<K , V> extends HashMap<K , V>
  • Map接口的哈希表和链接列表实现，具有可预知的迭代顺序。
  • 底层原理：哈希表+链表（记录元素的顺序）
import java.util.HashMap;
import java.util.LinkedHashMap;

public class Main {
    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);//不允许重复,无序,{a=d, b=b, c=c}

        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);//不允许重复,有序,{a=d, c=c, b=b}
    }
}

1.9 Hashtable集合

  • java.util.Hashtable<K , V>集合 implement Map<K , V>接口
  • Hashtable：底层也是一个哈希表，是一个线程安全的集合，是单线程集合，速度慢。
  • HashMap：底层是一个哈希表，是一个线程不安全的集合，是多线程的集合，速度快。
  • HashMap集合（之前学的所有的集合）：可以存储null值，null键。
  • Hashtable集合：不能存储null值，不能存储null键。
  • Hashtable和Vector集合一样，在jdk1.2版本之后被更先进的集合（HashMap和ArrayList）取代了。
  • Hashtable的子类Properties依然活跃在历史的舞台，Properties集合是一个唯一和IO流相结合的集合 
import java.util.HashMap;
import java.util.Hashtable;

public class Main {
    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
        System.out.println(table);
    }
}

1.10 Map集合练习

需求：
计算一个字符串中每个字符出现次数。
分析：

  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集合，输出结果。
    荐 Map集合【集合特点、常用方法、集合遍历方式】以及其子类HashMap、LinkedHashMap集合的相关用法 
import java.util.HashMap;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        //1.使用Scanner获取用户输入的字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String str = sc.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);
        }
    }
}

本文地址：https://blog.csdn.net/qq_44096670/article/details/107344324

相关标签： Java基础 java

上一篇： 谷歌AI对弈围棋冠军李世石 3月9日看曹大元说棋

下一篇： 首款安卓电竞平板！联想拯救者Y700实测：《王者》几乎满帧、最高36.5℃

推荐阅读