Constant Folding in JVM: How the Compiler Makes Your Code Faster!

Hello Java developers. Welcome to my new article. Today’s topic is Constant Folding. What is Constant Folding? Constant folding is a crucial optimization technique used by the Java Virtual Machine (JVM) and compiler to enhance performance. It is not only utilized in JVM, but also used in other modern languages’ compilers. This technique eliminates redundant computations by evaluating constant expressions at compile-time rather than runtime. This results in faster execution and reduced bytecode size. For example, consider the following Java code: public class ConstantFoldingExample { public static void main(String[] args) { int x = 5 + 10; System.out.println(x); } } The Java compiler recognizes that 5 + 10 is a constant expression and simplifies it to 15. As a result, the compiled bytecode does not contain an addition operation but directly loads 15 into the variable. Let’s explore the bytecode by using javap command line tool. Execute following lines in your terminal. $ javac ConstantFoldingExample.java $ javap -c ConstantFoldingExample The compiled bytecode might look like following: 0: bipush 15 // Push the constant value 15 onto the stack 2: istore_1 // Store it in variable x 3: getstatic java/lang/System/out Ljava/io/PrintStream; 6: iload_1 // Load x (which is 15) 7: invokevirtual java/io/PrintStream.println (I)V 10: return Does Constant Folding Occur in Only Arithmetic Operations? The short answer is no. It occurs in following cases. Arithmetic Operations (Addition, Subtraction, Multiplication and so on) String Concatenation Boolean We’ve already seen how constant folding occurs in arithmetic operations, let’s see other two. String Concatenation Consider following Java code public class ConstantFoldingWithStrings { public static void main(String... args) { String message = "Hello" + "World"; System.out.println("Message: " + message); } } Do the same actions as you did in arithmetic operation in order to get the bytecode. 0: ldc #7 // String HelloWorld The output is truncated for simplicity. No need to say anything, it is obvious from the result. Boolean Folding Boolean folding might confuse you, but we will see the both possible options ( false and true case ). true case: public class ConstantFoldingWithBooleans { public static void main(String... args) { boolean isBool = 3

Apr 2, 2025 - 06:40

Constant Folding in JVM: How the Compiler Makes Your Code Faster!

Hello Java developers. Welcome to my new article. Today’s topic is Constant Folding.

What is Constant Folding?

Constant folding is a crucial optimization technique used by the Java Virtual Machine (JVM) and compiler to enhance performance. It is not only utilized in JVM, but also used in other modern languages’ compilers.

This technique eliminates redundant computations by evaluating constant expressions at compile-time rather than runtime. This results in faster execution and reduced bytecode size.

For example, consider the following Java code:

public class ConstantFoldingExample {
    public static void main(String[] args) {
        int x = 5 + 10;
        System.out.println(x);
    }
}

The Java compiler recognizes that 5 + 10 is a constant expression and simplifies it to 15. As a result, the compiled bytecode does not contain an addition operation but directly loads 15 into the variable.

Let’s explore the bytecode by using javap command line tool. Execute following lines in your terminal.

$ javac ConstantFoldingExample.java
$ javap -c ConstantFoldingExample

The compiled bytecode might look like following:

 0: bipush 15  // Push the constant value 15 onto the stack
 2: istore_1   // Store it in variable x
 3: getstatic java/lang/System/out Ljava/io/PrintStream;
 6: iload_1    // Load x (which is 15)
 7: invokevirtual java/io/PrintStream.println (I)V
 10: return

Does Constant Folding Occur in Only Arithmetic Operations?

The short answer is no. It occurs in following cases.

Arithmetic Operations (Addition, Subtraction, Multiplication and so on)
String Concatenation
Boolean

We’ve already seen how constant folding occurs in arithmetic operations, let’s see other two.

String Concatenation

Consider following Java code

public class ConstantFoldingWithStrings {

  public static void main(String... args) {
      String message = "Hello" + "World";
      System.out.println("Message: " + message);
   }
}

Do the same actions as you did in arithmetic operation in order to get the bytecode.

0: ldc    #7 // String HelloWorld

The output is truncated for simplicity. No need to say anything, it is obvious from the result.

Boolean Folding

Boolean folding might confuse you, but we will see the both possible options ( false and true case ).

true case:

public class ConstantFoldingWithBooleans {

   public static void main(String... args) {
      boolean isBool = 3 < 5 && 6 < 8; // true
      System.out.println("Bool: " + isBool);
   }
}

Here’s the generated bytecode:

0: iconst_1
1: istore_1

iconst_1 opcode means ‘Push int constant 1‘ and in 1 means true.

Let’s see the false case:

public class ConstantFoldingWithBooleans {

   public static void main(String... args) {
      boolean isBool = 3 > 5 && 6 < 8; // false
      System.out.println("Bool: " + isBool);
   }
}

Generated bytecode:

0: iconst_0
1: istore_1

iconst_0 opcode means ‘Push int constant 0‘ and in 0 means false.

Tricky Example

Most of the time, we don’t write code this way by embedding constants directly into expressions. Instead, we store them in variables for better readability and maintainability. However, constant folding will happen when the variables are declared as final.

Consider following example

public class ConstantFolding {
   public static void main(String... args) {
      final int campaignPoints = 2000;
      final int rate = 2;
      int amount = getTransactionAmount() * campaignPoints * rate;
      System.out.println("Amount: " + amount);
   }

   public static int getTransactionAmount() {
      return 3000;
   }
}

In above example, if we don’t write final keyword in front of the variables, constant folding will not happen at compile time. Let’s see what will be generated as bytecode.

0: invokestatic  #7    // Method getTransactionAmount:()I
3: sipush        2000
6: imul
7: iconst_2
8: imul
9: istore_1

Constant Folding didn’t occur regardless of final keywords. Why?

The trick is hidden behind the equation.

int amount = getTransactionAmount() * campaignPoints * rate;

Java is calculates the arithmetic operations from left to right. So first operand ( getTransactionAmount() ) is not final. This is the reason why Constant Folding didn’t occur.

If we wrap the constant variables with parentheses or switch the operands positions, then Constant Folding will occur.

int amount = getTransactionAmount() * (campaignPoints * rate);

// or

int amount = campaignPoints * rate * getTransactionAmount();

// or

final int multiplier = campaignPoints * rate;
int amount = multiplier * getTransactionAmount();

You can choose one of the above. Here’s the generated bytecode

0: invokestatic  #7    // Method getTransactionAmount:()I
3: sipush        4000  // 2000 * 2 = 4000
6: imul
7: istore_1

This time Constant Folding occurred.

Benefits of Constant Folding

Improves performance by eliminating redundant computations.
Reduces bytecode size.
JVM executes optimized bytecode faster