Java内部类、foreach循环等语法糖javac到底优化了啥(反编译)

内部类（Inner Classes）、匿名内部类（Anonymous Inner Classes）和局部内部类（Local Inner Classes）是常见的语言特性。这些类为开发者提供了灵活的代码组织方式，使代码更加简洁和易读。

语法糖：通俗易懂的就是在原有语法基础上加入花活儿，通过改造编译器使得花活儿代码编译成已有代码，简化了书写，本质上.class里还是那些语法

匿名内部类:

public class OuterClass {
    public OuterClass() {
    }
    public void createAnonymousClass() {
        Runnable var1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("唱");
            }
        };
        Runnable var2 = new Runnable() {
            @Override
            public void run() {
                System.out.println("跳");
            }
        };
        Runnable var3 = new Runnable() {
            @Override
            public void run() {
                System.out.println("rap");
            }
        };
        new Thread(var1).start();
        Thread basketball = new Thread(() -> {
            System.out.println("篮球");
        });

    }
}

上面代码再熟悉不过了，编译后的class结构就如下，我们进行反编译这几个匿名内部类：

class OuterClass$1 implements Runnable {
    OuterClass$1(final OuterClass this$0) {
        this.this$0 = this$0;
    }
    public void run() {
        System.out.println("唱");
    }
}

class OuterClass$2 implements Runnable {
    OuterClass$2(final OuterClass this$0) {
        this.this$0 = this$0;
    }
    public void run() {
        System.out.println("跳");
    }
}

class OuterClass$3 implements Runnable {
    OuterClass$3(final OuterClass this$0) {
        this.this$0 = this$0;
    }
    public void run() {
        System.out.println("rap");
    }
}

内部类：

public class OuterClass {
    public OuterClass() {
    }
    
    public class InnerClass {
        public InnerClass() {
        }

        public void display() {
            System.out.println("内部类");
        }
    }
}

反编译：

public class OuterClass$InnerClass {
    public OuterClass$InnerClass(final OuterClass this$0) {
        this.this$0 = this$0;
    }
    public void display() {
        System.out.println("内部类");
    }
}

 局部内部类：

public class OuterClass {
    public OuterClass() {
    }

 public void createLocalInnerClass() {
        class LocalInnerClass {
            public LocalInnerClass() {
            }

            public void show() {
                System.out.println("局部内部类");
            }
        }
        LocalInnerClass local = new LocalInnerClass();
        local.show();
    }
}

反编译：

class OuterClass$1LocalInnerClass {
    public OuterClass$1LocalInnerClass(final OuterClass this$0) {
        this.this$0 = this$0;
    }
    public void show() {
        System.out.println("局部内部类");
    }
}

 增强for循环：

// 增强的for循环
    public void enhancedForLoop() {
        int[] numbers = {1, 2, 3, 4, 5};
        for (int number : numbers) {
            System.out.println("增强for循环输出: " + number);
        }
    }

编译后： 变成for i循环了

public void enhancedForLoop() {
        int[] numbers = new int[]{1, 2, 3, 4, 5};
        int[] var2 = numbers;
        int var3 = numbers.length;
        for(int var4 = 0; var4 < var3; ++var4) {
            int number = var2[var4];
            System.out.println("增强for循环输出: " + number);
        }
    }

Lambda表达式

public void lambdaExpression() {
        Runnable runnable = () -> System.out.println("使用Lambda表达式运行");
        runnable.run();
    }

反编译后：看着只是套了层括号

public void lambdaExpression() {
        Runnable runnable = () -> {
            System.out.println("使用Lambda表达式运行");
        };
        runnable.run();
    }

自动装箱与拆箱

public void autoBoxing() {
        Integer boxed = Integer.valueOf(1024);
        int unboxed = boxed;
        int a=1000;
        Integer b=a;
    }

反编译后：第一行Integer boxed = 1024;应该是编译器优化了

public void autoBoxing() {
        Integer boxed = 1024;
        int unboxed = boxed;
        int a = 1000;
        Integer b = Integer.valueOf(a);
    }

菱形操作符

public void diamondOperator() {
        Map<String, List<Integer>> map = new HashMap<>();
        map.put("键", Arrays.asList(1, 2, 3));
        System.out.println("菱形操作符输出: " + map);
    }

 反编译后：

public void diamondOperator() {
        Map<String, List<Integer>> map = new HashMap();
        map.put("键", Arrays.asList(1, 2, 3));
        System.out.println("菱形操作符输出: " + map);
    }

try-with-resources:

public void tryWithResources() {
        try (BufferedReader reader = new BufferedReader(new FileReader("test.txt"))) {
            System.out.println("try-with-resources读取文件: " + reader.readLine());
        } catch (IOException e) {
            System.out.println("文件读取失败，错误信息: " + e.getMessage());
        }
    }

public void tryWithResources() {
        try {
            BufferedReader reader = new BufferedReader(new FileReader("test.txt"));
            Throwable var2 = null;
            try {
                System.out.println("try-with-resources读取文件: " + reader.readLine());
            } catch (Throwable var12) {
                var2 = var12;
                throw var12;
            } finally {
                if (reader != null) {
                    if (var2 != null) {
                        try {
                            reader.close();
                        } catch (Throwable var11) {
                            var2.addSuppressed(var11);
                        }
                    } else {
                        reader.close();
                    }
                }
            }
        } catch (IOException var14) {
            IOException e = var14;
            System.out.println("文件读取失败，错误信息: " + e.getMessage());
        }
    }

方法引用:

public void methodReference() {
        List<String> names = Arrays.asList("张三", "李四", "王五");
        System.out.println("方法引用输出:");
        names.forEach(System.out::println); // 方法引用
    }

反编译后：帮你取了

public void methodReference() {
        List<String> names = Arrays.asList("张三", "李四", "王五");
        System.out.println("方法引用输出:");
        PrintStream var10001 = System.out;
        names.forEach(var10001::println);
    }

有迭代器的集合增强for循环

public void iteratorLoop() {
        List<String> names = Arrays.asList("张三", "李四", "王五");
        for (String name : names) {
            System.out.println(name);
        }
    }

反编译后：

public void iteratorLoop() {
        List<String> names = Arrays.asList("张三", "李四", "王五");
        Iterator var2 = names.iterator();
        while(var2.hasNext()) {
            String name = (String)var2.next();
            System.out.println(name);
        }
    }