Java字节码这么有趣？

最新推荐文章于 2025-05-03 10:56:02 发布

若云_bai

最新推荐文章于 2025-05-03 10:56:02 发布

阅读量258

点赞数

分类专栏：深入java 文章标签： java class jvm

本文链接：https://blog.youkuaiyun.com/zxloveooo/article/details/104921043

版权

深入java 专栏收录该内容

2 篇文章

订阅专栏

本文探讨Java字节码的趣味性，通过分析switch语句和Lambda表达式的字节码，揭示其内部工作原理。从字符串switch的hashCode判断到Lambda表达式的动态代理，了解两种语法在编译和运行时的区别，以及它们对代码体积和执行效率的影响。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

java中的字节码，如果你之前没有接触过，那么可能会感觉比较难。

我们先来看几个在开发中都会用到的例子，来增加学习的趣味性。

1. 例子

1.1 switch

我们在开发中经常用会用到switch来判断条件，那么判断字符串是不是像代码写的那么简单呢？是不是直接case 到就可以执行内部的代码呢？让我们来看看它内部的秘密。

public class SwitchClass {

    public static void choose(String str) {
        switch (str) {
            case "hello":
                System.out.println("1");
                break;
            case "one":
                System.out.println("2");
                break;
            default:
                System.out.println("3");
                break;
        }
    }

    public static void main(String[] args) {
        choose("hello");
    }
}

通过javap -c SwitchClass.class反编译，生成的字节码如下，从字节码中我们可以看到，字符串的判断是通过hashCode 来判断的，但是hashCode并不是唯一值，很多字符串生成的Code 是相同的。

我们接下来看字节码，42行发现有一个指令ifeq ，它其实就是if (str.equals(""))

继续往下看发现62行还有一个switch，其实它就是用来具体执行case中写的代码的。

 public static void choose(java.lang.String);
    Code:
       0: aload_0
       1: astore_1
       2: iconst_m1
       3: istore_2
       4: aload_1
       5: invokevirtual #7                  // Method java/lang/String.hashCode:()I
       8: lookupswitch  { // 2
                110182: 50
              99162322: 36
               default: 61
          }
      36: aload_1
      37: ldc           #13                 // String hello
      39: invokevirtual #15                 // Method java/lang/String.equals:(Ljava/lang/Object;)Z
      42: ifeq          61
      45: iconst_0
      46: istore_2
      47: goto          61
      50: aload_1
      51: ldc           #19                 // String one
      53: invokevirtual #15                 // Method java/lang/String.equals:(Ljava/lang/Object;)Z
      56: ifeq          61
      59: iconst_1
      60: istore_2
      61: iload_2
      62: lookupswitch  { // 2
                     0: 88
                     1: 99
               default: 110
          }
      88: getstatic     #21                 // Field java/lang/System.out:Ljava/io/PrintStream;
      91: ldc           #27                 // String 1
      93: invokevirtual #29                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      96: goto          118
      99: getstatic     #21                 // Field java/lang/System.out:Ljava/io/PrintStream;
     102: ldc           #35                 // String 2
     104: invokevirtual #29                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
     107: goto          118
     110: getstatic     #21                 // Field java/lang/System.out:Ljava/io/PrintStream;
     113: ldc           #37                 // String 3
     115: invokevirtual #29                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
     118: return

我们用伪代码来实现一下上面的逻辑。

public class SwitchClass {

    public static void choose(String str) {
        byte x = -1;
        switch (str.hashCode()) {
            case 99162322: // hello 的 hashCode
                if (str.equals("hello")) {
                    x = 0;
                }
                break;
            case 110182: // one 的 hashCode
                if (str.equals("one")) {
                    x = 1;
                }
                break;
            default:
                x = 2;
                break;
        }
        switch (x) {
            case 0:
                System.out.println("1");
                break;
            case 1:
                System.out.println("2");
                break;
            case 2:
                System.out.println("3");
                break;
        }
    }
}

可以看出执行了两边switch ，第一遍时根据字符串的hashCode和equals 将字符串转为相应的byte 类型，第二遍才是利用byte 执行进行比较。

注意：

switch 在配合String 使用的时候，变量不能为null，原因是 null 不能得到具体的hashCode。执行str.hashCode() 会报Exception in thread "main" java.lang.NullPointerException错误。

1.2 Lambda

1.2.1 new 方式

我们在创建Runnable的时候，我们可以在类的方法中直接new一个Runnable对象，然后可以配合Thread来使用，也可以直接调用run()。

