Java高级之HashMap中的keySet()方法

最新推荐文章于 2024-04-27 17:25:39 发布

二木成林

最新推荐文章于 2024-04-27 17:25:39 发布

阅读量1.1w

点赞数 14

分类专栏： Java 文章标签： HashMap keySet 增强型for循环迭代器源码解析

本文链接：https://blog.csdn.net/cnds123321/article/details/113791846

版权

Java 专栏收录该内容

24 篇文章 5 订阅

订阅专栏

keySet()方法的源码为：

    public Set<K> keySet() {
        Set<K> ks = keySet;
        if (ks == null) {
            ks = new KeySet();
            keySet = ks;
        }
        return ks;
    }

注释为：

    /**
     * 获取HashMap的键的集合，以Set<K>保存
     * @return 返回key的集合
     */
    public Set<K> keySet() {
        /*
            说明：
                1.可以看到其实该方法中，并没有将HashMap中的键添加到Set集合中，那么是如何实现的呢？
                2.但实际上，我们访问Set集合，根本就无法通过索引，而是需要通过迭代器Iterator才能访问到元素，foreach本质上也是迭代器
                3.这里的 ks 就仅仅只是一个Set引用，指向HashMap内部类KeySet的一个实例，重点在于该实例拥有自己的迭代器，当我们在使用增强for循环时才会调用该迭代器，也才会输出我们想要的东西
         */
        // 获取keySet
        Set<K> ks = keySet;
        // 判断ks是否为null,如果为null，表示为空
        if (ks == null) {
            // 实例化KeySet对象
            ks = new KeySet();
            // 然后将ks设置给keySet
            keySet = ks;
        }
        // 返回ks
        return ks;
    }

为了理解该方法参考了：源码解析HashMap的keySet()方法

但发现还是无法深入理解，最后查看增强for循环，得到了灵感。

所谓的增强型for循环，即是如下格式的for循环，其中遍历的目标可以是数组，也可以是集合（较为常用）：

for(数据类型 变量名 :遍历的目标){ 
    // 
}

例如：

public class Demo {
    public static void main(String[] args) {
        int[] arr=new int[]{1,2,3,4,5};
        for (int i : arr) {
            System.out.println(i);
        }
    }
}

面对这样的代码即使进行debug调试，可能也看不出来什么，但我们可以查看它的字节码文件（即后缀为.class的文件），里面会得到我们想要的。

该Demo.class的内容为：

public class Demo {
    public Demo() {
    }

    public static void main(String[] args) {
        int[] arr = new int[]{1, 2, 3, 4, 5};
        int[] var2 = arr;
        int var3 = arr.length;

        for(int var4 = 0; var4 < var3; ++var4) {
            int i = var2[var4];
            System.out.println(i);
        }

    }
}

可以看到如果增强型for循环如果遍历的目标是数组，那么最终编译使用的是for循环，得到变量的值进行输出。

那么下面来看看使用增强型for来遍历List集合

public class Demo {
    public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        list.add("唐僧");
        list.add("孙悟空");
        // 使用增强型for遍历循环List集合
        for (String s : list) {
            System.out.println(s);
        }
    }
}

编译后的字节码文件Demo.class内容如下：

public class Demo {
    public Demo() {
    }

    public static void main(String[] args) {
        List<String> list = new ArrayList();
        list.add("唐僧");
        list.add("孙悟空");
        Iterator var2 = list.iterator();

        while(var2.hasNext()) {
            String s = (String)var2.next();
            System.out.println(s);
        }

    }
}

可以看到如果增强型for循环如果遍历的目标是集合，那么最终编译使用的是迭代器，得到变量的值进行输出。

正是因为可以查看编译后的字节码，所以我们可以来查看keySet()方法运行后的结果，先运行下面的代码：

public class Demo {
    public static void main(String[] args) {
        Map<String,String> map=new HashMap<>();
        map.put("abc","123");
        map.put("efg","456");
        // 使用增强型for遍历循环List集合
        Set<String> keySet = map.keySet();
        for (String key : keySet) {
            System.out.println(key);
        }
    }
}

查看编译生成的字节码文件Demo.class

public class Demo {
    public Demo() {
    }

    public static void main(String[] args) {
        Map<String, String> map = new HashMap();
        map.put("abc", "123");
        map.put("efg", "456");
        Set<String> keySet = map.keySet();
        Iterator var3 = keySet.iterator();

        while(var3.hasNext()) {
            String key = (String)var3.next();
            System.out.println(key);
        }

    }
}

那么查看iterator()方法的源码，即迭代器的源码，该类在Set接口中定义了方法，而在HashMap在类KeySet中实现了该方法。

而我们知道类KeySet在keySet()方法中实例化了

在iterator()方法中又实例化了KeyIterator这个类对象，那么查看该类

这是一个next()方法，表示获取下一个元素，在编译后的字节码文件中，我们看到就是通过next()方法得到键key的。

在next()方法中的返回语句中又调用了nextNode()方法，nextNode().key就是键值对中的键，即我们需要的结果。

nextNode()方法的源代码如下：

下面注释这个方法：

 /**
  * 获取下一个结点
  *
  * @return 返回下一个结点信息
  */
 final Node<K, V> nextNode() {
     // 局部变量，保存哈希桶数组table
     Node<K, V>[] t;
     // 局部变量，保存当前结点的下一个结点
     Node<K, V> e = next;
     // 如果修改次数不对，那么多线程修改了HashMap
     if (modCount != expectedModCount)
	 // 则抛出异常
       throw new ConcurrentModificationException();
     // 如果下一个结点是null
     if (e == null)
     // 则抛出NoSuchElementException异常
       throw new NoSuchElementException();
     // 当前的链表遍历完了就开始遍历下一个链表
     if ((next = (current = e).next) == null && (t = table) != null) {
		 do {
		  } while (index < t.length && (next = t[index++]) == null);
     }
     // 返回下一个结点
     return e;
 }

实际上就是遍历循环的时候获取下一个结点，而nextNode().key就得到了键的值。

所以遍历循环map.keySet()在编译时分为了三步完成：