Integer Literals

I briefly touched upon Literals in the Code Blocks and Tokens lecture. Now is the time to dive deep into it. To quickly recap, any constant value which can be assigned to the variable is called a literal. Let's start by looking at integer literals.

Any whole number value is an integer literal. Integer literals are most commonly used literals in a typical program. 2, 16, 18426, 24041973 are some examples of integer literals.

In our programs almost all of the times we use decimal numbers meaning base 10 numbers. In addition to decimal numbers, Java also supports Octal, Hexadecimal and Binary numbers.

Octal (base 8)

To write a number as an Octal number prefix it with a 0. Java considers numbers with leading zeros as Octal numbers. So, don’t prefix your number with a 0 if you don’t want it to be interpreted as an Octal number. Octal number system uses the digits 0 to 7. So, if you write 08 or 09 in your program, it will lead to an error as 8 and 9 are invalid Octal numbers.

Hexadecimal (base 16)

To write a number as a Hexadecimal number, prefix it with a 0x. The case of x doesn’t matter. You can use either X or x. Hexadecimal number system uses digits 0 to 9 to represent values from 0 to 9 and letters A to F to represents values from 10 to 15. Again, the case of letters A to F doesn’t matter you can use either lowercase or uppercase.

Binary (base 2)

To write a number as a Binary number, prefix it with a 0b. Here again, b can be in any case.

Let’s look at a program to understand all this with examples.

public class NumberSystemDemo
{
    public void demoNumberSystems() {
        
        int decimalNumber = 2020;
        System.out.println("Value of decimalNumber is " 
        + decimalNumber);
        
        //Octal representation of 2020
        int octalNumber = 03744;
        System.out.println("Decimal Value of octalNumber is " + octalNumber);
        
        //Hexadecimal representation of 2020
        int hexadecimalNumber = 0x7e4; 
        System.out.println("Decimal Value of hexadecimalNumber is " + hexadecimalNumber);
        
        //Binary representation of 2020
        int binaryNumber = 0b011111100100; 
        System.out.println("Decimal Value of binaryNumber is " + binaryNumber);
    }
}

First, we declare an integer variable decimalNumber and assign it the value 2020 in base 10 and then print it. Nothing new here, we have been doing this since the beginning of this course.

Next, we declare an int variable octalNumber. Octal equivalent of decimal number 2020 is 3744. We assign this octal value to the variable octalNumber. Notice, the leading 0 before 3744. This tells Java that this integer literal is in base 8 or Octal form. We print the value of octalNumber variable in decimal form which comes out to 2020.

After that, we declare an int variable hexadecimalNumber. Hexadecimal equivalent of decimal number 2020 is 7e4. We assign this hexadecimal value to the variable hexadecimalNumber. Notice, the leading 0x before 7e4. This tells Java that this integer literal is in base 16 or hexadecimal form. The println statement prints hexadecimalNumber variable in decimal form which comes out to 2020.

Next, we declare an int variable binaryNumber and to it we assign the binary equivalent of decimal number 2020. We prefix the integer literal with 0b which tells Java to treat it as a binary number not a decimal number. We then print the value of variable binaryNumber in decimal form which comes out to 2020.

This should give you a good idea of how to use different number systems in Java.

Underscores in Integer Literal

One interesting thing about integer literals is that you can embed one or more underscores in an integer literal. It will still be a valid literal, the underscores will be discarded at compile time. Underscores can come only in between the digits of the literal, they cannot come at the start or end of the literal. This is useful to improve the readability of the literal.

When we are writing currency amount, we use commas to separate the hundreds place, thousands place, etc. If you have to write an amount of ninety lakh forty-five thousand three hundred and sixty you will write it like this — 90,45,360. In Java, you cannot use commas in your integer literal. Instead you can use underscores and write it like this — 90_45_360. It will be a valid integer literal.

Let’s look at a BlueJ program to see this in action:

public class UnderscoreDemo
{
    public void demoUnderscore() {
        
        int amount = 90_____45_____360;
        System.out.println("Value of amount is " + amount);
    }
}

You can add any number of underscores between the digits of an integer literal. All of them will be discarded and the integer literal will be printed without the underscores. So this is how you can use underscores to improve readability of your integer literals.