Java中Map使用详解

本文详细介绍了Java中HashMap的使用,包括构造方法、Entry结构、遍历方式及性能分析。同时,探讨了HashMap的内部原理,如哈希函数和负载因子。接着,对比了LinkedHashMap的有序特性和性能,以及TreeMap的升序和降序排列,并进行了性能测试。最后,展示了如何利用LinkedHashMap实现LRU缓存。
摘要由CSDN通过智能技术生成

目录

一、初识Map

1、初识Map

概述:

Map接口及其常用实现类:

2、Map通用方法

二、HashMap的使用(无序)

1、HashMap基本用法

构造方法:

代码演示:

运行结果:

2、HashMap的Entry结构

3、观察HashMap的顺序

代码演示:

运行结果:

发现:

4、HashMap遍历-keySet

概述:

代码演示:

运行结果:

5、HashMap遍历-values

概述:

代码演示:

运行结果:

6、HashMap遍历-entrySet

概述:

代码演示:

运行结果:

6、HashMap遍历-Iterator

概述:

代码演示:

运行结果:

7、HashMap遍历-性能分析

三、HashMap的原理

1、需求场景描述

2、代码实现

代码演示:

运行结果:

3、底层分析

思考:

原理分析:

如何key是字符类型该怎么定位呢?

关于负载因子loadFactor:

4、HashMap构造方法优化

不带参的构造方法:

带一个初始化大小的参数:

负载因子参数:

备注:

5、性能测试结果

6、HashMap常用方法(一)

方法概述:

代码演示:

7、HashMap常用方法(二)

方法概述:

代码实现:

运行结果:

四、LinkedHashMap(有序)

1、速度对比(100万条数据)

代码实现:

运行结果:

结论:

2、速度对比(500万条数据)

运行结果:

结论:

3、速度对比(1000万条)

4、LinkedHashMap特有方法

两种输出顺序:

录入顺序:

使用顺序:

利用LinkedHashMap实现LRU缓存:

五、TreeMap(有序)

1、TreeMap实现升序

代码实现:

运行结果:

2、TreeMap实现降序

代码实现:

运行结果:

3、TreeMap速度测试

代码实现:

运行结果:

结论:


一、初识Map

1、初识Map

概述:

以键值对形式来保存数据   ---key   ---value;

键(key)值(value)来保存数据,其中值(value)可以重复,但键(key)必须是唯一,相同就覆盖;

也可以为空,但最多只能有一个key为空;

它的主要实现类有HashMap(去重)、LinkedHashMap、TreeMap(排序)。 指的都是对key 的操作;

HashSet去重和HashMap的关系:

HashSet依赖Map 存储数据,set在保存数据时,实际上是在向Map中key这一列中存数据;

 

Map接口及其常用实现类:

 

2、Map通用方法

put(key,value):存入Map中的一个key-value键值对映射;

get(key):返回指定key所映射的值;    

int size():返回键值对的数量;

remove(key):删除指定key的一对映射;

containsKey(key):判断是否包含指定的key;

 

二、HashMap的使用(无序)

1、HashMap基本用法

构造方法:

HashMap():无参构造,默认初始化长度为16,负载因子为0.75;

HashMap(int initalCapacity):指定初始化长度;

HashMap(int initalCapacity,float loadFactor):指定初始化长度和负载因子;

 

代码演示:

package com.zb.study.map;

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

//测试HashMap
public class TestHashMap {
    public static void main(String[] args) {
        //创建HashMap
        Map<String,String> map = new HashMap<>();
        //存放元素
        map.put("齐天大圣","孙悟空");
        //取出元素
        String s = map.get("齐天大圣");
        System.out.println(s);
        //获取map长度
        int size = map.size();
        System.out.println(size);
        //判断是否包含指定key
        boolean b = map.containsKey("齐天大圣");
        System.out.println(b);
    }
}

 

运行结果:

孙悟空
1
true

 

2、HashMap的Entry结构

 

3、观察HashMap的顺序

