Home 成长之路 性能优化收录之HashMap

性能优化收录之HashMap

0 68

HashMap作为集合框架中的重要组成部分,使用的地方有很多,例如最近所使用到的Mybatis通过Map传参等,HashMap的思想是键值对映射,例如进行多条件判断,一样可以通过HashMap来实现

在讨论其优化之前,我们先提一句HashMap的使用(题外话,能跟潇同学联系上真的蛮开心的)

package Test;

import java.util.HashMap;
public class HashMap2 {

    /**
     * 使用键值对的思想可以干很多事情
     * Map<key,value>键和value可以定义为任意的数据类型
     * 通常用于多种相同性质的属性(或事件)执行操作,都是通过key去得到value
     * 开始实战:
     *      模拟case取整数值执行不同的流程
     *
     */
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.setName("白衣");
        p1.setType("老师");
        Person p2 = new Person();
        p2.setName("杨深建");
        p2.setType("学生");
        HashMap map = doMethod(p1, p2);
        //在此处控制传参即可执行不同的流程;
        Decide(map,1);
    }
    static HashMap doMethod(Person p1,Person p2){
        //制作HashMap
        HashMap<Integer,Person> hashMap = new HashMap<Integer, Person>();
        hashMap.put(1,p1);
        hashMap.put(2,p2);
        return hashMap;
    }
    static void Decide(HashMap hashMap,Integer integer){
        //显示数据,判断程序是否成功
        System.out.println(hashMap.get(integer).toString());
    }
}
//实体类
class Person{
    //定义字段;
    private String name;
    private String type;

    public String getName() {
        return name;
    }

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

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    @Override
    public String toString() {
        return  "Person{" +
                "name='" + name + '\'' +
                ", type='" + type + '\'' +
                '}';
    }
}

这只是我的一次小小尝试,仅为了说明HashMap的思想,也许实际开发中我们不会这么去用,而是创造接口实现,本质也是抽象思想
思想最重要!!!

下面开始分析其遍历模式及优化:


转载自https://mp.weixin.qq.com/s?__biz=MzU1NTkwODE4Mw==&mid=2247485208&idx=1&sn=62be917b1431243b898354d17112b06f&chksm=fbcc6a20ccbbe3365f985fc8e9e19ca5e420d8907dab59358181eab8612b9835c56fcdcca1c5&scene=178&cur_album_id=1337160373983690752#rd

随着 JDK 1.8 Streams API 的发布,使得 HashMap 拥有了更多的遍历的方式,但应该选择那种遍历方式?反而成了一个问题。

本文先从 HashMap 的遍历方法讲起,然后再从性能、原理以及安全性等方面,来分析 HashMap 各种遍历方式的优势与不足,本文主要内容如下图所示:

HashMap遍历四大类:

  • 1.迭代器(Iterator)方式遍历
  • 2.For Each方式遍历;
  • 3.Lambda表达式遍历(JDK1.8+);
  • 4.Streams API遍历(JDK1.8+);

每种类型下又有不同的实现方式,因此具体的遍历方式又可以分为以下7种:

  • 使用迭代器(Iterator)EntrySet 的方式进行遍历;
  • 使用迭代器(Iterator)KeySet 的方式进行遍历;
  • 使用 For Each EntrySet 的方式进行遍历;
  • 使用 For Each KeySet 的方式进行遍历;
  • 使用 Lambda 表达式的方式进行遍历;
  • 使用 Streams API 单线程的方式进行遍历;
  • 使用 Streams API 多线程的方式进行遍历。

1.迭代器EntrySet

public class IteratorEntryset {
    public static void main(String[] args) {

        //创建HashMap并赋值
        Map<Integer,String> map = new HashMap<>();
        map.put(1, "Java");
        map.put(2, "JDK");
        map.put(3, "Spring Framework");
        map.put(4, "MyBatis framework");
        map.put(5, "Java中文社群");

        //遍历
        Iterator<Map.Entry<Integer,String>> iterator = map.entrySet().iterator();
        while(iterator.hasNext()){
            Map.Entry<Integer,String> entry = iterator.next();
            System.out.println(entry.getKey());
            System.out.println(entry.getValue());
        }


    }
}

2.迭代器KeySet
public class IteratorKeySet {

    public static void main(String[] args) {

        //创建并赋值HashMap
        Map<Integer, String> map = new HashMap();
        map.put(1, "Java");
        map.put(2, "JDK");
        map.put(3, "Spring Framework");
        map.put(4, "MyBatis framework");
        map.put(5, "Java中文社群");
        // IteratorKeySet遍历 得到的是Map中的键Key
        Iterator<Integer> iterator = map.keySet().iterator();
        while (iterator.hasNext()) {
            //获取当前的Key
            Integer key = iterator.next();
            //打印Key
            System.out.println(key);
            //通过Key打印value;
            System.out.println(map.get(key));
        }
    }
}

3.Foreach EntrySet
public class ForEachKeySet {

