Java常见的12个语法糖

最新推荐文章于 2025-10-24 19:54:10 发布
原创 最新推荐文章于 2025-10-24 19:54:10 发布 · 2.3k 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#语法糖 #反编译

本文深入探讨Java中的语法糖特性，包括switch表达式的内部实现、forEach循环的编译原理、lambda表达式的编译过程、if语句的编译优化、枚举类型的编译表现、try-with-resources语句的实现机制、断言的编译形式、变长参数的编译转换、自动装箱拆箱的过程及泛型的实际应用。

一定一定要向前看

之前在学习Java基础的时候，零零碎碎地看了一些语法糖相关，今天记录下来

switch

  • switch

  • 原始代码

    public class tesst{
    public static void main(String[] args) {
        String string = "world";
        switch (string){
            case "hello":
                System.out.println(string);
                break;
            case "world":
                System.out.println(string);
                break;
            default:
                break;
        }
    }
}

  • 编译后的代码

    public class tesst {
    public static void main(String[] args) {
        String string;
        String string2 = string = "world";
        int n = -1;
        switch (string2.hashCode()) {
            case 99162322: {
                if (!string2.equals("hello")) break;
                n = 0;
                break;
            }
            case 113318802: {
                if (!string2.equals("world")) break;
                n = 1;
            }
        }
        switch (n) {
            case 0: {
                System.out.println(string);
                break;
            }
            case 1: {
                System.out.println(string);
                break;
            }
        }
    }
}

  • 这样我们可以看出来，字符串需要先进行hash，然后为了防止hash碰撞，又加了equals

  • 之前阿里妹在公众号上发了五道题，其中有一个是这样的：

    public class SwitchTest {
    public static void main(String[] args) {
        String param = null;
        switch (param) {
            case "null":
                System.out.println("null");
                break;
            default:
                System.out.println("default");
        }
    }
}

    这个题有三种选项，一种是输出null，一种是走default，最后一种是报错。

    通过语法糖我们可以发现，switch中比较的是hashCode的值，而null.hashCode()自然会爆出空指针异常

forEach

  • 原来的代码

    public class ForEach {
    public static void main(String[] args) {
        String[] s = {"fxxk","suger","fxxk","java"};
        for (String s1 : s) {
            System.out.println(s1);
        }
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            list.add(i);
        }
        for (Integer integer : list) {
            System.out.println(integer);
        }
    }
}

  • 编译后的代码

    public class ForEach{
    public ForEach(){
    }

    public static void main(String args[]){
        String s[] = {
            "fxxk", "suger", "fxxk", "java"
        };
        String args1[] = s;
        int j = args1.length;
        for(int k = 0; k < j; k++){
            String s1 = args1[k];
            System.out.println(s1);
        }

        List list = new ArrayList();
        for(int i = 0; i < 10; i++)
            list.add(Integer.valueOf(i));

        Integer integer;
        for(Iterator iterator = list.iterator(); iterator.hasNext(); System.out.println(integer))
            
            integer = (Integer)iterator.next();
    }
}

  • 可见，通过集合类是通过迭代器来实现了增强for循环，String通过普通的for循环来增强for循环。同时，因为其用了迭代器，我们需要注意，在foreach的时候只能遍历，不能修改。否则会爆出java.util.ConcurrentModificationException异常

lambda

  • lambda

  • 原始代码

    import java.util.ArrayList;
import java.util.List;
public class Lambda {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            list.add(i);
        }
        list.forEach(System.out::println);
    }
}

  • 编译后代码

    import java.io.PrintStream;
import java.lang.invoke.LambdaMetafactory;
import java.util.ArrayList;
import java.util.function.Consumer;

public class Lambda {
    public static void main(String[] arrstring) {
        ArrayList<Integer> arrayList = new ArrayList<Integer>();
        for (int i = 0; i < 10; ++i) {
            arrayList.add(i);
        }
        
        PrintStream printStream = System.out;
        printStream.getClass();
        
        arrayList.forEach(
            (Consumer<Integer>)LambdaMetafactory.metafactory(null, null, null, (Ljava/lang/Object;)V, println(java.lang.Object ), (Ljava/lang/Integer;)V)((PrintStream)printStream));
    }

}

  • 我们可以看出lambda和内部类的不同之处，内部类是生成了多个类文件，而lambda则是在一个类文件中，最多生成多个方法而已