代码演示:

package com.zb.study.map;

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

//测试HashMap
public class TestHashMap {
    public static void main(String[] args) {
        //创建HashMap
        Map<String,Integer> map = new HashMap<>();
        //存放元素
        map.put("大哥",1);
        map.put("二哥",2);
        map.put("三哥",3);
        map.put("四哥",4);
        map.put("五哥",5);
        //输出map
        System.out.println(map);
    }
}

运行结果:

{二哥=2, 四哥=4, 大哥=1, 三哥=3, 五哥=5}

发现:

HashMap输出后,我们发现:它不是按照值的顺序(12345)也不是按照put的顺序存放的,而是按照自己的算法进行排序的,见HashMap原理;

 

4、HashMap遍历-keySet

概述:

keySet是map集合中所有key的集合,我们可以通过遍历keySet的方法取出所有的value;

 

代码演示:

package com.zb.study.map;

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

//测试HashMap
public class TestHashMap {
    public static void main(String[] args) {
        //创建HashMap
        Map<String,Integer> map = new HashMap<>();
        //存放元素
        map.put("大哥",1);
        map.put("二哥",2);
        map.put("三哥",3);
        map.put("四哥",4);
        map.put("五哥",5);
        //获取keySet,keySet是map集合中所有key的集合,我们可以通过遍历keySet的方法取出所有的value;
        Set<String> keySet = map.keySet();
        for (String key : keySet) {
            System.out.println(map.get(key));
        }
    }
}

 

运行结果:

2
4
1
3
5

 

5、HashMap遍历-values

概述:

values是map所有值的集合,可以直接通过遍历values并输出;

 

代码演示:

package com.zb.study.map;

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

//测试HashMap
public class TestHashMap {
    public static void main(String[] args) {
        //创建HashMap
        Map<String,Integer> map = new HashMap<>();
        //存放元素
        map.put("大哥",1);
        map.put("二哥",2);
        map.put("三哥",3);
        map.put("四哥",4);
        map.put("五哥",5);
        //获取values,values是map所有值的集合,可以直接通过遍历values并输出
        for (Integer integer : map.values()) {
            System.out.println(integer);
        }
    }
}

 

运行结果:

2
4
1
3
5

 

6、HashMap遍历-entrySet

概述:

entrySet是所有entry的集合,可以通过遍历entrySet的方式获取key和value并输出;

 

代码演示:

package com.zb.study.map;

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

//测试HashMap
public class TestHashMap {
    public static void main(String[] args) {
        //创建HashMap
        Map<String,Integer> map = new HashMap<>();
        //存放元素
        map.put("大哥",1);
        map.put("二哥",2);
        map.put("三哥",3);
        map.put("四哥",4);
        map.put("五哥",5);
        //获取entrySet,entrySet是所有entry的集合,可以通过遍历entrySet的方式获取key和value并输出
        Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
        for (Map.Entry<String, Integer> entry : entrySet) {
            System.out.println(entry.getKey() + "==>" + entry.getValue());
        }
    }
}

 

运行结果:

二哥==>2
四哥==>4
大哥==>1
三哥==>3
五哥==>5

 

6、HashMap遍历-Iterator

概述:

iterator是一个迭代器,iterator.hasNext()用来判断是否还存在下一个entry,iterator.next()用来获取下一个entry;

 

代码演示:

package com.zb.study.map;

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

//测试HashMap
public class TestHashMap {
    public static void main(String[] args) {
        //创建HashMap
        Map<String,Integer> map = new HashMap<>();
        //存放元素
        map.put("大哥",1);
        map.put("二哥",2);
        map.put("三哥",3);
        map.put("四哥",4);
        map.put("五哥",5);
        //获取iterator,iterator是一个迭代器,iterator.hasNext()用来判断是否还存在下一个entry,iterator.next()用来获取下一个entry
        Iterator<Map.Entry<String, Integer>> iterator = map.entrySet().iterator();
        while (iterator.hasNext()){
            Map.Entry<String, Integer> next = iterator.next();
            System.out.println(next.getKey() + "==>" + next.getValue());
        }
    }
}

 