    /**
     * 使用Foreach遍历,通过Entryset()方法
     * Foreach适用于只在集合或数组中进行遍历,for则在较复杂的循环中效率更高
     * Foreach不能对集合或者数组中的元素进行添加和删除操作,因此需要修改元素(添加,删除)则需要使用for循环
     * @param args
     */
    public static void main(String[] args) {
        // 创建并赋值 HashMap
        Map<Integer, String> map = new HashMap();
        map.put(1, "Java");
        map.put(2, "JDK");
        map.put(3, "Spring Framework");
        map.put(4, "MyBatis framework");
        map.put(5, "Java中文社群");
        //使用Foreach遍历,通过EntrySet()方法
        for (Map.Entry<Integer,String> entry : map.entrySet()) {
            System.out.println(entry.getKey());
            System.out.println(entry.getValue());
        }
    }
}
4.Foreach KeySet
public class ForEachEntrySet {
    /**
     * 使用Foreach遍历,通过keyset()方法
     * Foreach适用于只在集合或数组中进行遍历,for则在较复杂的循环中效率更高
     * Foreach不能对集合或者数组中的元素进行添加和删除操作,因此需要修改元素(添加,删除)则需要使用for循环
     * @param args
     */
    public static void main(String[] args) {
        // 创建并赋值 HashMap
        Map<Integer, String> map = new HashMap();
        map.put(1, "Java");
        map.put(2, "JDK");
        map.put(3, "Spring Framework");
        map.put(4, "MyBatis framework");
        map.put(5, "Java中文社群");
        //使用Foreach遍历,通过keyset()方法
        for (Integer key:map.keySet()) {
            System.out.println(key);
            System.out.println(map.get(key));
        }
    }
}


5.Lambda
public class Lambda {
    public static void main(String[] args) {

        /**
         * Lambda表达式实现Map遍历
         */
        // 创建并赋值 HashMap
        Map<Integer, String> map = new HashMap();
        map.put(1, "Java");
        map.put(2, "JDK");
        map.put(3, "Spring Framework");
        map.put(4, "MyBatis framework");
        map.put(5, "Java中文社群");
        // Lambda遍历:(参数类型 参数名称) ‐> { 代码语句 }
        map.forEach((key,value)->{
            System.out.println(key);
            System.out.println(map.get(key));
        });
    }
}

6.Streams API 单线程

public class StreamsOne {
    /**
     * SteamsAPI是对集合的一种操作;
     *
     * @param args
     */
    public static void main(String[] args) {
        // 创建并赋值 HashMap
        Map<Integer, String> map = new HashMap();
        map.put(1, "Java");
        map.put(2, "JDK");
        map.put(3, "Spring Framework");
        map.put(4, "MyBatis framework");
        map.put(5, "Java中文社群");
        //遍历
        map.entrySet().stream().forEach((entry) -> {
            System.out.println(entry.getKey());
            System.out.println(entry.getValue());
        });
    }
}


7.Stream APT多线程
public class StreamsOne {
    /**
     * SteamsAPI是对集合的一种操作;
     * map.entrySet().Stream().forEach单线程
     * map.entrySet().parallelStream().forEach单线程
     * @param args
     */
    public static void main(String[] args) {
        // 创建并赋值 HashMap
        Map<Integer, String> map = new HashMap();
        map.put(1, "Java");
        map.put(2, "JDK");
        map.put(3, "Spring Framework");
        map.put(4, "MyBatis framework");
        map.put(5, "Java中文社群");
        // map.entrySet().Stream().forEach单线程
        // map.entrySet().parallelStream().forEach单线程
        map.entrySet().parallelStream().forEach((entry) -> {
            System.out.println(entry.getKey());
            System.out.println(entry.getValue());
        });
    }
}

以上程序的执行结果为:(因为是多线程,所以与之前的结果不一样)

4

MyBatis framework

5

Java中文社群

1

Java

2

JDK

3

Spring Framework

 

性能测试:

其中 Units 为 ns/op 意思是执行完成时间(单位为纳秒),而 Score 列为平均执行时间, ± 符号表示误差。从以上结果可以看出,两个 entrySet 的性能相近,并且执行速度最快,接下来是 stream ,然后是两个 keySet,性能最差的是 Lambda。

结论

从以上结果可以看出 entrySet 的性能比 keySet 的性能高出了一倍之多,因此我们应该尽量使用 entrySet  来实现 Map 集合的遍历

从结果可以看出,除了 Lambda 和 Streams API 之外,通过迭代器循环和 for 循环的遍历的 EntrySet 最终生成的代码是一样的,他们都是在循环中创建了一个遍历对象 Entry ,代码如下:

public static void entrySet() {
    Iterator var0 = map.entrySet().iterator();
    while(var0.hasNext()) {
        Entry var1 = (Entry)var0.next();
        System.out.println(var1.getKey());
        System.out.println((String)var1.getValue());
    }
}
public static void forEachEntrySet() {
    Iterator var0 = map.entrySet().iterator();
    while(var0.hasNext()) {
        Entry var1 = (Entry)var0.next();
        System.out.println(var1.getKey());
        System.out.println((String)var1.getValue());
    }
}

