通过java字节码分析java foreach循环

前几天看到群里有人发了一篇关于java foreach循环(增强for循环)
测试文章。文章没细看,从别人的发的截图来看是将LinkedList使用 for i
循环与foreach循环测试的数据做对比,然后得出foreach循环惊人的性能。猜写这文章的人应该是一个初学者,如果是我,会用迭代器来遍历LinkedList,然后再与foreach循环的数据作对比。因为LinkedList是双链表结构,并不适合使用 for i
循环这种方式进行遍历,实际写代码时也不会这么用。那foreach循环出现是为了解决什么问题?

一、集合遍历测试数据对比

使用的测试环境是jdk: 1.8.0_251,CPU:i7-9750H。

1.1 LinkedList循环测试数据对比

对于LinkedList遍历的测试代码如下所示:

import java.util.Iterator;
import java.util.LinkedList;

public class LinkedListTest {

    private static final int SIZE = 50000000;
    private static final int TIMES = 20;

    public static void main(String[] args) {
        LinkedList<String> list = initLinkedList();
        long time = System.currentTimeMillis();
        for (int i = 0; i < TIMES; i++) {
            testLinkedListIterator(list);
//            testLinkedListForeach(list);
        }

        System.out.println("LinkedList used time: " + ((System.currentTimeMillis() - time) / TIMES));
    }

    /**
     * 初始化数据
     * @return 返回初始化数据
     */
    private static LinkedList<String> initLinkedList() {
        LinkedList<String> list = new LinkedList<>();
        for (int i = 0; i < SIZE; i++) {
            list.add(String.valueOf(i));
        }

        return list;
    }

    /**
     * 测试迭代器迭代LinkedList的性能
     * @param list LinkedList数据
     * @return 返回执行的时间
     */
    private static long testLinkedListIterator(LinkedList<String> list) {
        long sum = 0L;
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            sum += it.next().length();
        }

        return sum;
    }

    /**
     * 测试foreach循环LinkedList的性能
     * @param list LinkedList数据
     * @return 返回执行的时间
     */
    private static long testLinkedListForeach(LinkedList<String> list) {
        long sum = 0L;
        for (String s : list) {
            sum += s.length();
        }

        return sum;
    }

}

最后测试两种遍历方式输出的时间分别是:

testLinkedListIterator(): LinkedList used time: 1005
testLinkedListForeach(): LinkedList used time: 1028

通过数据对比,迭代器循环和foreach循环两者不相上下。

1.2 ArrayList循环测试数据对比

同样测试ArrayList遍历的代码如下,但是增加了普通的for循环:

import java.util.ArrayList;
import java.util.Iterator;

public class ArrayListTest {

    private static final int SIZE = 50000000;
    private static final int TIMES = 20;

    public static void main(String[] args) {
        ArrayList<String> list = initArrayList();
        long time = System.currentTimeMillis();
        for (int i = 0; i < TIMES; i++) {
            testArrayListIterator(list);
//            testArrayListForeach(list);
//            testArrayListFor(list);
        }

        System.out.println("ArrayList used time: " + ((System.currentTimeMillis() - time) / TIMES));
    }

    /**
     * 初始化数据
     * @return 返回初始化数据
     */
    private static ArrayList<String> initArrayList() {
        ArrayList<String> list = new ArrayList<>(SIZE);
        for (int i = 0; i < SIZE; i++) {
            list.add(String.valueOf(i));
        }

        return list;
    }

    /**
     * 测试迭代器迭代ArrayList的性能
     * @param list ArrayList数据
     * @return 返回执行的时间
     */
    private static long testArrayListIterator(ArrayList<String> list) {
        Iterator<String> it = list.iterator();
        long sum = 0L;
        while (it.hasNext()) {
            sum += it.next().length();
        }

        return sum;
    }