运行结果:

二哥==>2
四哥==>4
大哥==>1
三哥==>3
五哥==>5

 

7、HashMap遍历-性能分析

我们组织了10万条数据,分别对集中遍历的方式进行了速度的测试,得出的结果从快到慢是顺序为:

iterator 11毫秒 (工作时次常用)—— values 11毫秒 —— entrySet 18毫秒(工作时最常用) —— keySet 33毫秒

补充:在上千万条数据进行遍历的时候,除了keySet时间较长,其他方式时间都极为接近;

 

三、HashMap的原理

1、需求场景描述

将五个学生的三门成绩使用Map存储起来;

 

2、代码实现

代码演示:

package com.zb.study.map;

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

//测试HashMap
public class TestHashMap {
    public static void main(String[] args) {
        //创建HashMap
        Map<String,Integer> subMap1 = new HashMap<>();
        Map<String,Map<String,Integer>> stuMap = new HashMap<>();
        subMap1.put("chinese",90);
        subMap1.put("math",96);
        subMap1.put("english",98);
        stuMap.put("s1",subMap1);
        Map<String,Integer> subMap2 = new HashMap<>();
        subMap2.put("chinese",91);
        subMap2.put("math",94);
        subMap2.put("english",95);
        stuMap.put("s2",subMap2);
        Map<String,Integer> subMap3 = new HashMap<>();
        subMap3.put("chinese",96);
        subMap3.put("math",95);
        subMap3.put("english",94);
        stuMap.put("s3",subMap3);
        Map<String,Integer> subMap4 = new HashMap<>();
        subMap4.put("chinese",91);
        subMap4.put("math",97);
        subMap4.put("english",96);
        stuMap.put("s4",subMap4);
        Map<String,Integer> subMap5 = new HashMap<>();
        subMap5.put("chinese",93);
        subMap5.put("math",96);
        subMap5.put("english",99);
        stuMap.put("s5",subMap5);
        System.out.println(stuMap);
    }
}

 

运行结果:

(手动换行了)

{s3={chinese=96, english=94, math=95}, s4={chinese=91, english=96, math=97}, 
s5={chinese=93, english=99, math=96}, s1={chinese=90, english=98, math=96},
 s2={chinese=91, english=95, math=94}}

 

3、底层分析

思考:

将120、37、61、40、92、78作为key存放到map中的过程;

 

原理分析:

 

如何key是字符类型该怎么定位呢?

转成hash码 —— 优化hash码 —— 根据优化后的hash码和HashMap的长度定位;

final int hash(Object k):用hashCode()方法将key转换成hash码并进行优化得到优化后的hash码;

static int indexFor(int h,int length):对优化的hash码进行取址,确定在Hashmap的位置;

 

关于负载因子loadFactor:

默认负载因子是0.75,意思是当元素占满map75%的时候对HashMap进行扩容,扩容规则是2的倍数(2的n次方),默认长16第一次扩容后就是32了,扩容之后重新计算,按照新的位置进行重新排序;

 

4、HashMap构造方法优化

不带参的构造方法:

Map<String,Integer> map= new HashMap<>();

默认长度:16

负载因子:0.75f

等价:

Map<String,Integer> map= new HashMap<>(16, 0.75f);

 

带一个初始化大小的参数:

Map<String,Integer> map= new HashMap<>(3);

传参为3,实际长度为4;

如果传参为5,实际长度为8;

因为其长度必须是2的倍数,传的参数为3意思是大于3的最小的2的n次方,也就是4,同理传参为5,长度也就是8了;

 

负载因子参数:

假如有两个元素经过计算位置都是8,那么只计算一次,当所有的位置被占用比例超过负载因子时进行扩容,扩容到下一个2的n次方的长度,根据新的长度重新计算位置,然后重新排序;

经过计算默认的0.75是最合理的,一般不轻易更改;

 