而 KeySet 的代码也是类似的,如下所示:

public static void keySet() {
    Iterator var0 = map.keySet().iterator();
    while(var0.hasNext()) {
        Integer var1 = (Integer)var0.next();
        System.out.println(var1);
        System.out.println((String)map.get(var1));
    }
} 
public static void forEachKeySet() {
    Iterator var0 = map.keySet().iterator();
    while(var0.hasNext()) {
        Integer var1 = (Integer)var0.next();
        System.out.println(var1);
        System.out.println((String)map.get(var1));
    }
}

所以我们在使用迭代器或是 for 循环 EntrySet 时,他们的性能都是相同的,因为他们最终生成的字节码基本都是一样的;同理 KeySet 的两种遍历方式也是类似的。

性能分析

EntrySet 之所以比 KeySet 的性能高是因为,KeySet 在循环时使用了 map.get(key),而 map.get(key) 相当于又遍历了一遍 Map 集合去查询 key 所对应的值。为什么要用“又”这个词?那是因为在使用迭代器或者 for 循环时,其实已经遍历了一遍 Map 集合了,因此再使用 map.get(key) 查询时,相当于遍历了两遍

而 EntrySet 只遍历了一遍 Map 集合,之后通过代码“Entry<Integer, String> entry = iterator.next()”把对象的 key 和 value 值都放入到了 Entry 对象中,因此再获取 key 和 value 值时就无需再遍历 Map 集合,只需要从 Entry 对象中取值就可以了。

所以,EntrySet 的性能比 KeySet 的性能高出了一倍,因为 KeySet 相当于循环了两遍 Map 集合,而 EntrySet 只循环了一遍

因此选EntrySet方法!!!

安全性测试

从上面的性能测试结果和原理分析,我想大家应该选用那种遍历方式,已经心中有数的,而接下来我们就从「安全」的角度入手,来分析那种遍历方式更安全。

我们把以上遍历划分为四类进行测试:迭代器方式、For 循环方式、Lambda 方式和 Stream 方式,测试代码如下。

1.迭代器方式

Iterator<Map.Entry<Integer, String>> iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
    Map.Entry<Integer, String> entry = iterator.next();
    if (entry.getKey() == 1) {
        // 删除
        System.out.println("del:" + entry.getKey());
        iterator.remove();
    } else {
        System.out.println("show:" + entry.getKey());
    }
}

以上程序的执行结果:

show:0

del:1

show:2

测试结果:迭代器中循环删除数据安全

2.For 循环方式

for (Map.Entry<Integer, String> entry : map.entrySet()) {
    if (entry.getKey() == 1) {
        // 删除
        System.out.println("del:" + entry.getKey());
        map.remove(entry.getKey());
    } else {
        System.out.println("show:" + entry.getKey());
    }
}

以上程序的执行结果:

测试结果:For 循环中删除数据非安全

3.Lambda 方式

map.forEach((key, value) -> {
    if (key == 1) {
        System.out.println("del:" + key);
        map.remove(key);
    } else {
        System.out.println("show:" + key);
    }
});

以上程序的执行结果:

测试结果:Lambda 循环中删除数据非安全

Lambda 删除的正确方式

// 根据 map 中的 key 去判断删除
map.keySet().removeIf(key -> key == 1);
map.forEach((key, value) -> {
    System.out.println("show:" + key);
});

以上程序的执行结果:

show:0

show:2

从上面的代码可以看出,可以先使用 Lambda 的 removeIf 删除多余的数据,再进行循环是一种正确操作集合的方式。

4.Stream 方式

map.entrySet().stream().forEach((entry) -> {
    if (entry.getKey() == 1) {
        System.out.println("del:" + entry.getKey());
        map.remove(entry.getKey());
    } else {
        System.out.println("show:" + entry.getKey());
    }
}); 以上程序的执行结果:

测试结果:Stream 循环中删除数据非安全

Stream 循环的正确方式

map.entrySet().stream().filter(m -> 1 != m.getKey()).forEach((entry) -> {
    if (entry.getKey() == 1) {
        System.out.println("del:" + entry.getKey());
    } else {
        System.out.println("show:" + entry.getKey());
    }
});

以上程序的执行结果:

show:0

show:2

从上面的代码可以看出,可以使用 Stream 中的 filter 过滤掉无用的数据,再进行遍历也是一种安全的操作集合的方式。

 

 

总结:本文我们讲了 HashMap 4 种遍历方式:迭代器、for、lambda、stream,以及具体的 7 种遍历方法,综合性能和安全性来看,我们应该尽量使用迭代器(Iterator)来遍历 EntrySet 的遍历方式来操作 Map 集合,这样就会既安全又高效了。

迭代器删除元素是安全的;

For删除元素不是安全的;

Lambda和Steam可以安全也可以不安全,取决于是否先判断删除(即不在循环中删除);

SIMILAR ARTICLES

发表评论

发表评论