if

  • 原始文件

        public static void main(String[] args) {
        if (true){
            System.out.println("true");
        }else{
            System.out.println("false");
        }
        if (false){
            System.out.println("false");
        }else{
            System.out.println(false);
        }

    }

  • 编译过的文件

        public static void main(String args[])
    {
        System.out.println("true");
        System.out.println(false);
    }

enum

  • 原始文件

    public enum EnumClass {
    SPRING,SUMMER,FALL,WINTER;
}

  • 编译文件

    public final class EnumClass extends Enum
{

    public static EnumClass[] values()
    {
        return (EnumClass[])$VALUES.clone();
    }

    public static EnumClass valueOf(String name)
    {
        return (EnumClass)Enum.valueOf(suger/EnumClass, name);
    }

    private EnumClass(String s, int i)
    {
        super(s, i);
    }

    public static final EnumClass SPRING;
    public static final EnumClass SUMMER;
    public static final EnumClass FALL;
    public static final EnumClass WINTER;
    private static final EnumClass $VALUES[];

    static 
    {
        SPRING = new EnumClass("SPRING", 0);
        SUMMER = new EnumClass("SUMMER", 1);
        FALL = new EnumClass("FALL", 2);
        WINTER = new EnumClass("WINTER", 3);
        $VALUES = (new EnumClass[] {
            SPRING, SUMMER, FALL, WINTER
        });
    }
}

    public static final Enum SPRING;
    public static final Enum SUMMER;
    public static final Enum FALL;
    public static final Enum WINTER;
    private static final Enum $VALUES[];

    static 
    {
        SPRING = new Enum("SPRING", 0);
        SUMMER = new Enum("SUMMER", 1);
        FALL = new Enum("FALL", 2);
        WINTER = new Enum("WINTER", 3);
        $VALUES = (new Enum[] {
            SPRING, SUMMER, FALL, WINTER
        });
    }
}

  • 我们可以看出，枚举是继承了Enum类的，同时他也是final，即不可继承的。

tryWithResource

  • 源代码

    public class TryWith {
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new                   FileReader("d:\\TryWith.jad"))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

  • 编译后的代码

    public class TryWith
{
    public TryWith()
    {
    }
    public static void main(String args[])
    {
        try
        {
            BufferedReader br = new BufferedReader(new FileReader("d:TryWith.jad"));
            String line;
            try
            {
                while((line = br.readLine()) != null) 
                    System.out.println(line);
            }
            catch(Throwable throwable)
            {
                try
                {
                    br.close();
                }
                catch(Throwable throwable1)
                {
                    throwable.addSuppressed(throwable1);
                }
                throw throwable;
            }
            br.close();
        }
        catch(IOException e)
        {
            e.printStackTrace();
        }
    }
}

  • 我们可以看到，是编译器帮我们把资源关闭了

assert

  • 原始代码

    public class Assert {
    public static void main(String[] args) {
        int a = 1;
        assert a > 0;
        System.out.println(a);
    }
}

  • 编译代码

    public class Assert
{

    public Assert()
    {
    }

    public static void main(String args[])
    {
        int a = 1;
        if(!$assertionsDisabled && a <= 0)
        {
            throw new AssertionError();
        } else
        {
            System.out.println(a);
            return;
        }
    }

    static final boolean $assertionsDisabled = !suger/Assert.desiredAssertionStatus();

}

  • 我们可以看到，断言通过if语句来执行

