There are two types of java data types: Primitive data types: The primitive java data types include boolean, char, byte, short, int, long, float, and double. Non-primitive java data types: The non-primitive java data types include Classes, Interfaces, and Arrays.

Table of Contents

## The Double Primitive Java Data Type

A double is a double-precision 64-bit IEEE 754 floating point number.

double example = -7162.37; double myDouble = 974.21; double anotherDouble = 658.7; double addedDoubles = myDouble + anotherDouble; // 315.51 double subtractedDoubles = myDouble - anotherDouble; // 1632.91 double scientificNotationDouble = 1.2e-3; // 0.0012

Because of the way floating point numbers are stored, many numbers don’t have an exact representation.

double notExact = 1.32 - 0.42; // result should be 0.9 System.out.println(notExact); // 0.9000000000000001

While using **double **is fine for most applications, neither **float **nor **double **should be used to store precise numbers such as currency. Instead, the **BigDecimal **class should be used

The default value of a double is 0.0d

public double defaultDouble; // defaultDouble == 0.0

Note: Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY, Double.NaN are double values. NaN stands for results of operations that cannot be determined, such as dividing 2 infinite values. Furthermore, 0d and -0d is

different, but == yields true:

double d1 = 0d; double d2 = -0d; System.out.println(d1 == d2); // true System.out.println(1d / d1); // Infinity System.out.println(1d / d2); // -Infinity System.out.println(Double.POSITIVE_INFINITY / Double.POSITIVE_INFINITY); // NaN

## The long primitive

By default, long is a 64-bit signed integer (in Java 8, it can be either signed or unsigned). Signed, it can store a minimum value of -263, and a maximum value of 263 – 1, and unsigned it can store a minimum value of 0 and a maximum value of 264 – 1

long example = -42; long myLong = 284; long anotherLong = 73; //an "L" must be appended to the end of the number, because by default, //numbers are assumed to be the int type. Appending an "L" makes it a long //as 549755813888 (2 ^ 39) is larger than the maximum value of an int (2^31 - 1), //"L" must be appended long bigNumber = 549755813888L; long addedLongs = myLong + anotherLong; // 284 + 73 = 357 long subtractedLongs = myLong - anotherLong; // 284 - 73 = 211

The maximum and minimum values of long can be found at:

long high = Long.MAX_VALUE; // high == 9223372036854775807L long low = Long.MIN_VALUE; // low == -9223372036854775808L The default value of a long is 0L long defaultLong; // defaultLong == 0L

**Note**: letter “L” appended at the end of the long literal is case insensitive, however, it is good practice to use capital as it is easier to distinguish from digit one:

2L == 2l; // true

**Warning**: Java caches Integer objects instances from the range -128 to 127.

The following results can be found:

Long val1 = 127L;

Long val2 = 127L;

System.out.println(val1 == val2); // true

Long val3 = 128L;

Long val4 = 128L;

System.out.println(val3 == val4); // false

To properly compare 2 Object Long values, use the following code(From Java 1.7 onward):

Long val3 = 128L;

Long val4 = 128L;

System.out.println(Objects.equal(val3, val4)); // true

Comparing a primitive long to an Object long will not result in a false negative like comparing 2 objects with ==does.

### The boolean primitive

A boolean can store one of two values, either true or false

boolean foo = true; System.out.println("foo = " + foo); // foo = true boolean bar = false; System.out.println("bar = " + bar); // bar = false boolean notFoo = !foo; System.out.println("notFoo = " + notFoo); // notFoo = false boolean fooAndBar = foo && bar; System.out.println("fooAndBar = " + fooAndBar); // fooAndBar = false boolean fooOrBar = foo || bar; System.out.println("fooOrBar = " + fooOrBar); // fooOrBar = true boolean fooXorBar = foo ^ bar; System.out.println("fooXorBar = " + fooXorBar); // fooXorBar = true The default value of a boolean is false boolean defaultBoolean; // defaultBoolean == falseInteger objects instances from the range -128 to 127.

#### The byte primitive

A byte is a 8-bit signed integer. It can store a minimum value of -27 (-128), and a maximum value of 27 – 1 (127)

byte example = -36;

byte myByte = 96;

byte anotherByte = 7;

byte addedBytes = (byte) (myByte + anotherByte); // 103

byte subtractedBytes = (byte) (myBytes - anotherByte); // 89

The maximum and minimum values of byte can be found at:

byte high = Byte.MAX_VALUE; // high == 127

byte low = Byte.MIN_VALUE; // low == -128

The default value of a byte is 0

byte defaultByte; // defaultByte == 0

##### Negative value representation

Java and most other languages store negative integral numbers in a representation called 2’s complement notation.

For a unique binary representation of a data type using n bits, values are encoded like this:

The least significant n-1 bits store a positive integral number x in integral representation. The most significant value stores a bit with value s. The value represented by those bits is

x - s * 2n-1

i.e. if the most significant bit is 1, then a value that is just by 1 larger than the number you could represent with the other bits (2n-2 + 2n-3 + … + 21 + 20 = 2n-1 – 1) is subtracted allowing a unique binary representation for each value from – 2n-1 (s = 1; x = 0) to 2n-1 – 1 (s = 0; x = 2n-1 – 1).

This also has the nice side effect, that you can add the binary representations as if they were positive binary numbers:v1 = x1 – s1 * 2n-1

v2 = x2 - s2 * 2n-1

s1 | s2 | x1 + x2 overflow | addition result |

0 | 0 | No | x1 + x2 = v1 + v2 |

0 | 0 | Yes | too large to be represented with data type (overflow) |

0 | 1 | No | x1 + x2 – 2n-1 = x1 + x2 – s2 * 2n-1 = v1 + v2 |

0 | 1 | Yes | (x1 + x2) mod 2n-1 = x1 + x2 – 2n-1 = v1 + v2 |

1 | 0 | * | see above (swap summands) |

1 | 1 | No | No too small to be represented with data type (x1 + x2 – 2n < -2n-1 ; underflow) |

1 | 1 | Yes | (x1 + x2) mod 2n-1 – 2n-1 = (x1 + x2 – 2n-1) – 2n-1 = (x1 – s1 * 2n-1) + (x2 – s2 * 2n-1) = v1 + v2 |

Note that this fact makes finding binary representation of the additive inverse (i.e. the negative value) easy:

Observe that adding the bitwise complement to the number results in all bits being 1. Now add 1 to make value

overflow and you get the neutral element 0 (all bits 0).

So the negative value of a number i can be calculated using (ignoring possible promotion to int here)

(~i) + 1

**Example**: taking the negative value of 0 (byte):

The result of negating 0, is **11111111**. Adding 1 gives a value of **100000000 **(9 bits). Because a byte can only store 8 bits, the leftmost value is truncated, and the result is **00000000**

Original | Process | Result |

0 (00000000) | Negate | -0 (11111111) |

11111111 | Add 1 to binary | 100000000 |

100000000 | Truncate to 8 bits | 00000000 (-0 equals 0) |

##### The short primitive java data type

A short is a 16-bit signed integer. It has a minimum value of -215 (-32,768), and a maximum value of 215 ‑1 (32,767)

short example = -48; short myShort = 987; short anotherShort = 17; short addedShorts = (short) (myShort + anotherShort); // 1,004 short subtractedShorts = (short) (myShort - anotherShort); // 970

The maximum and minimum values of short can be found at:

short high = Short.MAX_VALUE; // high == 32767 short low = Short.MIN_VALUE; // low == -32768

The default value of a short is 0

short defaultShort; // defaultShort == 0