备注:

我们因情况下只自定义长度,但我们明确知道我们录入多少数据,我们就将默认长度设置为与其接近的数值,减少map的自动扩容,因为自动扩容需要重新选址很消耗性能;

 

5、性能测试结果

我们计划传入10万条数据,分别创建初始化长度为16和初始化长度为16384的两个map,负载因子使用默认的0.75,经测算我们发现:

初始化长度为16384的map由于不需要太多次扩容,其执行速度高于初始化长度为16的map;

 

6、HashMap常用方法(一)

 

方法概述:

判断是否为空、删除节点、清空HashMap对象、判断是否存在某个key、判断是否存在某个value、替换某个key的value,不存在则put;

 

代码演示:

package com.zb.study.map;

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

//测试HashMap
public class TestHashMap {
    public static void main(String[] args) {
        //创建HashMap
        Map<String,Integer> map = new HashMap<>();
        map.put("大哥",1);
        map.put("二哥",2);
        //判断是否为空
        System.out.println("判断是否为空map.isEmpty():" + map.isEmpty());
        //删除节点
        map.remove("大哥");
        map.remove("大哥",1);
        //清空HashMap对象
        map.clear();
        // 判断是否存在某个key
        System.out.println("判断是否存在某个key:" + map.containsKey("二哥"));
        // 判断是否存在某个value
        System.out.println("判断是否存在某个value:" + map.containsValue(1));
        // 替换某个key的value
        map.replace("大哥",999);//替换
        map.replace("大哥",1,999);//替换
        map.put("大哥",888);//覆盖
        //不存在则put
        map.putIfAbsent("大哥",222);

    }
}

 

7、HashMap常用方法(二)

方法概述:

map.foreach()、getOrDefault();

 

代码实现:

package com.zb.study.map;

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

//测试HashMap
public class TestHashMap {
    public static void main(String[] args) {
        //创建HashMap
        Map<String,Integer> map = new HashMap<>();
        map.put("大哥",1);
        map.put("二哥",2);
        //forEach遍历
        map.forEach((key,value)-> System.out.println(key + "==>" + value));
        //默认返回值
        System.out.println(map.getOrDefault("三哥", 9999));
    }
}

 

运行结果:

二哥==>2
大哥==>1
9999

 

 

四、LinkedHashMap(有序)

1、速度对比(100万条数据)

代码实现:

package com.zb.study.map;

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

//测试LinkedHashMap
public class TestLinkedHashMap {
    public static void main(String[] args) {
        Map<String, String> hashMap = new HashMap<>();
        Map<String, String> linkedHashMap = new LinkedHashMap<>();
        long start = System.currentTimeMillis();
        System.out.println("=======put时间=======");
        System.out.println("开始时间:" + start);
        for (int i = 0; i < 1000000; i++) {
            hashMap.put(String.valueOf(i),"value");
        }
        long end = System.currentTimeMillis();
        System.out.println("结束时间:" + end);
        System.out.println("hashMap使用时间:" + (end-start));
        start = System.currentTimeMillis();
        System.out.println("开始时间:" + start);
        for (int i = 0; i < 1000000; i++) {
            linkedHashMap.put(String.valueOf(i),"value");
        }
        end = System.currentTimeMillis();
        System.out.println("结束时间:" + end);
        System.out.println("linkedHashMap使用时间:" + (end-start));
        System.out.println("=======遍历时间=======");
        start = System.currentTimeMillis();
        System.out.println("开始时间:" + start);
        for (String value : hashMap.values());
        end = System.currentTimeMillis();
        System.out.println("结束时间:" + end);
        System.out.println("hashMap使用时间:" + (end-start));
        start = System.currentTimeMillis();
        System.out.println("开始时间:" + start);
        for (String value : linkedHashMap.values());
        end = System.currentTimeMillis();
        System.out.println("结束时间:" + end);
        System.out.println("hashMap使用时间:" + (end-start));
    }
}

 

运行结果:

=======put时间=======
开始时间:1606196463697
结束时间:1606196463880
hashMap使用时间:183
开始时间:1606196463880
结束时间:1606196464040
linkedHashMap使用时间:160
=======遍历时间=======
开始时间:1606196464040
结束时间:1606196464074
hashMap使用时间:34
开始时间:1606196464074
结束时间:1606196464093
hashMap使用时间:19

 

结论:

LinkedHashMap比HashMap速度快;

 

2、速度对比(500万条数据)

运行结果:

=======put时间=======
开始时间:1606196769308
结束时间:1606196773364
hashMap使用时间:4056
开始时间:1606196773364
结束时间:1606196779231
linkedHashMap使用时间:5867
=======遍历时间=======
开始时间:1606196779232
结束时间:1606196779384
hashMap使用时间:152
开始时间:1606196779384
结束时间:1606196779464
hashMap使用时间:80

结论:

存的速度:hashMap > linkedHashMap ;

遍历速度:linkedHashMap > hashMap ;

 

3、速度对比(1000万条)

与500万条结论一致;

 

4、LinkedHashMap特有方法

两种输出顺序:

1、录入顺序;2、使用顺序;

 

录入顺序:

代码实现:

package com.zb.study.map;

import java.util.LinkedHashMap;
import java.util.Map;

//测试LinkedHashMap
public class TestLinkedHashMap {
    public static void main(String[] args) {
        Map<String, String> map = new LinkedHashMap<>();
        map.put("y1","xx");
        map.put("m1","xx");
        map.put("k1","xx");
        map.put("n1","xx");
        System.out.println(map.get("m1"));
        //按照录入顺序输出
        for (String key : map.keySet()) {
            System.out.println(key + "==>" + map.get(key));
        }
    }
}

运行结果:

xx
y1==>xx
m1==>xx
k1==>xx
n1==>xx

使用顺序:

代码实现:

package com.zb.study.map;

import java.util.LinkedHashMap;
import java.util.Map;

//测试LinkedHashMap
public class TestLinkedHashMap {
    public static void main(String[] args) {
        Map<String, String> map = new LinkedHashMap<>(16,0.75f,true);
        map.put("y1","xx");
        map.put("m1","xx");
        map.put("k1","xx");
        map.put("n1","xx");
        System.out.println(map);
        System.out.println(map.get("m1"));
        //按照录入顺序输出
        System.out.println(map);
    }
}

运行结果(实现和上面一样的方法会报错):

{y1=xx, m1=xx, k1=xx, n1=xx}
xx
{y1=xx, k1=xx, n1=xx, m1=xx}

 

利用LinkedHashMap实现LRU缓存:

自定义LRUMap类:

package com.zb.study.map;

import java.util.LinkedHashMap;
import java.util.Map;

public class LRUMap<K,V> extends LinkedHashMap<K,V> {
    private final int maxSize;

    public LRUMap(int maxSize) {
        super(16,0.75f,true);
        this.maxSize = maxSize;
    }

    @Override
    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
        return size() > this.maxSize;
    }
}

测试代码:

package com.zb.study.map;

import java.util.Map;

//测试LinkedHashMap
public class TestLinkedHashMap {
    public static void main(String[] args) {
        //长度为3,只保留最新“活跃”的3个
        Map<String, String> lruMap = new LRUMap<>(3);
        lruMap.put("大哥","value");
        lruMap.put("二哥","value");
        lruMap.put("三哥","value");
        System.out.println(lruMap.get("大哥"));
        lruMap.put("四哥","value");
        lruMap.put("五哥","value");
        System.out.println(lruMap);
    }
}

运行结果:

value
{大哥=value, 四哥=value, 五哥=value}

 

五、TreeMap(有序)

1、TreeMap实现升序

代码实现:

package com.zb.study.map;

import java.util.Map;
import java.util.TreeMap;

