Java Variable Types: The Eight That Matter

Java has exactly eight primitive types: byte, short, int, long, float, double, char, and boolean. Everything else (Strings, arrays, your own classes) is a reference type stored as an object on the heap. The eight primitives are the building blocks. Understanding what each one does, what its range is, and when to use it instead of a default int or double is one of those skills that separates Java developers who write working code from Java developers who write code without surprise overflow bugs.

The way I think about Java's primitives is that they're a performance trade-off the language insists on exposing. Most modern languages either hide the integer width entirely (Python, Ruby) or force you to think about it constantly (C, Rust). Java sits in the middle: you have eight options, but for most code you'll just use int and double and ignore the rest. Knowing why the others exist is useful even if you rarely choose them.

The Eight Primitives

Integer Types

byte  b = 127;          // 8-bit, range -128 to 127
short s = 32767;        // 16-bit, range -32768 to 32767
int   i = 2147483647;   // 32-bit, range about ±2.1 billion
long  l = 9223372036854775807L;  // 64-bit, range about ±9.2 quintillion

The default integer type is int. Use long when your numbers can exceed roughly 2 billion (timestamps in milliseconds, IDs at scale, anything bigger than ~2.1B). Use byte for raw binary data (file I/O, network protocols). Use short almost never; the memory savings rarely justify the awkwardness, and most operations promote it to int anyway.

Floating-Point Types

float  f = 3.14f;     // 32-bit, ~7 significant decimal digits
double d = 3.141592653589793;  // 64-bit, ~15 significant decimal digits

The default floating-point type is double. Use float only when you have a specific reason (memory-constrained systems, graphics work where 32-bit floats are the standard). Both are IEEE 754 floating-point and produce the usual rounding errors at edges. For monetary calculations, neither is appropriate. Use BigDecimal instead.

Character Type

char c = 'A';
char unicode = '\u00E9';  // é

A single 16-bit Unicode character. The width was decided in the early 1990s when Unicode looked like it would fit in 16 bits, before they realized it wouldn't. Now char is technically half of a UTF-16 code unit, which causes endless confusion when working with characters outside the Basic Multilingual Plane (most emoji, some CJK characters). Don't use char for general text processing. Use String and its code-point methods.

Boolean Type

boolean isActive = true;
boolean hasPermission = false;

True or false. Java is strict: a boolean is not a number. You can't use 0 and 1 interchangeably as you can in C or JavaScript. if (1) is a compile error.

Reference Types

Everything that isn't one of the eight primitives is a reference type:

String name = "Alex";
int[] numbers = {1, 2, 3};
List<Integer> list = new ArrayList<>();
Person p = new Person("Alex", 30);

Reference types are stored as pointers on the stack pointing to objects on the heap. Two reference variables can point to the same object, and changes through one are visible through the other.

Boxing and Wrapper Classes

Each primitive has a wrapper class that turns it into an object: Byte, Short, Integer, Long, Float, Double, Character, Boolean. Wrappers are needed for collections (you can't store an int in List, but you can store an Integer).

int primitive = 42;
Integer wrapper = primitive;     // autoboxed: int → Integer
int back = wrapper;              // unboxed: Integer → int

List<Integer> nums = new ArrayList<>();
nums.add(5);                     // autoboxed automatically

Java does this conversion automatically as needed (autoboxing and unboxing). The catch: a List<Integer> uses heap memory for every element, while an int[] doesn't. For tight numeric loops, this difference can be 4x in memory and 2-3x in speed. The newer Stream API and primitive specializations (IntStream, LongStream) help reduce this.

The Default Values

Uninitialized fields (not local variables, which must be initialized before use) get default values:

• byte, short, int, long: 0
• float, double: 0.0
• char: '\\u0000' (null character)
• boolean: false
• Reference types: null

These defaults are why Java is more predictable than C, where uninitialized variables contain whatever happened to be in memory. Java will crash with NullPointerException at runtime, but at least it won't silently use random data.

Comparing Primitives vs References

int a = 5;
int b = 5;
a == b;  // true (value comparison for primitives)

String s1 = "hello";
String s2 = "hello";
s1 == s2;          // true or false depending on string interning
s1.equals(s2);     // true (the right way to compare strings)

Integer i1 = 200;
Integer i2 = 200;
i1 == i2;          // false (reference comparison, different objects)
i1.equals(i2);     // true

For primitives, == compares values. For reference types, == compares references (memory addresses), not contents. This is the source of half the confusing Java bugs new developers hit. Use .equals() for content comparison on objects.

What to Use by Default

• Whole numbers under 2 billion: int.
• Whole numbers above 2 billion (timestamps, IDs): long.
• Decimal numbers: double.
• Money: BigDecimal.
• True/false: boolean.
• Text: String (not char).
• Lists of numbers: int[] for small/fixed, List<Integer> for dynamic.

That covers about 90% of normal Java code. The other primitives (byte, short, float, char) exist for specific cases and you'll know when you need them.

The Take

Java's primitive types are an artifact of the language being designed in 1995 with C++ as a model. Modern languages (Kotlin, Scala) hide most of this complexity, but the underlying JVM still uses the same eight primitive types. Understanding them helps you read older Java code and reason about performance when it matters. For most application work, the distinction between primitives and reference types is one of those things that's technically important but rarely visible until something goes wrong.