    /**
     * 测试foreach循环ArrayList的性能
     * @param list ArrayList数据
     * @return 返回执行的时间
     */
    private static long testArrayListForeach(ArrayList<String> list) {
        long sum = 0L;
        StringBuilder sb = new StringBuilder();
        for (String s : list) {
            sum += s.length();
        }

        return sum;
    }

    /**
     * 测试普通for循环ArrayList的性能
     * @param list ArrayList数据
     * @return 返回执行的时间
     */
    private static long testArrayListFor(ArrayList<String> list) {
        long sum = 0L;
        for (int i = 0; i < list.size(); i++) {
            sum += list.get(i).length();
        }

        return sum;
    }

}

最后测试三种遍历方式输出的时间分别是:

testArrayListIterator(): ArrayList used time: 162
testArrayListForeach(): ArrayList used time: 164
testArrayListFor(): ArrayList used time: 166

同样,三者的数据基本不相上下。

二、数组遍历测试数据对比

对于普通的数组也可以使用foreach循环,测试代码如下所示:

public class ArrayTest {

    private static final int SIZE = 50000000;
    private static final int TIMES = 20;

    public static void main(String[] args) {
        String[] list = initArray();
        long time = System.currentTimeMillis();
        for (int i = 0; i < TIMES; i++) {
           testArrayForeach(list);
           // testArrayFor(list);
        }

        System.out.println("Array used time: " + ((System.currentTimeMillis() - time) / TIMES));
    }

    /**
     * 初始化数据
     * @return 返回初始化数据
     */
    private static String[] initArray() {
        String[] list = new String[SIZE];
        for (int i = 0; i < SIZE; i++) {
            list[i] = String.valueOf(i);
        }

        return list;
    }

    /**
     * 测试foreach循环数组的性能
     * @param list 数组数据
     * @return 返回执行的时间
     */
    private static long testArrayForeach(String[] list) {
        long sum = 0L;
        for (String s : list) {
            sum += s.length();
        }

        return sum;
    }

    /**
     * 测试普通for循环数组的性能
     * @param list 数组数据
     * @return 返回执行的时间
     */
    private static long testArrayFor(String[] list) {
        long sum = 0L;
        for (int i = 0; i < list.length; i++) {
            sum += list[i].length();
        }

        return sum;
    }

}

测试两种遍历方式输出的时间分别是:

testArrayForeach(): Array used time: 152
testArrayFor(): Array used time: 150

一样区分不了伯仲。

三、从字节码看foreach循环

从上面的测试的数据来看,集合的foreach循环和迭代器循环耗时基本一致,没有很大差异。同样,数组的foreach循环和普通循环也没有很大的差异。接下来看下编译后的代码来进行对比,因最终都是编译成字节码交给虚拟机运行,所以看编译后的结果最直接,看看foreach循环的代码有什么不同。

下面就以 smali
格式来查看字节码,因为 smali
这种方式跟java语法类似,感觉比不停的出栈、入栈要容易理解。

查看的方法是下载 jadx
工具,直接将class文件拖入到打开的窗口中,在右边的窗口中的左下角有一个 代码
smali
切换的Tab,点击 smali
就可以看到smali格式的代码。

3.1 LinkedList测试代码的字节码

下面只贴出核心部分的代码,想看完整的代码,可以自己动手试下。

.method private static testLinkedListForeach(Ljava/util/LinkedList;)J
    // 头部省略
    .prologue
    .line 56
    .local p0, "list":Ljava/util/LinkedList;, "Ljava/util/LinkedList<Ljava/lang/String;>;"
    const-wide/16 v2, 0x0

    .line 57
    .local v2, "sum":J
    invoke-virtual {p0}, Ljava/util/LinkedList;->iterator()Ljava/util/Iterator;

    move-result-object v1

    :goto_6
    invoke-interface {v1}, Ljava/util/Iterator;->hasNext()Z

    move-result v4

    if-eqz v4, :cond_19

    invoke-interface {v1}, Ljava/util/Iterator;->next()Ljava/lang/Object;

    move-result-object v0

    check-cast v0, Ljava/lang/String;

    .line 58
    .local v0, "s":Ljava/lang/String;
    invoke-virtual {v0}, Ljava/lang/String;->length()I

    move-result v4

    int-to-long v4, v4

    add-long/2addr v2, v4

    .line 59
    goto :goto_6

    .line 61
    .end local v0    # "s":Ljava/lang/String;
    :cond_19
    return-wide v2