public class TestTreeMap {
    public static void main(String[] args) {
        Map<String, String> map = new TreeMap<>();
        map.put("c","a3");
        map.put("e","a5");
        map.put("b","a2");
        map.put("a","a1");
        map.put("d","a4");
        //默认升序
        System.out.println(map);
    }
}

运行结果:

{a=a1, b=a2, c=a3, d=a4, e=a5}

 

2、TreeMap实现降序

代码实现:

package com.zb.study.map;

import java.util.Comparator;
import java.util.Map;
import java.util.TreeMap;

public class TestTreeMap {
    public static void main(String[] args) {
        //Map<String, String> map = new TreeMap<>(String::compareTo);//这里用了lambda表达式
        //完整表达式
        Map<String, String> map = new TreeMap<>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o2.compareTo(o1);
            }
        });
        map.put("c","a3");
        map.put("e","a5");
        map.put("b","a2");
        map.put("a","a1");
        map.put("d","a4");
        //降序
        System.out.println(map);
    }
}

运行结果:

{e=a5, d=a4, c=a3, b=a2, a=a1}

 

3、TreeMap速度测试

代码实现:

package com.zb.study.map;

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.TreeMap;

//测试LinkedHashMap
public class TestLinkedHashMap {
    public static void main(String[] args) {
        Map<String, String> hashMap = new HashMap<>();
        Map<String, String> linkedHashMap = new LinkedHashMap<>();
        Map<String, String> treeMap = new TreeMap<>();
        long start = System.currentTimeMillis();
        System.out.println("=======put时间=======");
        System.out.println("开始时间:" + start);
        for (int i = 0; i < 1000000; i++) {
            hashMap.put(String.valueOf(i),"value");
        }
        long end = System.currentTimeMillis();
        System.out.println("结束时间:" + end);
        System.out.println("hashMap使用时间:" + (end-start));
        start = System.currentTimeMillis();
        System.out.println("开始时间:" + start);
        for (int i = 0; i < 1000000; i++) {
            linkedHashMap.put(String.valueOf(i),"value");
        }
        end = System.currentTimeMillis();
        System.out.println("结束时间:" + end);
        System.out.println("linkedHashMap使用时间:" + (end-start));
        start = System.currentTimeMillis();
        System.out.println("开始时间:" + start);
        for (int i = 0; i < 1000000; i++) {
            treeMap.put(String.valueOf(i),"value");
        }
        end = System.currentTimeMillis();
        System.out.println("结束时间:" + end);
        System.out.println("treeMap使用时间:" + (end-start));
        System.out.println("=======遍历时间=======");
        start = System.currentTimeMillis();
        System.out.println("开始时间:" + start);
        for (String value : hashMap.values());
        end = System.currentTimeMillis();
        System.out.println("结束时间:" + end);
        System.out.println("hashMap使用时间:" + (end-start));
        start = System.currentTimeMillis();
        System.out.println("开始时间:" + start);
        for (String value : linkedHashMap.values());
        end = System.currentTimeMillis();
        System.out.println("结束时间:" + end);
        System.out.println("hashMap使用时间:" + (end-start));
        start = System.currentTimeMillis();
        System.out.println("开始时间:" + start);
        for (String value : treeMap.values());
        end = System.currentTimeMillis();
        System.out.println("结束时间:" + end);
        System.out.println("treeMap使用时间:" + (end-start));
    }
}

运行结果:

=======put时间=======
开始时间:1606201339487
结束时间:1606201339664
hashMap使用时间:177
开始时间:1606201339664
结束时间:1606201339827
linkedHashMap使用时间:163
开始时间:1606201339827
结束时间:1606201341737
treeMap使用时间:1910
=======遍历时间=======
开始时间:1606201341737
结束时间:1606201341774
hashMap使用时间:37
开始时间:1606201341774
结束时间:1606201341797
hashMap使用时间:23
开始时间:1606201341797
结束时间:1606201341832
treeMap使用时间:35

结论:

treeMap存放数据比较耗时,遍历与hashMap和linkedHashMap差不多;

 

 

 

 

 

 

 

 

 

评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值