Java Data Types

Java is statically typed — every variable has a type known at compile time. Types fall into two families: primitives (raw values built into the language) and reference types (objects, arrays, anything created with new). This chapter walks through both.

The eight primitive types

Primitives are the only values in Java that are not objects. They store their value directly in the variable's storage slot. Java defines exactly eight:

A few things worth committing to memory:

• int is the default integer type. Most counters and indexes are int. Use long only when you actually need numbers above ~2 billion.
• double is the default floating-point type. Plain 3.14 is a double; 3.14f is a float. Use double unless memory pressure forces float.
• Underscores in numeric literals improve readability: 1_000_000 is the same as 1000000.
• Default values apply only to fields, not to local variables. A local variable has no default — you must initialise it before reading.

Reference types

Everything else — String, arrays, your own classes, library classes — is a reference type. A reference-type variable doesn't hold the object itself; it holds a reference (essentially a pointer) to the object on the heap:

String name = "Ada";
int[] scores = new int[10];
LocalDate today = LocalDate.now();

The default value of any reference variable is null — a special value meaning "no object."

String s = null;
System.out.println(s.length());  // throws NullPointerException at runtime

null is the source of one of Java's most common runtime errors. The Java Exceptions chapter covers how to handle the NullPointerException this raises.

Wrapper classes

Each primitive has a matching wrapper class — a real object that wraps the primitive value:

You need wrappers when you want to put primitives into collections (which only hold objects):

List<Integer> scores = new ArrayList<>();
scores.add(42);   // autoboxed from int → Integer
int first = scores.get(0);  // unboxed from Integer → int

Java automatically converts between primitives and wrappers — called autoboxing and unboxing — so most of the time you don't notice.

A note on String

String is a reference type, not a primitive. It's special enough that the language gives it a literal syntax ("text") and the + operator. Strings are immutable — once created, their contents never change. Every "modification" returns a new string. The Java Strings chapter goes deep.

Choosing a type

A short decision tree for everyday Java:

• Counting things or array indexes → int
• Large counts (file sizes, timestamps in millis) → long
• Money → BigDecimal (not double — floating-point rounding will bite you)
• Single character → char
• Yes/no → boolean
• Text → String
• A date or time → types in java.time (LocalDate, Instant, Duration)

Resist the urge to "save memory" by using byte or short for ordinary integers. JVMs are tuned for int operations; short doesn't actually use less memory in most cases.

Common gotchas

A handful of type behaviours surprise newcomers regularly. Knowing them up front saves hours of debugging.

Integer overflow wraps silently

Integer arithmetic in Java never throws on overflow — it wraps around. Adding 1 to the largest int produces the smallest int:

int max = Integer.MAX_VALUE;   // 2147483647
System.out.println(max + 1);   // -2147483648

If a value might exceed ~2.1 billion, use long. For counts that could overflow even long, reach for BigInteger.

Floating-point is not exact

float and double follow the IEEE 754 standard, which cannot represent most decimal fractions exactly. The classic example:

System.out.println(0.1 + 0.2);   // 0.30000000000000004

This is why you should never use double for money. Use BigDecimal (constructed from a String, e.g. new BigDecimal("0.1")) when exact decimal values matter.

char is a number

A char is an unsigned 16-bit integer holding a Unicode code unit, so it participates in arithmetic:

char a = 'A';
System.out.println((int) a);   // 65
System.out.println((char) (a + 1));  // B

Compare wrappers with .equals(), not ==

== on wrapper objects compares references, not values. Because of an autoboxing cache for small Integer values (-128 to 127), == appears to work for small numbers and then fails for large ones:

Integer a = 127, b = 127;
System.out.println(a == b);   // true  (cached)
Integer c = 128, d = 128;
System.out.println(c == d);   // false (different objects)
System.out.println(c.equals(d));  // true  (compares values)

Always use .equals() to compare wrapper values. See Java Type Casting for the rules on converting between these types.

A working demonstration

What's next

Java Type Casting shows how to convert between numeric types and between related reference types.

Practice