.end method

.method private static testLinkedListIterator(Ljava/util/LinkedList;)J
    // 头部省略
    .prologue
    .line 41 // 对应java代码的行号
    .local p0, "list":Ljava/util/LinkedList;, "Ljava/util/LinkedList<Ljava/lang/String;>;" // p0对应代码中的list参数
    const-wide/16 v2, 0x0 // v2对应代码中的 sum变量

    .line 42
    .local v2, "sum":J
    invoke-virtual {p0}, Ljava/util/LinkedList;->iterator()Ljava/util/Iterator;

    move-result-object v0 // 这里是迭代器变量,上面一行代码执行LinkedList的iterator()方法的返回值

    .line 43
    .local v0, "it":Ljava/util/Iterator;, "Ljava/util/Iterator<Ljava/lang/String;>;"
    :goto_6 // 这里是标记循环开始的位置
    invoke-interface {v0}, Ljava/util/Iterator;->hasNext()Z

    move-result v1 // 将上一行代码中hasNext() boolean结果保存到v1变量中

    if-eqz v1, :cond_19 // 判断v1的值是否为true,如果不为true,则跳转到:cond_19标记的位置,即下面代码的return位置,即退出整个方法

    .line 44
    invoke-interface {v0}, Ljava/util/Iterator;->next()Ljava/lang/Object;

    move-result-object v1 // 取next()方法的结果,保存到v1变量中

    check-cast v1, Ljava/lang/String;

    invoke-virtual {v1}, Ljava/lang/String;->length()I

    move-result v1 // 将字符串的长度赋值到v1变量中,这里有点类似python语法,可以理解成,所有的变量都是object,不同类型的变量之间都可以赋值。v1变量之前的值已经不需要了,所以在这里会被重新覆盖成新值

    int-to-long v4, v1 // 将v1值转换成long值,并保存到v4变量中

    add-long/2addr v2, v4 // 将v2和v4的值相加,并保存到v2中,这里的v2在上面对应的sum变量

    goto :goto_6 // 跳转到循环开始的位置

    .line 47
    :cond_19
    return-wide v2
.end method

对比上面两个方法的 smali
代码,发现foreach循环最终编译成迭代器循环的代码。这就解释了为什么两种循环方式测试的消耗时间基本一致。其实也可以通过 class
字节码工具转换成 java
代码就可以看到,原来的foreach循环没有了,换成了迭代器循环。

3.2 ArrayList测试代码的字节码

ArrayList的迭代器遍历和foreach遍历的smali代码与上面LinkedList循环部分的代码基本一致,下面只贴出普通for循环部分的代码:

.method private static testArrayListFor(Ljava/util/ArrayList;)J
    .registers 7
    .annotation system Ldalvik/annotation/Signature;
        value = {
            "(",
            "Ljava/util/ArrayList",
            "<",
            "Ljava/lang/String;",
            ">;)J"
        }
    .end annotation

    .prologue
    .line 72
    .local p0, "list":Ljava/util/ArrayList;, "Ljava/util/ArrayList<Ljava/lang/String;>;"
    const-wide/16 v2, 0x0

    .line 73
    .local v2, "sum":J
    const/4 v0, 0x0 // v0是循环下标i

    .local v0, "i":I
    :goto_3
    invoke-virtual {p0}, Ljava/util/ArrayList;->size()I // size大小

    move-result v1

    if-ge v0, v1, :cond_18 // 如果v1大于v0,则跳转到:cond_18标记的位置,即return位置

    .line 74
    invoke-virtual {p0, v0}, Ljava/util/ArrayList;->get(I)Ljava/lang/Object; // 调用p0的get方法,参数值是v0

    move-result-object v1

    check-cast v1, Ljava/lang/String;

    invoke-virtual {v1}, Ljava/lang/String;->length()I

    move-result v1

    int-to-long v4, v1

    add-long/2addr v2, v4

    .line 73
    add-int/lit8 v0, v0, 0x1 // v0值加1,并保存到v0中

    goto :goto_3 // 跳转到:goto_3位置,重新开始循环

    .line 77
    :cond_18
    return-wide v2
