# Decimal Integer literals

suggest changeInteger literals provide values that can be used where you need a `byte`

, `short`

, `int`

, `long`

or `char`

instance. (This example focuses on the simple decimal forms. Other examples explain how to literals in octal, hexadecimal and binary, and the use of underscores to improve readability.)

## Ordinary integer literals

The simplest and most common form of integer literal is a decimal integer literal. For example:

```
0 // The decimal number zero (type 'int')
1 // The decimal number one (type 'int')
42 // The decimal number forty two (type 'int')
```

You need to be careful with leading zeros. A leading zero causes an integer literal to be interpreted as *octal* not decimal.

`077 // This literal actually means 7 x 8 + 7 ... or 63 decimal!`

Integer literals are unsigned. If you see something like `-10`

or `+10`

, these are actually *expressions* using the unary `\-`

and unary `\+`

operators.

The range of integer literals of this form have an intrinsic type of `int`

, and must fall in the range zero to 231 or 2,147,483,648.

Note that 231 is `1`

greater than `Integer.MAX_VALUE`

. Literals from 0 through to `2147483647`

can be used anywhere, but it is a compilation error to use `2147483648`

without a preceding unary `\-`

operator. (In other words, it is reserved for expressing the value of `Integer.MIN_VALUE`

.)

```
int max = 2147483647; // OK
int min = -2147483648; // OK
int tooBig = 2147483648; // ERROR
```

## Long integer literals

Literals of type `long`

are expressed by adding an `L`

suffix. For example:

```
0L // The decimal number zero (type 'long')
1L // The decimal number one (type 'long')
2147483648L // The value of Integer.MAX_VALUE + 1
long big = 2147483648; // ERROR
long big2 = 2147483648L; // OK
```

Note that the distinction between `int`

and `long`

literals is significant in other places. For example

```
int i = 2147483647;
long l = i + 1; // Produces a negative value because the operation is
// performed using 32 bit arithmetic, and the
// addition overflows
long l2 = i + 1L; // Produces the (intuitively) correct value.
```

Reference: JLS 3.10.1 - Integer Literals