一篇文章让你精通：java集合讲解（六，Map）

韶光不负

已于 2022-05-25 10:35:13 修改

阅读量1.4k

点赞数 5

分类专栏： Java 集合 Java面试题文章标签： java 开发语言后端

于 2021-11-09 21:16:02 首次发布

本文链接：https://blog.csdn.net/weixin_47514459/article/details/121234216

版权

Java 同时被 3 个专栏收录

76 篇文章 1 订阅

订阅专栏

Java面试题

26 篇文章 1 订阅

订阅专栏

集合

13 篇文章 0 订阅

订阅专栏

相信大家从头看过来，已经对前面List与Set有了一定的理解，下面我们就需要对集合中最后一个分类进行讲解Map，废话不多说，下面就让我们来看看Map有什么奇妙的地方吧！

结论：LinkedHashMap时（哈希表进行存储）

TreeMap

结论：TreeMapMap时（哈希表进行存储）

Map常见四种操作

HashMap添加元素过程

练习map添加学生信息

问题：为什么没有重写hashcode与equals方法没有报错

问题：为什么是4个学生信息，我们添加的是五个学生信息？

Set与Map的关系（面试题）

Map

特点：存储的是键值对的映射关系（每一个元素存在键与值，通过得到key找到与之对应value）

分类

map分为二类，hashmap，LinkHashMap与treemap

map的参数设置(500为自己设置的存储空间，0.5f是装填因子（当存储数据到达500*0.5时，map就会发生扩容）)

当我们设置500时，主数组长度不会是500，只能是2的次方>500最近的数

 Map map=new LinkedHashMap(500,0.5f);
//HashMap(500,0.5f)
//TreeMap(500,0.5f)

HashMap:

特点：采用hashtable哈希表结构进行存储

优点：快

缺点：无序

LinkHashMap:

特点：采用hashtable哈希表结构进行存储，同时使用链表来维持次序

与Hashmap相比优点：有序（添加顺序）

TreeMap:

特点：采用二叉树（红黑树）结构进行存储

优点：比List的查找顺序要快

缺点：没有hashmap速度快

使用Map

Map的常见方法
put	添加
size	统计key个数
get("key")	通过key获取value
keySet()	获取key集合
values()	获取value
isEmpty()	判断是否为空
containsKey(“key”)	判断key是否存在
containsValue(“value”)	判断value是否存在，比较内容
replace(key,new 内容) 例：（ replace(12,new Student(10,"xiaoming",18,68.5)) ）	修改key的内容
replace(“key”)	删除key

HashMap:

package com.luo_sf.map;


import java.util.HashMap;
import java.util.Map;
/*
使用map存储国家名称
*/
public class TestMap {
    public static void main(String[] args) {
        //创建Map
        Map<String,String> countries= new HashMap<>();
        

        //添加
        countries.put("中国","China");
        countries.put("美国","America");

        countries.put("巴西","Brazil");
        countries.put("韩国","Korea");
        //测试相同的key发生什么？
        countries.put("韩国","South Korea");

        //统计
        System.out.println(countries.size());
        //获取
        System.out.println(countries.get("中国"));
        //测试不存在的
        System.out.println(countries.get("日本"));

        //查看相同的key发生结果
        System.out.println(countries);

    }

}

结论：hashMap时（哈希表进行存储）

1，key:无序，唯一（当我们存储相同的key时，后面value会覆盖前面value）

2，value: 无序，不唯一

LinkedHashMap

package com.luo_sf.map;



import java.util.LinkedHashMap;
import java.util.Map;
/*
使用map存储国家名称
*/
public class TestMap {
    public static void main(String[] args) {
        //创建Map
        Map<String,String> countries= new LinkedHashMap<>();

        //添加
        countries.put("中国","China");
        countries.put("美国","America");

        countries.put("巴西","Brazil");
        countries.put("韩国","Korea");
        //测试相同的key发生什么？
        countries.put("韩国","South Korea");

        //统计
        System.out.println(countries.size());
        //获取
        System.out.println(countries.get("中国"));
        //测试不存在的
        System.out.println(countries.get("日本"));

        //查看相同的key发生结果
        System.out.println(countries);

    }

}

结论：LinkedHashMap时（哈希表进行存储）

1，key:有序（添加顺序），唯一（当我们存储相同的key时，后面value会覆盖前面value）

2，value: 无序，不唯一

TreeMap

package com.luo_sf.map;
import java.util.Map;
import java.util.TreeMap;