.end method

通过上面的代码发现,普通for循环遍历,并没有使用迭代器的方式进行遍历。

3.3 数组测试代码的字节码

对于数组的遍历,两种方式的smali代码基本一致。也就是说foreach循环的代码编译成了普通的 for i循环
。代码如下所示:

.method private static testArrayFor([Ljava/lang/String;)J
    .registers 7
    .param p0, "list"    # [Ljava/lang/String;

    .prologue
    .line 52
    const-wide/16 v2, 0x0

    .line 53
    .local v2, "sum":J
    const/4 v0, 0x0

    .local v0, "i":I
    :goto_3
    array-length v1, p0

    if-ge v0, v1, :cond_11

    .line 54
    aget-object v1, p0, v0

    invoke-virtual {v1}, Ljava/lang/String;->length()I

    move-result v1

    int-to-long v4, v1

    add-long/2addr v2, v4

    .line 53
    add-int/lit8 v0, v0, 0x1

    goto :goto_3

    .line 57
    :cond_11
    return-wide v2
.end method

.method private static testArrayForeach([Ljava/lang/String;)J
    .registers 9
    .param p0, "list"    # [Ljava/lang/String;

    .prologue
    .line 38
    const-wide/16 v2, 0x0

    .line 39
    .local v2, "sum":J
    array-length v4, p0 // 取p0数组的长度,保存到v4变量中

    const/4 v1, 0x0 // v1是下标

    :goto_4
    if-ge v1, v4, :cond_11

    aget-object v0, p0, v1 // 取p0的v1位置的值,并保存到v0变量中

    .line 40
    .local v0, "s":Ljava/lang/String;
    invoke-virtual {v0}, Ljava/lang/String;->length()I

    move-result v5

    int-to-long v6, v5

    add-long/2addr v2, v6

    .line 39
    add-int/lit8 v1, v1, 0x1

    goto :goto_4

    .line 43
    .end local v0    # "s":Ljava/lang/String;
    :cond_11
    return-wide v2
.end method

四、总结

通过上面的代码对比分析发现:

  • 1.对于集合中的类,使用foreach循环遍历时,使用的是对应迭代器进行遍历;
  • 2.对于数组的foreach遍历,最终会被转换成普通的for循环。

既然如此,使用foreach循环的好处也体现出来了。编译器会自动将集合转换成迭代器进行遍历,省去了手写迭代器循环的麻烦,简单明了。数组遍历同样也是简化代码,所以如果不需要对集合数组中的元素进行修改,建议优先使用foreach循环,避免犯一些低级问题(如,使用普通 for i循环
来遍历LinkedList,从而导致性能低下)。

原文 

http://www.jacpy.com/2020/06/20/analyze-java-foreach-by-bytecode.html

本站部分文章源于互联网,本着传播知识、有益学习和研究的目的进行的转载,为网友免费提供。如有著作权人或出版方提出异议,本站将立即删除。如果您对文章转载有任何疑问请告之我们,以便我们及时纠正。

PS:推荐一个微信公众号: askHarries 或者qq群:474807195,里面会分享一些资深架构师录制的视频录像:有Spring,MyBatis,Netty源码分析,高并发、高性能、分布式、微服务架构的原理,JVM性能优化这些成为架构师必备的知识体系。还能领取免费的学习资源,目前受益良多

转载请注明原文出处:Harries Blog™ » 通过java字节码分析java foreach循环

赞 (0)
分享到:更多 ()

评论 0

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址