变长参数

  • 原始代码

    public class Long {
    public static void main(String... args) {
        String[] zi = {"i","am","zi","10ng"};
        ma(zi);
    }

    private static void ma(String... args) {
        for (String arg : args) {
            System.out.println(arg);
        }
    }
}

  • 编译之后

    public class Long{
    public Long(){
    }

    public static transient void main(String args[]){
        String zi[] = {"i", "am", "zi", "10ng"};
        ma(zi);
    }

    private static transient void ma(String args[]){
        String as[] = args;
        int i = as.length;
        for(int j = 0; j < i; j++){
            String arg = as[j];
            System.out.println(arg);
        }
    }

自动装拆箱

  • 自动装拆箱

  • 原始代码

        public static void main(String[] args) {
        int a = 1;
        Integer b;
        b  = a;
        a = b;
    }

  • 编译之后

        public static void main(String args[])
    {
        int a = 1;
        Integer b = Integer.valueOf(a);
        a = b.intValue();
    }

  • 同时我们需要知道，在JDK5之后，Integer的操作中引入了一个新功能来节省内存和提高性能。即，整型对象通过使用相同的对象引用实现了缓存和重用。适用于整数值区间-128 至 +127。

泛型

  • 泛型

  • 源代码

    public class Generic extends Pair<String>{
    private String first;
    @Override
    public void setFirst(String first) {
        this.first = first;
    }
}
class Pair<T>{
    private T first;
    private T second;

    Pair() {
    }
    public Pair(T first, T second) {
        this.first = first;
        this.second = second;
    }
    public T getFirst() {
        return first;
    }
    public void setFirst(T first) {
        this.first = first;
    }
    public T getSecond() {
        return second;
    }
    public void setSecond(T second) {
        this.second = second;
    }
}

  • 编译后的代码

    public class Generic extends Pair{
    private String first;
	public Generic()    {
    }
    public void setFirst(String first)    {
        this.first = first;
    }
    public volatile void setFirst(Object obj)   {
        setFirst((String)obj);
    }
    public volatile void setSecond(Object obj)    {
        super.setSecond(obj);
    }
    public volatile Object getSecond()    {
        return super.getSecond();
    }
    public volatile Object getFirst()    {
        return super.getFirst();
    }
}
class Pair{
    Pair(){
    }
    public Pair(Object first, Object second)    {
        this.first = first;
        this.second = second;
    }
    public Object getFirst()    {
        return first;
    }
    public void setFirst(Object first)    {
        this.first = first;
    }
    public Object getSecond()    {
        return second;
    }
    public void setSecond(Object second)   {
        this.second = second;
    }
    private Object first;
    private Object second;
}

  • 注意此处继承之后的桥接方法

  • 同时，我们需要知道因为类型擦除而出现的错误，详见泛型

内部类

多态

  • 多态

  • 原始代码

    class GrandFather{
    private int a;
    GrandFather() {
        a = 10;
    }
    public GrandFather method() {
        System.out.println("--------调用GrandFather method()方法");
        return new GrandFather();
    }
}
//父类
class Father extends GrandFather {
    private int b;
    Father() {
        b = 20;
    }
    @Override
    public Father method() {
        System.out.println("--------调用Father method()方法");
        return new Father();
    }
}

  • 编译器编译过后的Father类：

    class Father extends GrandFather
{
	private int b;
    Father(){
        b = 20;
    }
    public Father method(){
        System.out.println("--------\u8C03\u7528Father method()\u65B9\u6CD5");
        return new Father();
    }
    public volatile GrandFather method(){
        return method();
    }
}
Java基础---常见的语法糖
汤键的博客
07-06 1546
Java基础---常见的语法糖
谈一谈JAVA里有哪些语法糖
重口味码农
09-24 1474
谈一谈JAVA里的语法糖 上周在听大牛分享JVM编译优化时，提到了在编译阶段会进行的一个步骤：解语法糖。他提出了一个问题是：JAVA里有哪些语法糖，听到这个问题，似乎很容易回答，因为我们都知道java有很多语法糖，但话到嘴边，也就只能想起字符串拼接和foreach来，果然，没有经过系统的梳理，一些听起来简单的知识点也会难倒你，所以我来梳理一下，看java里到底有哪些语法糖。 概述 在搜狗百科中，语...
Java 语法糖详解（含底层原理）
最新发布
回忆在这里记录着
10-24 1090
本文系统梳理Java语法糖的相关知识，旨在帮助回顾整理并为学习者提供参考。语法糖（Syntactic Sugar）是一种简化代码书写、提升开发效率的语法表达方式，其核心特征是不改变语言功能，仅是简化书写形式，编译后会转换为底层基础语法。关键特性包括：不引入新功能、编译时处理，最终生成的字节码与基础语法代码等效，JVM执行的是解语法糖后的字节码。作者希望通过解析语法糖到基础语法的转换过程，深入理解其底层实现原理。
常见的语法糖
m0_46667398的博客
06-13 759
title: 语法糖 date: 2022-06-02 23:52:37 categories:Java常见的12个语法糖语法糖（Syntactic sugar），也译为糖衣语法，是由英国计算机科学家彼得·兰 丁发明的一个术语，指计算机语言中添加的某种语法，这种语法对语言的功能没有影响，但 是更方便程序员使用。语法糖让程序更加简洁，有更高的可读性语法糖往往给程序员提供了更实用的编码方式，有益于更好的编码风格，更易读。不过其并没有给语言添加什么新东西。需要声明的是“语法糖”这个词绝非贬义词，它可以给我带来方便
谈谈Java中的语法糖
热门推荐
小楼一夜听春雨
02-11 2万+
语法糖（Syntactic Sugar），也称糖衣语法，指在计算机语言中添加的某种语法，这种语法对语言本身功能来说没有什么影响，只是为了方便程序员的开发，提高开发效率。说白了，语法糖就是对现有语法的一个封装。
Java语法糖3：泛型
weixin_33936401的博客
10-13 145
泛型初探 在泛型（Generic type或Generics）出现之前，是这么写代码的： public static void main(String[] args) { List list = new ArrayList(); list.add("123"); list.add("456"); System.out.println((...
Java 语法糖详解：常见语法糖的原理与示例
兀行者的博客
02-13 1067
在 Java 的发展过程中，为了提升开发者的编码效率和代码的可读性，Java 引入了许多“语法糖”（Syntactic Sugar）。语法糖并不是语言的核心功能，但它能够让代码更加简洁、直观，从而提升开发体验。本文将详细介绍 Java 中常见的语法糖，并通过示例帮助你理解它们的作用和使用场景。
Java常见语法糖
工大樱木花道
10-28 694
语法糖定义 语法糖（英语：Syntactic sugar）是由英国计算机科学家彼得·兰丁发明的一个术语，指计算机语言中添加的某种语法，这种语法对语言的功能没有影响，但是更方便程序员使用。语法糖让程序更加简洁，有更高的可读性。 语法糖是啥？语法糖没有一个官方的定义（或者说定义相当宽泛），更像是一种观念：任何让你写着爽、但是实际发生的和你看到的不一样的东西都可以“被认为”是语法糖。例如最常见的Integer和int的自动装拆箱操作背后就是语法糖。看上去你在写。 Java中很常见的Foreach就属于语法糖的一个
Java 常用语法糖及其对比总结
Bruce__taotao的博客
10-11 1001
Java 中的语法糖使代码更简洁、更易读，同时在某些情况下提高开发效率和运行性能。下面列举了 50 个常用的语法糖，每条语法糖都详细比较了使用和不使用的代码，并解释了其优势。通过这些常用语法糖，Java 代码得到了极大的简化和优化，既提升了代码的可读性，也提高了开发效率。在实际开发中，合理使用这些语法糖可以有效减少样板代码，提升代码质量。
深入理解Java常用语法糖
大唐雨夜的博客
12-08 3795
语法糖的存在主要是方便开发人员使用，使程序更加简洁，提高程序可读性。Java虚拟机并不支持这些语法糖，这些语法糖在编译阶段就会被还原成简单的基础语法结构，这个过程就是解语法糖。
Java语法糖
zhaohong_bo的专栏
04-10 335
先Mark，需要后续补齐、 参考： https://www.cnblogs.com/qingshanli/p/9375040.html
Java编程常见的语法糖有哪些？
IT_studied的博客
08-11 286
　　语法糖，是由英国计算机科学家彼得·约翰·兰达(Peter J. Landin)发明的一个术语，简单来说就是对现有语法的一个封装。使用语法糖能够增加程序的可读性，减少程序代码出错的机会。作为一种与平台无关的高级编程语言，Java中也含有语法糖，这些语法糖并不被虚拟机所支持，在编译成字节码阶段会自动转换成简单常用的语法。下面就给大家介绍几个常见的语法糖。 　　一般来说Java中的语法糖主要有四种： 　　泛型与类型擦除 　　一个编译器处理泛型有两种方式：Code specializatio..
Java 中12个常见的语法糖
weixin_51393513的博客
12-10 1337
本文从Java编译原理角度，深入字节码及class文件，抽丝剥茧，了解Java中的语法糖原理及用法，帮助大家在学会如何使用Java语法糖的同时，了解这些语法糖背后的原理。 语法糖 语法糖(Syntactic Sugar)也称糖衣语法，是由英国计算机学家 Peter.J.Landin 发明的一个术语，指在计算机语言中添加的某种语法，这种语法对语言的功能并没有影响，但是更方便程序员使用。简而言之，语法糖让程序更加简洁，有更高的可读性。 有意思的是，在编程领域，除了语法糖，还有语法盐和语法...
Java的语法糖
孙平平的博客
08-31 2218
Java的语法糖 语法糖 语法糖（Syntactic sugar），也译为糖衣语法，是由英国计算机科学家彼得·约翰·兰达（Peter J. Landin）发明的一个术语，指计算机语言中添加的某种语法，这种语法对语言的功能并没有影响，但是更方便程序员使用。通常来说使用语法糖能够增加程序的可读性，从而减少程序代码出错的机会。 解语法糖 Java中最常用的语法糖主要是泛型、变长数组、自动...
Java中的语法糖
weixin_45775259的博客
11-08 345
在进行今天的分享之前，首先让我们先了解一些概念。 编译器是一种计算机程序, 它主要的目的，就是把方便人们编写、阅读以及维护的高级计算机语言所写的源代码程序翻译成计算机可以解读和运行的低阶机器语言的程序, 即可执行文件。 而Java语言中的编译器就是javac, 它用于将 .java 文件转换成JVM可以进行识别的 .class 字节码文件, 反编译则是将 .class 文件转换成 .java 文件。 语法糖（Syntactic sugar），也译为糖衣语法，是由英国计算机科学家彼得·兰丁发明的一个术语，是指
浅析java常见语法糖
默默草
07-09 575
a
java中的语法糖
topdeveloperr的博客
03-22 1821
Table of Contents 概述 语法糖：泛型与类型擦出 泛型和重载 自动装箱，自动拆箱，与遍历循环 条件编译 概述 在博客java重要基础知识汇总中，我们提到了内部类是一种java的语法糖。事实上java除了内部类还提供了另外一些语法糖，用于方便程序员的代码开发。但是值得注意的是，语法糖对代码不会带来任何实质性的功能上的变化。他仅仅是编译器做的一些'把戏'.语法糖在各种编程...
JAVA中常见的语法糖？
07-30
<think>我们被要求回答关于Java中常见的语法糖及其用法的问题。根据引用内容，我们可以整理出以下常见的Java语法糖： 1. **自动装箱与拆箱**：基本数据类型和其包装类之间的自动转换。 2. **增强型for循环**：简化集合和数组的遍历。 3. **泛型**：在编译时提供类型安全检查，但会被类型擦除。 4. **可变参数**：允许方法接受不定数量的参数。 5. **try-with-resources**：自动关闭资源，无需显式调用close()。 6. **Lambda表达式**：简化函数式接口的实现。 7. **方法引用**：进一步简化Lambda表达式，直接引用已有方法。 8. **字符串连接**：使用`+`连接字符串，编译器优化为StringBuilder。 9. **Switch表达式**：支持字符串、枚举等，以及新的箭头语法和返回值。 10. **类型推断**（如钻石操作符`<>`）：在泛型实例化时省略类型参数。 11. **Optional类**：优雅处理null值。 12. **Stream API**：函数式风格处理数据集合。 13. **接口私有方法**：在接口中定义私有方法，减少重复代码。 14. **局部变量类型推断**（var）：根据初始化值推断局部变量类型。 15. **模块化系统**（Java 9）：模块化打包和管理。 16. **文本块**（Java 15）：多行字符串字面量。 17. **记录类**（Records）：不可变数据的透明载体。 18. **密封类**（Sealed Classes）：限制哪些类可以继承。 我们将逐一解释这些语法糖，并给出示例。注意，语法糖在编译时会被解糖，转换成更基础的Java代码。 下面开始详细说明：</think>### Java 常见语法糖详解 语法糖是 Java 为开发者提供的便捷语法，通过编译器解糖（desugar）转换为 JVM 可执行的基础代码。以下是 Java 核心语法糖及其实现原理： #### 一、基础语法糖 1. **自动装箱与拆箱** - **原理**：编译器自动插入 `Integer.valueOf()` 和 `intValue()` 调用 - **示例**： ```java Integer a = 10; // 解糖后: Integer a = Integer.valueOf(10); int b = a; // 解糖后: int b = a.intValue(); ``` 2. **增强 for 循环** - **原理**：转换为迭代器或传统 for 循环 - **示例**： ```java for (String s : list) { ... } // 解糖后: for (Iterator<String> it = list.iterator(); it.hasNext(); ) { String s = it.next(); ... } ``` 3. **泛型类型擦除** - **原理**：编译后类型信息被擦除，插入强制类型转换 - **示例**： ```java List<String> list = new ArrayList<>(); // 解糖后: List list = new ArrayList(); String s = list.get(0); // 解糖后: String s = (String) list.get(0); ``` #### 二、现代语法糖（Java 8+） 4. **Lambda 表达式** - **原理**：转换为函数式接口的实现类 - **示例**： ```java list.forEach(s -> System.out.println(s)); // 解糖后: list.forEach(new Consumer<String>() { public void accept(String s) { System.out.println(s); } }); ``` 5. **方法引用** - **原理**：Lambda 的简写形式 - **示例**： ```java list.forEach(System.out::println); // 等价于: list.forEach(s -> System.out.println(s)); ``` 6. **try-with-resources** - **原理**：自动生成 `finally` 块关闭资源 - **示例**： ```java try (FileInputStream fis = new FileInputStream("file.txt")) { // ... } // 解糖后添加 finally { fis.close() } 和异常处理 ``` #### 三、最新语法糖（Java 14+） 7. **Switch 表达式** - **特性**：支持返回值、箭头语法、模式匹配 - **示例**： ```java String dayType = switch (day) { case 1, 7 -> "Weekend"; // 多值匹配 default -> { if (day > 5) yield "Invalid"; else yield "Weekday"; // yield 返回值 } }; ``` 8. **记录类（Records）** - **原理**：自动生成 `equals()`、`hashCode()`、`toString()` - **示例**： ```java record Point(int x, int y) {} // 等价于 final class 包含私有 final 字段 ``` 9. **文本块（Text Blocks）** - **特性**：保留多行字符串格式 - **示例**： ```java String json = """ { "name": "John", "age": 30 } """; ``` #### 四、使用注意事项 1. **性能陷阱** - 循环内的自动装箱会导致大量对象创建：`for (Integer i = 0; i < 10000; i++)` - 字符串拼接用 `+` 在循环中会生成多个 `StringBuilder` 对象 2. **类型擦除限制** - 泛型无法用于运行时类型检查：`if (obj instanceof List<String>)` 编译报错 3. **Lambda 作用域** - Lambda 内访问的局部变量必须是 final 或等效 final > 📌 **最佳实践**：语法糖提升开发效率，但需理解其底层实现以避免性能陷阱和类型错误[^1][^3][^4]。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值