/*
使用map存储国家名称
*/
public class TestMap {
    public static void main(String[] args) {
        //创建Map
        Map<String,String> countries= new TreeMap<>();

        //添加
        countries.put("中国","China");
        countries.put("美国","America");

        countries.put("巴西","Brazil");
        countries.put("韩国","Korea");
        //测试相同的key发生什么？
        countries.put("韩国","South Korea");

        //统计
        System.out.println(countries.size());
        //获取
        System.out.println(countries.get("中国"));
        //测试不存在的
        System.out.println(countries.get("日本"));

        //查看相同的key发生结果
        System.out.println(countries);

    }

}

结论：TreeMapMap时（哈希表进行存储）

1，key:有序（自然顺序，abc...），唯一（当我们存储相同的key时，后面value会覆盖前面value）

2，value: 无序，不唯一

Map常见四种操作

创建Map

 Map<String,String> Map名称= new TreeMap<>();

添加键值对

Map名称.put("key","value");

根据key获取value

System.out.println(Map名称.get("key"));

遍历数据

 //遍历Map
        System.out.println(countries);  //toString方法

        //获取key,得到value
        Set<String> keyset = countries.keySet();
        for (String key:keyset) {
            System.out.println(key + "-->" + countries.get(key));
        }

        //获取所以的节点（Entry,相当于哈希表与二叉树中的节点）组成集合
        System.out.println(countries.entrySet());
        //或者
        Set<Map.Entry<String,String>> entrySet=countries.entrySet();
        Iterator<Map.Entry<String,String>> it=entrySet.iterator();
        while (it.hasNext()){
        Map.Entry<String,String> entry=it.next();
            System.out.println(entry);
        }
    }

HashMap添加元素过程

1,计算key的hash值，二次计算hash值（hash值进行hash计算）对数组长度取模，对应数组的下标

2，如果没有产生hash冲突，直接常见node节点存入数组中

3，如果产生冲突，equals方法进行比较，相同则取代该元素，不同，则判断链表高度，当链表高度超过8，并且数组的长度到64，则转变为红黑树，长度低于6，红黑树转化回链表。

4，key值为null，储存在下标0位置。

练习map添加学生信息

创建学生对象

package com.luo_sf.map;

public class Student {
    private int id;
    private String name;
    private int age;
    private Double scpre;

    public Student() {
    }

    public Student(int id, String name, int age, Double scpre) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.scpre = scpre;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public Double getScpre() {
        return scpre;
    }

    public void setId(int id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setScpre(Double scpre) {
        this.scpre = scpre;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", scpre=" + scpre +
                '}';
    }
}

创建map集合

package com.luo_sf.map;

import java.security.KeyStore;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.Map.*;


public class StudentMap {
    public static void main(String[] args) {
        //创建一个map集合
        Map<Integer,Student> map= new HashMap();

        //创建学生信息
        Student stu1= new Student(10,"xiaoming",18,68.5);
        Student stu2= new Student(11,"zhangsan",28,78.5);
        Student stu3= new Student(12,"lishi",8,98.5);
        Student stu4= new Student(13,"wangwu",38,66.5);
        Student stu5= new Student(10,"xiaoming",18,68.5);

        //添加入map中
        map.put(stu1.getId(),stu1);
        map.put(stu2.getId(),stu2);
        map.put(stu3.getId(),stu3);
        map.put(stu4.getId(),stu4);
        map.put(stu5.getId(),stu5);

        //统计人数
        System.out.println(map.size());

        System.out.println(map);

        System.out.println(map.get(12));

        //遍历
        Set<Entry<Integer,Student>>entrySet = map.entrySet();
        for (Entry entry:entrySet) {

            System.out.println(entry.getValue());
        }

    }


}

问题：为什么没有重写hashcode与equals方法没有报错

 Map<Integer,Student> map= new HashMap();
 map.put(stu5.getId(),stu5);

因为哈希码与key有关跟value无关，我们设置的为Integer（学生的id），在哈希表内部有Integer的hashcode与equals方法，所以没有报错。

问题：为什么是4个学生信息，我们添加的是五个学生信息？

在map中key是唯一的，所以当出现重复的key时，后面value覆盖前面的value。

Set与Map的关系（面试题）

如果Map只存储key，不存储value时，就是与之对应的Set(SET是与之对应Map的key的集合)

韶光不负

关注

5
点赞
踩
4

收藏

觉得还不错? 一键收藏
打赏
1
评论
一篇文章让你精通：java集合讲解（六，Map）

相信大家从头看过来，已经对前面List与Set有了一定的理解，下面我们就需要对集合中最后一个分类进行讲解Map，废话不多说，下面就让我们来看看Map有什么奇妙的地方吧！目录Map分类HashMap:LinkHashMap（HashMap的子类）:TreeMap:使用MapHashMap:结论：hashMap时（哈希表进行存储）LinkedHashMap结论：LinkedHashMap时（哈希表进行存储）TreeMap结论：TreeMapMa...
复制链接

扫一扫