public class TestLambda {
    public void testRunnable() {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("run");
            }
        };
        runnable.run();
    }
}

1.2.2 Lambda 方式

在java8的时候，有了新的特性，Lambda表达式，使用的高级版本的开发工具的时候，比如idea ，会有下面的提示，提示用户可以可以用Lambda来替换new Runnable()。

使用Lambda的方式如下：

public class TestLambda {
    public void testRunnable() {
        Runnable runnable = () -> System.out.println("run");
        runnable.run();
    }
}

那么这两种方式在jvm底层的运行过程中有什么不同呢？

1.2.3 反编译 new 方式

javap -c TestLambda反编译，可以发现在new Runnable() 的时候，javac 之后，编译器会创建额外的内部类TestLambda$1，然后new这个类，然后执行run()。

  public void testRunnable();
    Code:
       0: new           #2                  // class vip/ruoyun/lambda/TestLambda$1
       3: dup
       4: aload_0
       5: invokespecial #3                  // Method vip/ruoyun/lambda/TestLambda$1."<init>":(Lvip/ruoyun/lambda/TestLambda;)V
       8: astore_1
       9: aload_1
      10: invokeinterface #4,  1            // InterfaceMethod java/lang/Runnable.run:()V
      15: return

javap -c TestLambda$1反编译内部类，可以看到会把外部的类对象传入this$0，有构造方法和run()方法。

class vip.ruoyun.lambda.TestLambda$1 implements java.lang.Runnable {
  final vip.ruoyun.lambda.TestLambda this$0;

  vip.ruoyun.lambda.TestLambda$1(vip.ruoyun.lambda.TestLambda);
    Code:
       0: aload_0
       1: aload_1
       2: putfield      #1                  // Field this$0:Lvip/ruoyun/lambda/TestLambda;
       5: aload_0
       6: invokespecial #2                  // Method java/lang/Object."<init>":()V
       9: return

  public void run();
    Code:
       0: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc           #4                  // String run
       5: invokevirtual #5                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       8: return
}

可以发现，我们在使用这种方式的时候，编译器会自动生成一个内部类，然后创建这个内部，执行内部类的方法。那么这种方式的底层是通过创建内部类，然后new内部类，然后执行run()。

1.2.4 反编译 Lambda 方式

javap -p -v TestLambda反编译，来看看它的字节码，会发现大有不同，此时不会创建内部类，而是在类中生成一个私有的静态的synthetics（合成）方法，然后执行InvokeDynamic #0:run:()Ljava/lang/Runnable; ，此过程是找到lambda$testLambdaRunnable$0()的方法，然后执行。其实这个方法是在编译的时候自动创建的。

invokedynamic会通过ASM 动态生成Runnable代理类class，加载到内存中，然后创建对象，加载，执行方法，这样执行效率会很慢很多，虽然代码体积少了。

  public void testLambdaRunnable();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=2, args_size=1
         0: invokedynamic #5,  0              // InvokeDynamic #0:run:()Ljava/lang/Runnable;
         5: astore_1
         6: aload_1
         7: invokeinterface #4,  1            // InterfaceMethod java/lang/Runnable.run:()V
        12: return
      LineNumberTable:
        line 16: 0
        line 17: 6
        line 18: 12
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      13     0  this   Lvip/ruoyun/lambda/TestLambda;
            6       7     1 runnable   Ljava/lang/Runnable;

  private static void lambda$testLambdaRunnable$0();
    descriptor: ()V
    flags: ACC_PRIVATE, ACC_STATIC, ACC_SYNTHETIC
    Code:
      stack=2, locals=0, args_size=0
         0: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #7                  // String run
         5: invokevirtual #8                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 16: 0

1.2.5 小结

new方式，在编译时期，生成内部类。
lambda方式，在编译时期，生成私有的静态的synthetics（合成）方法，在运行期通过ASM 动态生成Runnable代理类，然后创建对象，加载，执行方法。

那么Lambda的方式会比new方式生成的代码体积小。但是执行效率会很慢很多。

我们在以后的编写代码的时候，请选用合适的方式。

小结

这篇文章只是字节码的入门，如果想要继续了解，可持续关注~

如果你喜欢我的文章，可以关注我的掘金、公众号、博客、简书或者Github！

简书: https://www.jianshu.com/u/a2591ab8eed2

GitHub: https://github.com/bugyun

Blog: https://ruoyun.vip

掘金: https://juejin.im/user/56cbef3b816dfa0059e330a8/posts

优快云: https://blog.youkuaiyun.com/zxloveooo

欢迎关注微信公众号