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. Java NullPointerException covers patterns for avoiding it later.

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.

A working demonstration

What's next

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

Practice