Java Primitive Data Types: Types, Size, Range, Examples & Usage

Every Java program works with data. Sometimes that data is a simple number such as 25, sometimes a character such as 'A', and sometimes a value such as true or false. Java provides primitive data types for storing these basic values efficiently.

Primitive types are the foundation of Java programming. Before working comfortably with variables, operators, arrays, methods, objects, or collections, you should understand what primitive data types are and how Java stores and handles them.

What Are Primitive Data Types?

Primitive data types are Java's built-in data types used to represent simple values directly. They are not classes and do not represent objects. Java provides exactly 8 primitive data types: byte, short, int, long, float, double, char, and boolean.

Important: Java has exactly 8 primitive data types. All other data types, including String, arrays, classes, interfaces, and enums, are reference types.

Why Does Java Have Primitive Types?

Imagine a program processing millions of numeric values. Creating a separate object for every small number would introduce unnecessary memory and processing overhead. Primitive types allow Java to represent basic values efficiently.

Think of primitive values as the basic building blocks of a program. When you write an expression such as 10 + 20, Java can work directly with numeric values rather than requiring you to create objects for each number.

The 8 Primitive Data Types

Type	Category	Size	Example	Used For
byte	Integer	8 bits	100	Small whole numbers
short	Integer	16 bits	15000	Small-to-medium whole numbers
int	Integer	32 bits	500000	General-purpose whole numbers
long	Integer	64 bits	9000000000L	Very large whole numbers
float	Floating-point	32 bits	12.5f	Decimal values with lower precision
double	Floating-point	64 bits	12.5	General-purpose decimal calculations
char	Character	16 bits	'A'	A single UTF-16 code unit
boolean	Logical	Not fixed by Java specification	true	True/false conditions

Integer Data Types

Java provides four primitive types for storing whole numbers: byte, short, int, and long. Their main difference is the range of values they can represent.

byte

The byte type uses 8 bits and can store values from -128 to 127. It is useful when memory efficiency matters and the expected values fit within this range.

byte age = 25;
byte temperature = -10;

For example, when an application stores a very large collection of small numeric values, byte can use less memory than int.

short

The short type uses 16 bits and stores whole numbers from -32,768 to 32,767.

short temperature = 250;
short students = 500;

Although short uses less storage than int, ordinary Java arithmetic commonly promotes smaller integer types to int.

int

The int type uses 32 bits and is the most commonly used integer type in Java. It can represent values from -2,147,483,648 to 2,147,483,647.

int age = 25;
int salary = 50000;
int totalMarks = 450;

Unless you have a specific reason to choose another integer type, int is normally the best default for whole-number calculations.

Remember: An integer literal such as 100 is treated as an int by default.

long

The long type uses 64 bits and is designed for whole numbers that may exceed the range of int.

long population = 8000000000L;
long distance = 50000000000L;

The L suffix tells Java that the numeric literal should be treated as a long.

Common mistake: A large integer literal that exceeds the int range must be written as a long literal, usually by adding L.

Floating-Point Data Types

Java provides two primitive types for decimal or floating-point values: float and double.

float

The float type uses 32-bit single-precision floating-point representation. A decimal literal assigned directly to a float requires the f or F suffix.

float temperature = 36.5f;
float price = 99.99F;

Without the suffix, Java treats a decimal literal such as 36.5 as a double.

double

The double type uses 64-bit double-precision floating-point representation. It provides greater precision than float and is the normal choice for general floating-point calculations.

double salary = 45000.75;
double average = 87.65;

Remember: Decimal literals such as 10.5 are double by default. Use 10.5f when you specifically need a float.

char Data Type

The char type represents a single UTF-16 code unit. It is commonly used for individual characters rather than complete text.

char grade = 'A';
char symbol = '$';
char digit = '7';

Character literals use single quotation marks. Double quotation marks represent a String, which is a reference type.

char letter = 'A';
String name = "Java";

This small difference is a classic beginner interview question: 'A' is a char, while "A" is a String.

boolean Data Type

The boolean type represents a logical value and can contain only true or false.

boolean isLoggedIn = true;
boolean paymentCompleted = false;

Boolean values are essential for decision-making and are frequently used with conditions and loops.

boolean isEligible = age >= 18;

if (isEligible) {
    System.out.println("Eligible to vote");
}

Think of a boolean as a simple yes/no switch. It represents whether a condition is true or false.

Primitive Data Types and Memory

Primitive variables store primitive values, while reference variables store references to objects. This distinction becomes important when you begin working with classes, objects, arrays, and collections.

int marks = 95;
double percentage = 91.5;
boolean passed = true;

Each variable has a declared type that determines what kind of value it can represent and which operations are valid for that value.

Type Conversion

Java allows compatible primitive values to be converted from one numeric type to another. When a smaller numeric type is converted to a larger compatible type, Java can often perform the conversion automatically.

int number = 100;
long result = number;

This works because every valid int value can be represented by a long.

The reverse direction may lose information, so Java requires an explicit cast.

long number = 1000L;
int result = (int) number;

The cast tells Java that the conversion is intentional.

Common Beginner Mistakes

• Forgetting the L suffix for large long literals.
• Forgetting the f suffix when assigning a decimal literal to a float.
• Using double quotes for a char instead of single quotes.
• Thinking String is a primitive type. It is a reference type.
• Assuming floating-point calculations are always mathematically exact.
• Choosing byte or short everywhere simply because they use less storage. For ordinary calculations, int is generally the natural choice.

Best Practices

• Use int as the normal choice for whole-number calculations unless another type is required.
• Use long when values may exceed the int range.
• Use double for most general-purpose floating-point calculations.
• Use float when its precision is sufficient or when an API specifically requires it.
• Use char for a single UTF-16 code unit, not for storing complete text.
• Use boolean for true/false states instead of representing them with arbitrary numbers.

Interview Insights

Interview Question: How many primitive data types does Java have?

Java has exactly 8 primitive data types: byte, short, int, long, float, double, char, and boolean.

Primitive Data Types: Quick Revision

Type	Size	Range / Values	Default Value	Example
byte	8 bits	-128 to 127	0	byte n = 10;
short	16 bits	-32,768 to 32,767	0	short n = 1000;
int	32 bits	-2³¹ to 2³¹ - 1	0	int n = 50000;
long	64 bits	-2⁶³ to 2⁶³ - 1	0L	long n = 50000L;
float	32 bits	Approximately ±3.4 × 10³⁸	0.0f	float n = 5.5f;
double	64 bits	Approximately ±1.7 × 10³⁰⁸	0.0d	double n = 5.5;
char	16 bits	0 to 65,535	'\u0000'	char c = 'A';
boolean	Not specified by Java	true or false	false	boolean ok = true;

Primitive data types may look simple, but they influence almost every Java program you write. Choosing the appropriate type helps your code communicate its intent, avoid unnecessary conversions, and handle values safely. Once these eight building blocks are clear, variables and expressions become much easier to understand.