Java With Us

Java Primitives — int, double, boolean and the Eight Built-in Types

Updated on 2026-04-21 Reviewed by the Java With Us editorial team

Java has exactly eight primitive types. They aren't objects — they hold a raw value directly in memory, with no header and no methods. Every other type in Java (String, arrays, your own classes) is a reference type.

The eight primitives at a glance

TypeSizeRangeDefaultWrapper
byte8 bits−128 to 1270Byte
short16 bits−32 768 to 32 7670Short
int32 bits−2³¹ to 2³¹−10Integer
long64 bits−2⁶³ to 2⁶³−10LLong
float32 bits~±3.4×10³⁸ (7 digits)0.0fFloat
double64 bits~±1.8×10³⁰⁸ (15 digits)0.0Double
booleanJVM-definedtrue / falsefalseBoolean
char16 bitsUTF-16 code unit'\u0000'Character

Defaults only apply to fields

Instance and static fields are initialised to the default value above. Local variables are not — Java rejects code that reads an uninitialised local:

int x;
System.out.println(x); // ❌ "variable x might not have been initialized"

Literals: the suffixes that bite

long  big   = 3_000_000_000;       // ❌ int overflow before assignment
long  big2  = 3_000_000_000L;      // ✅ L suffix forces long literal
float pi    = 3.14;                // ❌ double cannot be assigned to float
float pi2   = 3.14f;               // ✅ f suffix forces float literal
int   hex   = 0xFF;                // 255
int   binary = 0b1010_1010;        // 170 — underscores allowed since Java 7

Floating-point precision

float and double are binary floating-point (IEEE 754). Decimal numbers like 0.1 can't be represented exactly:

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

For money or anything that must round predictably, use BigDecimal with a string constructor: new BigDecimal("0.1").

Wrappers and autoboxing

Each primitive has a wrapper class (Integer, Double, …). Java auto-boxes between them, but two traps:

Integer a = 127, b = 127;
Integer c = 200, d = 200;
System.out.println(a == b); // true  — cached for −128..127
System.out.println(c == d); // false — different objects
System.out.println(c.equals(d)); // true ✅ always use .equals()

Integer x = null;
int y = x; // ❌ NullPointerException on auto-unboxing

Modern Java: var still infers primitives

var (Java 10+) infers the type from the initialiser:

var i  = 42;        // int
var d  = 3.14;      // double
var b  = true;      // boolean
var s  = "hello";   // String — reference, not primitive

All sub-topics

  • int — the workhorse 32-bit integer
  • long — when 32 bits aren't enough
  • double — IEEE-754 64-bit floats
  • boolean — true and false (and only those)
  • char — UTF-16 code units, not characters
  • byte — for binary data and arrays
  • short — rarely needed today
  • float — when memory matters

Common mistakes

  • Comparing wrappers with == — works for −128..127 by accident, then breaks. Use .equals().
  • Forgetting the L on long literals — 1024 * 1024 * 1024 * 4 overflows silently to a negative int.
  • Using float/double for money — switch to BigDecimal.
  • Treating char as a Unicode character — emoji and supplementary characters need two chars. Use String and codePointAt().

Try it & related tools

Run any snippet in the Java Online Compiler. To inspect numeric edge cases, try the Base64 tool for byte-level work or the String Escape tool for char and \uXXXX handling.

Related articles