Understanding Syntactic Sugar and Its Desugaring in Java

Syntactic sugar, a term coined by computer scientist Peter J. Landin, refers to language constructs that do not add new functionality but make code easier for programmers to write and read, much like everyday abbreviations or slang.

In programming languages, syntactic sugar improves code conciseness, naturalness, efficiency, and reduces errors, while the underlying semantics remain unchanged.

Desugaring is the process of translating these convenient constructs back into more primitive language forms that the runtime can understand. In Java, many syntactic sugars are compiled away by the Java compiler, and the Java Virtual Machine only sees the desugared bytecode.

The Java compiler performs desugaring through a method often named desugar(). Developers can explore how syntactic sugar is implemented by decompiling compiled classes, as demonstrated by the linked article on explaining compilation and decompilation.

Java has accumulated numerous syntactic sugars over its versions, such as enhanced switch statements supporting enums and strings, generics, varargs, autoboxing/unboxing, lambda expressions, try‑with‑resources, and local variable type inference. These features simplify common programming patterns.

One concrete example is the support for switch on String. The source code uses a regular switch statement, but the compiler transforms it into a series of hashCode() and equals() checks. The following code shows the original source:

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

After compilation and decompilation, the code becomes:

public class switchDemoString
{
    public switchDemoString()
    {
    }
    public static void main(String args[])
    {
        String str = "world";
        String s;
        switch((s = str).hashCode())
        {
        default:
            break;
        case 99162322:
            if(s.equals("hello"))
                System.out.println("hello");
            break;
        case 113318802:
            if(s.equals("world"))
                System.out.println("world");
            break;
        }
    }
}

This demonstrates that a switch on a String is implemented by computing the string's hashCode() and then using equals() to verify the actual value, ensuring correct behavior despite the original source using a high‑level construct.

Other forms of syntactic sugar follow similar patterns, and interested readers can study additional examples in the referenced articles.