Understanding the Underscore in Numeric Values in Java (Java 7 and Later)

In the java 7 and later version one new feature introduced that help developer to improve the readability of large numeric values of adding underscores within numeric literals. This new feature applies to integer and floating-point numbers, making it easier for developers to work with large numbers by breaking them down into more manageable chunks. In this article, we’ll explore this feature in detail and its implications on how numbers are written in Java.

1. Underscore in Numeric Values

In java 7 and later version we can put underscore(_) between digits of a numeric values to enhance readability. This can be done with both integer and floating-point literals

Underscores cannot be placed at the beginning or end of the number.

Underscores cannot be placed immediately before or after a decimal point (for floating-point numbers).

Underscores can be placed between digits for better grouping, like in thousands, millions, or even for binary or hexadecimal representations.

2. Examples of Using Underscores

Here are a few examples demonstrating how to use underscores in numeric values:

Integer Example:

int num = 1_000_000;  // Valid representation for one million
System.out.println(num); // Output: 1000000

3.Floating-Point Example:

float num = 1_00.0f;  // Valid representation for 100.0 as a float
System.out.println(num);  // Output: 100.0

Invalid Example:

float num = 1_00._0f;  // Invalid, underscore is placed before the decimal point

4.Large Numbers with Multiple Underscores:

public class LargeNumberExample {
    public static void main(String[] args) {
        long largeNumber = 1_000___0__00_000L;
        System.out.println("Large number with underscores: " + largeNumber);
    }
}

Here we can put as much as underscore in the number for better readability java don’t give the exception As long as the underscores don’t appear at the beginning or end of the number, it’s perfectly fine.

5. Key Points to Remember

• Underscores are only for readability—they don’t affect the actual value of the number.

• You cannot use underscores before or after a decimal point or at the beginning or end of a number.

• Underscores can be used in octal, hexadecimal, and binary literals, improving their readability.

• This feature is available starting from Java 7, so make sure your project is using Java 7 or later.

6. Conclusion

The introduction of underscores in numeric literals is a small but impactful feature in Java 7 and later. It enhances the readability of large numbers, making the code cleaner and easier to understand. This feature can be especially helpful when working with large constants, such as configuration values or mathematical constants, and when dealing with numbers in different bases like binary, octal, or hexadecimal. As long as you adhere to the rules of where underscores can be placed, this feature can be a great addition to your Java codebase.