Data Types (Primitives & Ranges)

In the Variables lesson you met int, double, String and boolean. Now let's go deeper: Java's eight primitive types, exactly how much each one can hold, and how picking the right type prevents subtle bugs like overflow and rounding errors.

Learn Data Types (Primitives & Ranges) in our free Java course — a beginner-friendly interactive lesson with worked examples, a practice exercise and a quick…

Part of the free Java course at LearnCodingFast — hands-on lessons with examples you run in your browser, plus practice exercises and a quick quiz.

What You'll Learn in This Lesson

1️⃣ Two Families of Types

Java has exactly 8 primitive types . A primitive stores a raw value directly in a fixed block of memory — there is no object, no method, and it can never be null . They split into two families:

Each step is twice the bits, so twice the range.

double has roughly twice the precision of float.

The remaining two don't fit either family: char holds a single character, and boolean holds only true or false .

💡 Analogy: Think of types as buckets of different sizes. A byte is an egg cup, an int is a kitchen jug, and a long is a water barrel. You could carry a teaspoon of water in a barrel, but it wastes space — and you can't pour a barrel into an egg cup without spilling.

2️⃣ The Complete Range Table

Because every primitive has a fixed size, its minimum and maximum values are constants baked into the language. Memorise the int range; look the rest up via the wrapper classes ( Integer.MAX_VALUE , Long.MIN_VALUE , etc.).

Type

Size

Minimum

Maximum

Default

byte

8-bit

-128

127

0

short

16-bit

-32,768

32,767

int

32-bit

-2,147,483,648

2,147,483,647

long

64-bit

-9.2 × 10¹⁸

9.2 × 10¹⁸

0L

float

~±3.4 × 10³⁸

~7 digits

0.0f

double

~±1.8 × 10³⁰⁸

~15 digits

0.0

char

'\u0000' (0)

65,535

'\u0000'

boolean

1-bit*

false

true

* The JVM doesn't truly use a single bit; size is implementation-defined. The "Default" column is the value a field gets when you don't initialise it (local variables get no default — you must assign them).

3️⃣ Overflow — When Numbers Wrap Around

Because each type has a hard ceiling, going one past it doesn't throw an error — it silently wraps back to the minimum, like an odometer rolling over to zero.

4️⃣ char Is Secretly a Number

A char looks like a letter, but internally it's an unsigned 16-bit number — the Unicode code point . That means you can do arithmetic on characters:

This trick — treating letters as numbers — is the basis of cipher puzzles, sorting, and case-conversion. Single quotes mean char ; double quotes mean String . They are not interchangeable.

5️⃣ Choosing the Right Type

You rarely need the exotic types. Use this decision guide:

• Whole number that fits in a couple of billion → int (the default)
• Whole number bigger than ~2 billion (IDs, timestamps, byte counts) → long
• Decimal number (measurements, science, prices while learning) → double
• Yes/no flag → boolean
• A single character → char
• Real money in production → BigDecimal (a class, not a primitive)
• Raw file/network bytes → byte (often in a byte[] )

🧩 Reorder Challenge

These lines are scrambled. Put them in the correct order so the program declares a long file size, converts it to a double in megabytes, and prints it.

Why: The class and method headers must come first. bytes must be declared before it can be used, and it needs the L suffix because 5.3 billion overflows int . We divide by 1024.0 (a double) so the division is floating-point, not integer — giving 5120.00 MB .

🧠 Quick Recall

-2147483648 . Adding 1 to the largest int overflows and wraps to the smallest int.

C . 'A' is 65, plus 2 is 67, and casting 67 back to char gives 'C' .

3 then 3.5 . The first is integer division (both ints, decimal dropped); the second has a double operand, so it's floating-point division.

Common Beginner Mistakes

• ❌ Forgetting the L on big longs: long n = 3000000000; won't compile — the literal is read as an int first and overflows. Write 3000000000L .
• ❌ Forgetting the f on floats: float f = 3.14; fails because 3.14 is a double. Write 3.14f .
• ❌ Trusting double for money: 0.1 + 0.2 is 0.30000000000000004 . Use BigDecimal for currency.
• ❌ Assuming overflow errors: it doesn't throw — it wraps. Use long or Math.addExact when overflow matters.
• ❌ Single vs double quotes: 'A' is a char; "A" is a String. Mixing them is a compile error.

📋 Quick Reference

Range

Notes

-128 .. 127

Raw bytes; integer family

-32,768 .. 32,767

Rarely used

~ -2.1B .. 2.1B

Default whole number

~ -9.2 .. 9.2 × 10¹⁸

Needs L suffix: 10L

~7 decimal digits

Needs f suffix: 3.14f

~15 decimal digits

Default decimal number

0 .. 65,535

Single char in 'quotes'; a number

false / true

Only true or false

Integer.MAX_VALUE

—

int max constant

Integer.MIN_VALUE

int min constant

Long.MAX_VALUE

9,223,372,036,854,775,807

long max constant

1_000_000

1000000

Underscores aid readability

MAX + 1

wraps to MIN

Overflow is silent, not an error

BigDecimal

class

exact

Use for money, not double

Frequently Asked Questions

🎉 Lesson Complete!

You now know all 8 primitive types, their exact ranges, why long needs L and float needs f , how overflow silently wraps, and why double is wrong for money. Most of your code will use int , double , and boolean — but now you know what the others are for.

Next up: Type Casting — safely (and unsafely) converting values from one type to another.

Practice quiz

Continue this course

• Previous: Variables
• Next: Type Casting