Java Data Types | Primitive & Non-Primitive Data Types 2026

Java Data Types — Overview

In the previous chapter, we learned about Java Blocks — code blocks, static blocks, instance blocks, and scope rules. Now we cover one of the most foundational topics in Java: Data Types.

Every variable in Java has a data type — it tells the compiler two things: what kind of value the variable can hold, and how much memory to allocate. Java is a statically typed language, which means you must declare the data type of every variable at compile time. This is what makes Java programs reliable, predictable, and fast.

▶
What you will learn: Both categories of Java data types, all 8 primitive types in depth, non-primitive reference types, Java literals, wrapper classes, autoboxing/unboxing, type casting, and how to choose the right type for your use case.

Two Categories of Java Data Types

Java data types fall into exactly two categories. Understanding the fundamental difference between them is the first step to mastering Java memory management and object-oriented programming.

Feature	Primitive Types	Non-Primitive (Reference) Types
Count	Exactly 8	Unlimited — all classes, interfaces, arrays, enums
Examples	byte, short, int, long, float, double, char, boolean	String, int[], Scanner, ArrayList, your own classes
Stores	The actual value directly	A memory address (reference) pointing to the object
Memory location	Stack	Reference on stack; object data on heap
Can be null?	No — always has a value	Yes — reference can be null
Default value	0, 0.0, false, '\u0000'	null
Has methods?	No	Yes — all objects have methods
Size	Fixed — defined by Java spec	Not fixed — depends on object structure
Extends Object?	No	Yes — all reference types extend java.lang.Object
Performance	Faster — direct value access	Slightly slower — requires dereferencing

☕ JavaPrimitive vs Reference — Memory Concept

// PRIMITIVE — value stored directly in the variable
int age = 21;          // 'age' holds the value 21 directly

// NON-PRIMITIVE — variable holds a reference (memory address)
String name = "Rahul"; // 'name' holds the address of the String object
                        // the actual characters 'R','a','h','u','l' are on the heap

// null means the reference variable points to nothing
String city = null;    // city holds no address — not pointing to any object

Primitive Data Types — All 8 Types

Java has exactly 8 primitive data types. Their sizes are fixed by the Java specification — unlike C/C++ where sizes can vary by platform. This platform independence is a key part of Java's Write Once, Run Anywhere guarantee.

Type	Category	Size	Default	Min Value	Max Value	Example Literal
byte	Integer	1 byte (8 bits)	0	-128	127	byte b = 100;
short	Integer	2 bytes (16 bits)	0	-32,768	32,767	short s = 5000;
int	Integer	4 bytes (32 bits)	0	-2,147,483,648	2,147,483,647	int i = 2026;
long	Integer	8 bytes (64 bits)	0L	-9,223,372,036,854,775,808	9,223,372,036,854,775,807	long l = 8000000000L;
float	Floating-Point	4 bytes (32 bits)	0.0f	~1.4 × 10⁻⁴⁵	~3.4 × 10³⁸	float f = 3.14f;
double	Floating-Point	8 bytes (64 bits)	0.0d	~4.9 × 10⁻³²⁴	~1.8 × 10³⁰⁸	double d = 3.14159265;
char	Character	2 bytes (16 bits)	'\u0000'	0 (\u0000)	65,535 (\uFFFF)	char c = 'A';
boolean	Logical	JVM-dependent (~1 bit)	false	false	true	boolean flag = true;

🔢

4 Integer Types

byte, short, int, long — for whole numbers. int is the default choice. Use long for very large numbers. Use byte/short only when memory is critically limited.

📐

2 Floating-Point Types

float, double — for decimal numbers. double is the default choice (and the default for decimal literals). Use float only when memory is tightly constrained.

🔤

1 Character Type

char — stores a single Unicode character using 16-bit UTF-16 encoding. Can also store any integer from 0 to 65,535 representing a Unicode code point.

✅

1 Boolean Type

boolean — stores only true or false. Used for conditions, flags, and logical decisions. Cannot be cast to/from numeric types (unlike C/C++).

Integer Types — byte, short, int, long

Java has four integer types for storing whole numbers (no decimal part). They differ only in size and therefore the range of values they can hold. int is the most commonly used integer type.

byte — 1 Byte

byte is the smallest integer type — 1 byte (8 bits). Range: -128 to 127. Used when memory saving is critical — in large arrays, file/network I/O streams, or image pixel data.

☕ Javabyte Examples

byte minByte = -128;       // minimum value
byte maxByte =  127;       // maximum value
byte pixelValue = 64;      // grayscale pixel — 0 to 127 range
byte fileFlag  = 0x0A;     // hexadecimal literal — value is 10

// Overflow — byte wraps around
byte overflow = (byte) 128;  // 128 overflows → becomes -128
System.out.println(overflow); // -128

short — 2 Bytes

short is 2 bytes (16 bits). Range: -32,768 to 32,767. Rarely used in modern Java — int is preferred unless you are working with binary protocols, audio samples, or legacy systems.

☕ Javashort Examples

short minShort = -32768;    // minimum value
short maxShort =  32767;    // maximum value
short year     =  2026;     // fits comfortably in a short
short audioSample = 15000;  // raw PCM audio sample

int — 4 Bytes (Default Integer Type)

int is 4 bytes (32 bits). Range: -2,147,483,648 to 2,147,483,647 (about ±2.1 billion). This is the default integer type in Java — integer literals like 42 are int by default. Use int for counting, indexing, loop variables, and general arithmetic.

☕ Javaint Examples

int age        = 21;
int year       = 2026;
int population = 1400000000;   // India population — fits in int
int maxInt     = Integer.MAX_VALUE;  // 2147483647
int minInt     = Integer.MIN_VALUE;  // -2147483648

// Numeric literals with underscore (Java 7+) — for readability
int oneMillion  = 1_000_000;     // same as 1000000
int cardNumber  = 1234_5678_9012_3456;  // not valid — too large for int

// Integer arithmetic
int a = 10, b = 3;
System.out.println(a / b);   // 3  — integer division, truncates
System.out.println(a % b);   // 1  — remainder (modulo)

long — 8 Bytes

long is 8 bytes (64 bits). Range: -9.2 × 10¹⁸ to 9.2 × 10¹⁸. Use long when your value exceeds the int range — world population, millisecond timestamps, file sizes in bytes, database IDs. Must add L or l suffix to long literals (uppercase L preferred — lowercase l looks like 1).

☕ Javalong Examples

long worldPopulation  = 8_100_000_000L;    // 8.1 billion — exceeds int
long fileSize         = 10_737_418_240L;   // 10 GB in bytes
long epochMs          = 1_700_000_000_000L; // Unix timestamp in ms
long maxLong          = Long.MAX_VALUE;     // 9223372036854775807

// Missing L suffix — compile error if value > Integer.MAX_VALUE
// long big = 8100000000;   ← ERROR: integer number too large
long big = 8_100_000_000L;  // ✅ correct with L suffix

System.out.println("World population: " + worldPopulation);

Output

World population: 8100000000

Floating-Point Types — float, double

Java has two floating-point types for storing decimal numbers. Both follow the IEEE 754 standard. The key difference is precision and memory size.

float — 4 Bytes, Single Precision

float is 4 bytes (32 bits) — single-precision IEEE 754. Accurate to approximately 7 significant decimal digits. Must add f or F suffix to float literals — otherwise the compiler treats them as double.

☕ Javafloat Examples

float pi      = 3.14f;         // 'f' suffix required
float price   = 99.99f;
float tempC   = 36.6f;         // body temperature
float maxFloat = Float.MAX_VALUE;  // ~3.4 × 10^38

// Without 'f' suffix — compile error
// float x = 3.14;   ← ERROR: possible lossy conversion from double to float

// Precision limitation of float
float f1 = 1.0f / 3.0f;
System.out.println(f1);   // 0.33333334  — only ~7 digits accurate

double — 8 Bytes, Double Precision (Default)

double is 8 bytes (64 bits) — double-precision IEEE 754. Accurate to approximately 15–16 significant decimal digits. Decimal literals like 3.14 are double by default. Prefer double for all general decimal calculations.

☕ Javadouble Examples

double pi       = 3.141592653589793;  // no suffix needed
double salary   = 75000.50;
double distance = 384400.0;            // moon distance in km
double maxDouble = Double.MAX_VALUE;   // ~1.8 × 10^308

// Better precision than float
double d1 = 1.0 / 3.0;
System.out.println(d1);  // 0.3333333333333333  — ~15 digits accurate

// Scientific notation literal
double avogadro = 6.022e23;   // 6.022 × 10^23
double electron = 1.6e-19;    // 1.6 × 10^-19 coulombs
System.out.println(avogadro); // 6.022E23

Output

0.3333333333333333 6.022E23

▶
⚠️ Floating-point precision warning: Neither float nor double can represent all decimal values exactly — this is a property of IEEE 754 binary representation. Example: 0.1 + 0.2 does not equal exactly 0.3 in Java (or any language using IEEE 754). For exact decimal arithmetic (money, banking), use java.math.BigDecimal.

Feature	float	double
Size	4 bytes (32 bits)	8 bytes (64 bits)
Precision	~7 significant digits	~15–16 significant digits
Suffix required?	Yes — f or F	No — optional d or D
Default for literals?	No	Yes — 3.14 is double
Memory usage	Less	More
When to use	Memory-critical; graphics; ML weights	General decimal math — always prefer this
Special values	Float.NaN, Float.POSITIVE_INFINITY	Double.NaN, Double.POSITIVE_INFINITY

Character Type — char

char is a 2-byte (16-bit) unsigned integer that stores a single character using UTF-16 Unicode encoding. Range: 0 to 65,535 (Unicode code points \u0000 to \uFFFF). Unlike C/C++ where char is 1 byte (ASCII only), Java's char supports the full Unicode character set.

☕ Javachar Examples

// Character literals — enclosed in SINGLE quotes
char letter  = 'A';
char digit   = '7';
char space   = ' ';
char newline = '\n';   // escape sequence
char tab     = '\t';   // escape sequence

// Unicode escape sequence
char rupee   = '\u20B9';  // ₹ Indian Rupee symbol
char heart   = '\u2665';  // ♥ Heart symbol
char omega   = '\u03A9';  // Ω Omega symbol

// char can be treated as an unsigned integer
char ch = 'A';
System.out.println(ch);          // A
System.out.println((int) ch);    // 65 — ASCII/Unicode value of 'A'
System.out.println(ch + 1);      // 66 — arithmetic on char returns int
System.out.println((char)(ch + 1)); // B — cast back to char

// char arithmetic — classic use
for (char c = 'A'; c <= 'E'; c++) {
    System.out.print(c + " ");  // A B C D E
}

Output

A 65 66 B A B C D E

Common Escape Sequences for char

Escape Sequence	Name	Unicode	Use Case
\n	Newline	\u000A	Move to next line in output
\t	Tab	\u0009	Horizontal indentation
\r	Carriage Return	\u000D	Move cursor to line start (Windows line endings)
\'	Single Quote	\u0027	Literal single quote inside char literal: '\''
\"	Double Quote	\u0022	Literal double quote inside String literal
\\	Backslash	\u005C	Literal backslash character: '\\'
\0	Null Character	\u0000	Default value of char; string terminator in C — not Java
\uXXXX	Unicode Escape	Any	Any Unicode character: '\u20B9' = ₹

Boolean Type — boolean

boolean stores only two values: true or false. It is used for conditions, flags, control-flow decisions, and any binary state. The actual memory size is JVM-dependent (often treated as a 32-bit int internally for alignment, though it represents only 1 bit of information).

☕ Javaboolean Examples

boolean isLoggedIn  = true;
boolean isExpired   = false;
boolean hasPassed   = true;

// Boolean from comparison expressions
int score = 85;
boolean distinction = score >= 90;   // false — 85 is not >= 90
boolean firstClass  = score >= 60;   // true

// Boolean in control flow
if (isLoggedIn) {
    System.out.println("Welcome back!");
}

// Boolean from method return
String name = "Java";
boolean startsWithJ = name.startsWith("J");  // true
boolean isEmpty     = name.isEmpty();           // false

System.out.println("Distinction : " + distinction);
System.out.println("First Class : " + firstClass);
System.out.println("Starts with J: " + startsWithJ);

Output

Welcome back! Distinction : false First Class : true Starts with J: true

▶
⚠️ Java vs C/C++: In Java, boolean is not interchangeable with integers. You cannot write if (1) or cast a boolean to int. true and false are the only valid values — period.
▶
💡 Naming convention: Boolean variables and methods are typically named with the is, has, can, or should prefix — isActive, hasPermission, canEdit — making the intent immediately clear.

Java Literals — Writing Values in Code

A literal is a fixed value written directly in the source code — the actual data itself, not a variable or expression. Java supports several forms of literals for different data types.

Integer Literals

☕ JavaInteger Literal Forms

// Decimal (base 10) — default, no prefix
int decimal = 255;

// Binary (base 2) — prefix 0b or 0B  (Java 7+)
int binary  = 0b11111111;     // same as 255

// Octal (base 8) — prefix 0 (zero)
int octal   = 0377;           // same as 255

// Hexadecimal (base 16) — prefix 0x or 0X
int hex     = 0xFF;           // same as 255

// Underscore separator (Java 7+) — improves readability
int million    = 1_000_000;
long creditCard = 1234_5678_9012_3456L;
int rgb        = 0xFF_A5_00;  // orange color in hex

System.out.println(decimal + " " + binary + " " + octal + " " + hex);

Output

255 255 255 255

Floating-Point Literals

☕ JavaFloating-Point Literal Forms

double d1 = 3.14;         // standard decimal — double by default
double d2 = 3.14d;        // explicit double suffix (optional)
float  f1 = 3.14f;        // float — 'f' suffix REQUIRED

// Scientific (exponential) notation
double avogadro = 6.022e23;    // 6.022 × 10^23
double planck   = 6.626e-34;   // 6.626 × 10^-34

// Special values
double posInf = Double.POSITIVE_INFINITY;  // 1.0 / 0.0
double negInf = Double.NEGATIVE_INFINITY;  // -1.0 / 0.0
double nan    = Double.NaN;                // 0.0 / 0.0 — Not a Number

System.out.println(1.0 / 0.0);   // Infinity
System.out.println(-1.0 / 0.0);  // -Infinity
System.out.println(0.0 / 0.0);   // NaN

Output

Infinity -Infinity NaN

char, boolean, and String Literals

☕ JavaOther Literal Types

// char literal — SINGLE quotes, exactly ONE character
char grade   = 'A';
char unicode = '\u20B9';  // ₹

// boolean literals — only two values
boolean t = true;
boolean f = false;

// String literal — DOUBLE quotes (non-primitive, but very common)
String name = "Tech Sustainify";

// Text Block (Java 15+) — multi-line String literal
String json = """
        {
            "name": "Java",
            "version": 21
        }
        """;

// null literal — for any reference type
String city = null;

Literal Type	Syntax	Example
Integer decimal	digits	int n = 42;
Integer binary	0b + digits	int n = 0b101010;
Integer octal	0 + digits	int n = 052;
Integer hex	0x + digits	int n = 0x2A;
Long	digits + L	long n = 42L;
Float	digits + f	float f = 3.14f;
Double	digits (no suffix)	double d = 3.14;
Scientific notation	digits + e + exp	double d = 6.022e23;
char	single quotes	char c = 'A';
boolean	true or false	boolean b = true;
String	double quotes	String s = "Hello";
null	null	String s = null;

Non-Primitive (Reference) Data Types

Non-primitive types are also called reference types because a variable of this type stores a reference (memory address) to where the object data lives on the heap — not the data itself. All non-primitive types ultimately extend java.lang.Object.

Type	Description	Created with	Example
String	Immutable sequence of characters. Most used type in Java.	String literal or new String()	String name = "Java";
Array	Fixed-size, ordered collection of same-type elements.	new type[size] or { } literal	int[] marks = {90, 85, 92};
Class	Blueprint for objects — groups state (fields) and behaviour (methods).	new ClassName()	Student s = new Student();
Interface	Contract — defines methods a class must implement.	Implemented by a class	Runnable r = () -> {};
Enum	Fixed set of named constants.	Enum declaration	Day d = Day.MONDAY;
Record	Immutable data carrier class (Java 16+).	record declaration	record Point(int x, int y) {}

☕ JavaNon-Primitive Types Demo

import java.util.ArrayList;

public class NonPrimitiveDemo {
    public static void main(String[] args) {

        // String
        String language = "Java";
        System.out.println(language.length());       // 4
        System.out.println(language.toUpperCase());  // JAVA

        // Array
        int[] scores = {95, 82, 78, 91};
        System.out.println(scores[0]);               // 95
        System.out.println(scores.length);           // 4

        // null reference
        String city = null;
        System.out.println(city);                    // null
        // city.length();  ← NullPointerException at runtime!

        // ArrayList (class from java.util)
        ArrayList<String> fruits = new ArrayList<>();
        fruits.add("Mango");
        fruits.add("Apple");
        System.out.println(fruits);   // [Mango, Apple]
    }
}

Output

4 JAVA 95 4 null [Mango, Apple]

String — Most Used Non-Primitive Type

String is by far the most commonly used non-primitive type in Java. It represents an immutable sequence of Unicode characters. Once created, a String's value cannot be changed — any modification creates a new String object.

☕ JavaString Essentials

// Two ways to create a String
String s1 = "Hello";                // String literal — stored in String Pool
String s2 = new String("Hello");    // new object on heap — NOT recommended

// String is immutable
String name = "Java";
name.toUpperCase();          // does NOT change 'name'
System.out.println(name);    // Java — unchanged
name = name.toUpperCase();   // reassign the reference to a new String
System.out.println(name);    // JAVA

// String concatenation
String firstName = "Rahul";
String lastName  = "Sharma";
String fullName  = firstName + " " + lastName;  // "Rahul Sharma"

// Useful String methods
System.out.println(fullName.length());          // 12
System.out.println(fullName.charAt(0));         // R
System.out.println(fullName.contains("Rahul")); // true
System.out.println(fullName.replace("Rahul", "Priya")); // Priya Sharma
System.out.println(fullName.substring(6));      // Sharma
System.out.println(fullName.toLowerCase());     // rahul sharma
System.out.println("  Java  ".trim());          // Java

// == vs .equals() for Strings
String a = "Java";
String b = "Java";
String c = new String("Java");
System.out.println(a == b);         // true  — same pool object
System.out.println(a == c);         // false — different heap objects
System.out.println(a.equals(c));    // true  — same content

▶
⚠️ Always use .equals() to compare String content — not ==. The == operator compares references (memory addresses), not the actual characters. This is one of the most common beginner bugs in Java.
▶
💡 String Pool: When you write String s = "Java", Java checks if "Java" already exists in the String Pool (a special area of the heap). If yes, the same object is reused — no new allocation. This is why String a = "Java"; String b = "Java"; gives a == b → true.

Wrapper Classes & Autoboxing / Unboxing

Wrapper classes are object representations of Java's 8 primitive types. They exist because many parts of Java (like collections, generics, reflection) require objects, not primitives. Every primitive type has exactly one corresponding wrapper class.

Primitive	Wrapper Class	Package	Key Utility Methods
byte	Byte	java.lang	Byte.parseByte(str), Byte.MAX_VALUE, Byte.MIN_VALUE
short	Short	java.lang	Short.parseShort(str), Short.MAX_VALUE
int	Integer	java.lang	Integer.parseInt(str), Integer.MAX_VALUE, Integer.toBinaryString(n)
long	Long	java.lang	Long.parseLong(str), Long.MAX_VALUE, Long.toBinaryString(n)
float	Float	java.lang	Float.parseFloat(str), Float.MAX_VALUE, Float.isNaN(f)
double	Double	java.lang	Double.parseDouble(str), Double.MAX_VALUE, Double.isInfinite(d)
char	Character	java.lang	Character.isLetter(c), Character.isDigit(c), Character.toUpperCase(c)
boolean	Boolean	java.lang	Boolean.parseBoolean(str), Boolean.TRUE, Boolean.FALSE

Autoboxing and Unboxing (Java 5+)

Autoboxing is the automatic conversion of a primitive to its wrapper class. Unboxing is the reverse — automatic conversion of a wrapper to its primitive. Java does this conversion automatically wherever needed.

☕ JavaWrapper Classes & Autoboxing Demo

import java.util.ArrayList;

public class WrapperDemo {
    public static void main(String[] args) {

        // --- Autoboxing: primitive → Wrapper ---
        int primitiveInt  = 42;
        Integer wrappedInt = primitiveInt;   // autoboxed automatically
        System.out.println(wrappedInt);      // 42

        // --- Unboxing: Wrapper → primitive ---
        Integer wrapperVal = 100;
        int primitiveVal   = wrapperVal;     // unboxed automatically
        System.out.println(primitiveVal);    // 100

        // --- ArrayList requires objects, not primitives ---
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(10);   // autoboxed: int 10 → Integer(10)
        numbers.add(20);
        numbers.add(30);
        int sum = 0;
        for (int n : numbers) {   // each Integer is unboxed to int
            sum += n;
        }
        System.out.println("Sum: " + sum);  // 60

        // --- Wrapper utility methods ---
        String numStr  = "2026";
        int    parsed  = Integer.parseInt(numStr);   // String → int
        String binary  = Integer.toBinaryString(255); // "11111111"
        String hex     = Integer.toHexString(255);    // "ff"
        System.out.println(parsed);   // 2026
        System.out.println(binary);   // 11111111
        System.out.println(hex);      // ff

        // --- Character utility ---
        char ch = 'a';
        System.out.println(Character.isLetter(ch));    // true
        System.out.println(Character.toUpperCase(ch)); // A
        System.out.println(Character.isDigit('5'));     // true
    }
}

Output

42 100 Sum: 60 2026 11111111 ff true A true

▶
⚠️ Autoboxing performance: Autoboxing creates new objects on the heap. In performance-critical loops, avoid autoboxing millions of times — it adds GC pressure. Use primitive arrays instead of ArrayList<Integer> when performance matters.
▶
⚠️ NullPointerException trap: If a wrapper variable is null and you try to unbox it, Java throws a NullPointerException. Example: Integer x = null; int y = x; → NullPointerException at runtime.

Type Casting — Widening & Narrowing

Type casting is the process of converting a value from one data type to another. Java supports two kinds of casting for primitive types — and they behave very differently.

1. Widening Casting (Implicit / Automatic)

Converting a smaller type to a larger type. Java does this automatically — no code needed, no data loss. The hierarchy: byte → short → int → long → float → double

☕ JavaWidening Casting

byte   b = 42;
short  s = b;       // byte  → short  (auto)
int    i = s;       // short → int    (auto)
long   l = i;       // int   → long   (auto)
float  f = l;       // long  → float  (auto)
double d = f;       // float → double (auto)

System.out.println("byte   : " + b);  // 42
System.out.println("short  : " + s);  // 42
System.out.println("int    : " + i);  // 42
System.out.println("long   : " + l);  // 42
System.out.println("float  : " + f);  // 42.0
System.out.println("double : " + d);  // 42.0

// char to int — char's Unicode value is used
char  ch  = 'A';
int   val = ch;    // char → int (auto)
System.out.println(val);  // 65

Output

byte : 42 short : 42 int : 42 long : 42 float : 42.0 double : 42.0 65

2. Narrowing Casting (Explicit / Manual)

Converting a larger type to a smaller type. Must be done manually by writing the target type in parentheses. Data loss may occur — the extra bits are simply discarded.

☕ JavaNarrowing Casting

double d = 9.99;
int    i = (int) d;       // double → int: decimal truncated (not rounded)
System.out.println(d);    // 9.99
System.out.println(i);    // 9  ← 0.99 is lost

// int to byte — overflow may occur
int  bigInt = 130;
byte b      = (byte) bigInt;  // 130 is outside byte range (-128 to 127)
System.out.println(b);         // -126  ← data corruption due to overflow

// Narrowing the full chain
double source = 1234.56;
long   toLong = (long) source;   // 1234
int    toInt  = (int)  toLong;   // 1234
short  toShort= (short)toInt;    // 1234  (fits)
byte   toByte = (byte) toShort;  // 1234 % 256 = 210 → wraps to -46

System.out.println("double → long  : " + toLong);
System.out.println("long   → int   : " + toInt);
System.out.println("int    → short : " + toShort);
System.out.println("short  → byte  : " + toByte);

Output

9.99 9 -126 double → long : 1234 long → int : 1234 int → short : 1234 short → byte : -46

Feature	Widening (Implicit)	Narrowing (Explicit)
Direction	Small type → Large type	Large type → Small type
Syntax	Automatic — no extra code	Manual — (targetType) value
Data loss?	No	Yes — truncation or overflow possible
Example	int i = 42; double d = i;	double d = 9.9; int i = (int) d;
Compile error?	No	Yes if you forget the cast operator
Runtime error?	No	No — but result may be unexpected

How to Choose the Right Data Type

Choosing the right data type makes your code correct, efficient, and readable. Here is a practical decision guide for real-world Java development:

🔢

Whole Numbers → int by default

Use int for counters, ages, IDs, indices, loop variables. Switch to long only when values might exceed 2.1 billion — timestamps, file sizes, world-scale counts.

📐

Decimal Numbers → double by default

Use double for prices, measurements, scientific values, percentages. Only use float if memory is critically constrained (GPU buffers, ML model weights).

💰

Money / Exact Decimals → BigDecimal

Never use float or double for money — they cannot represent 0.1 exactly. Use java.math.BigDecimal for financial calculations requiring exact precision.

🔤

Single Character → char

Use char for individual characters, grade letters, menu options. For sequences of characters always use String.

✅

True/False States → boolean

Use boolean for flags, conditions, enable/disable switches. Name it with is/has/can prefix: isActive, hasRole, canEdit.

🏷️

Small Memory-Critical → byte/short

Use byte for raw binary data, file I/O buffers, image pixels, network packets. Use short only in legacy protocols or large arrays where each byte matters.

Scenario	Recommended Type	Reason
Age of a person	int	Max ~150, always whole number — int is the default
World population	long	8.1 billion exceeds int's max of 2.1 billion
Product price (₹99.99)	double	Decimal needed; double is default for decimal math
Bank account balance	BigDecimal	Exact decimal required — float/double have rounding errors
Student pass/fail	boolean	Only two states — true or false
Grade letter (A, B, C)	char	Single character
Student name	String	Sequence of characters
Pixel color value (0–255)	byte or int	byte saves memory; int is simpler for arithmetic
Unix timestamp (milliseconds)	long	Milliseconds since 1970 exceeds int range
Loop counter	int	Standard — int is default for indices
Scientific measurement	double	High precision needed; double provides ~15 digits
Raw network packet data	byte[]	Network protocols work in bytes

Complete Java Program — Putting It All Together

Let us write one complete program that uses all 8 primitive types, String, arrays, wrapper class utility, and type casting — all in a single realistic student information system.

☕ JavaStudentProfile.java

import java.util.Scanner;

/**
 * StudentProfile.java
 * Demonstrates all 8 primitive types, String, array, wrapper classes,
 * literals, and type casting in one realistic program.
 */
public class StudentProfile {

    // Class constants using appropriate types
    static final int    MAX_MARKS    = 100;
    static final double PASS_PERCENT = 40.0;
    static final char   HIGHEST_GRADE = 'O';

    public static void main(String[] args) {

        // ---- 8 PRIMITIVE TYPES ----
        byte  rollNumber = 42;              // byte: small whole number
        short batchYear  = 2026;            // short: year fits in short
        int   studentId  = 1_00_001;        // int: large ID with underscore
        long  aadhaarNum = 1234_5678_9012L; // long: 12-digit Aadhaar
        float attendance = 87.5f;           // float: percentage
        double gpa       = 8.75;            // double: GPA precision
        char  section    = 'A';             // char: section label
        boolean isActive = true;            // boolean: enrollment status

        // ---- STRING ----
        String name    = "Rahul Sharma";
        String course  = "B.Tech CSE";
        String college = "Tech Sustainify University";

        // ---- ARRAY ----
        int[] subjectMarks = {88, 92, 79, 95, 85};

        // ---- CALCULATIONS using appropriate types ----
        int totalMarks = 0;
        for (int mark : subjectMarks) {
            totalMarks += mark;
        }
        double percentage = (totalMarks / (double)(subjectMarks.length * MAX_MARKS)) * 100;

        // ---- TYPE CASTING ----
        int roundedGpa  = (int) gpa;           // narrowing: 8.75 → 8
        double longToDouble = (double) studentId; // widening: int → double

        // ---- WRAPPER CLASS UTILITY ----
        String gpaStr   = Double.toString(gpa);      // double → String
        String idBinary = Integer.toBinaryString(studentId % 256); // binary
        char   sectionUpper = Character.toUpperCase(section); // already upper

        // ---- GRADE using char ----
        char grade;
        if      (percentage >= 90) grade = 'O';   // Outstanding
        else if (percentage >= 75) grade = 'A';
        else if (percentage >= 60) grade = 'B';
        else if (percentage >= PASS_PERCENT) grade = 'C';
        else                       grade = 'F';

        boolean hasPassed = percentage >= PASS_PERCENT;

        // ---- DISPLAY ----
        System.out.println("╔══════════════════════════════════════╗");
        System.out.println("║          STUDENT PROFILE             ║");
        System.out.println("╠══════════════════════════════════════╣");
        System.out.printf ("║ Name      : %-24s║%n", name);
        System.out.printf ("║ Course    : %-24s║%n", course);
        System.out.printf ("║ College   : %-24s║%n", college);
        System.out.printf ("║ Roll No   : %-24d║%n", (int) rollNumber);
        System.out.printf ("║ Section   : %-24c║%n", sectionUpper);
        System.out.printf ("║ Batch     : %-24d║%n", (int) batchYear);
        System.out.printf ("║ GPA       : %-24s║%n", gpaStr);
        System.out.printf ("║ GPA (int) : %-24d║%n", roundedGpa);
        System.out.printf ("║ Attendance: %-23.1f%%║%n", attendance);
        System.out.printf ("║ Total     : %-24d║%n", totalMarks);
        System.out.printf ("║ Percentage: %-23.2f%%║%n", percentage);
        System.out.printf ("║ Grade     : %-24c║%n", grade);
        System.out.printf ("║ Status    : %-24s║%n", hasPassed ? "PASS" : "FAIL");
        System.out.printf ("║ Active    : %-24b║%n", isActive);
        System.out.println("╚══════════════════════════════════════╝");

Output

╔══════════════════════════════════════╗ ║ STUDENT PROFILE ║ ╠══════════════════════════════════════╣ ║ Name : Rahul Sharma ║ ║ Course : B.Tech CSE ║ ║ College : Tech Sustainify University║ ║ Roll No : 42 ║ ║ Section : A ║ ║ Batch : 2026 ║ ║ GPA : 8.75 ║ ║ GPA (int) : 8 ║ ║ Attendance: 87.5% ║ ║ Total : 439 ║ ║ Percentage: 87.80% ║ ║ Grade : A ║ ║ Status : PASS ║ ║ Active : true ║ ╚══════════════════════════════════════╝

Practice This Code — Live Editor

Java Data Types — Interview Questions

These are the most frequently asked Java interview questions on data types — from beginner to intermediate level.

'int' is a primitive type — it stores the value directly in memory (stack), cannot be null, has no methods, and is faster. 'Integer' is a wrapper class (non-primitive, object) — it wraps int in an Object, can be null, has utility methods like Integer.parseInt(), Integer.MAX_VALUE, Integer.toBinaryString(). Java auto-converts between them via autoboxing (int → Integer) and unboxing (Integer → int).

In C/C++, char is 1 byte because it uses ASCII encoding (only 128-256 characters). Java uses UTF-16 Unicode encoding, which requires 2 bytes (16 bits) to represent characters from across all the world's writing systems — over 65,000 code points in the Basic Multilingual Plane. This makes Java char fundamentally different: it can store any Unicode character, not just ASCII. This is why Java programs work correctly with Indian scripts, Chinese characters, emoji, and symbols worldwide.

byte range is -128 to 127. If you write byte b = 128; it is a compile error — 'incompatible types: possible lossy conversion from int to byte'. If you force it with narrowing cast: byte b = (byte) 128; — the value wraps around to -128 due to two's complement overflow. Binary of 128 is 10000000 — as a signed 8-bit value this is -128. This is called integer overflow and is a common source of bugs in low-level programming.

float and double use IEEE 754 binary floating-point, which cannot represent many decimal fractions exactly — including 0.1, 0.2, and 0.3. For example, 0.1 + 0.2 in Java equals 0.30000000000000004, not 0.3. In financial calculations this tiny error accumulates into significant wrong amounts over millions of transactions. Use java.math.BigDecimal for exact decimal arithmetic in banking, e-commerce, and any financial application.

Practice Questions — Test Your Knowledge

Test your understanding of Java Data Types. Try to answer each question before revealing the answer.

1. What is the output? int a = 5; int b = 2; System.out.println(a / b); System.out.println(a % b);

Easy

2. Will this compile? long l = 3000000000; Explain.

Medium

3. What is the output? char c = 'A'; System.out.println(c + 1); System.out.println((char)(c + 1));

Medium

4. What data type would you use to store a 12-digit Aadhaar number? Why?

Easy

5. What is the output and why? double d = 0.1 + 0.2; System.out.println(d); System.out.println(d == 0.3);

Medium

✅ AnswerOutput: 0.30000000000000004, then false. IEEE 754 binary floating-point cannot represent 0.1 or 0.2 exactly — they are infinite repeating binary fractions. Adding them gives 0.30000000000000004, not exactly 0.3. Therefore d == 0.3 is false. This is why you should never compare floating-point values with == — use Math.abs(d - 0.3) < 1e-10 instead. For exact arithmetic, use BigDecimal.

6. What is the difference between String s1 = 'Java' and String s2 = new String('Java')? Which is better?

Medium

✅ Answers1 = "Java" creates a String in the String Pool (or reuses an existing one). If another variable also points to "Java", they share the same object. s2 = new String("Java") always creates a new String object on the heap, separate from the pool. s1 == s1 is true (same pool object), but s1 == s2 is false (different objects). String literals (s1 style) are preferred — they save memory through pool reuse and are more readable.

7. What is the result of (byte)(200)? Explain the calculation.

Hard

8. Can you store the value 65535 in a char? Can you store -1 in a char?

Hard

✅ Answer65535: Yes. char is an unsigned 16-bit integer with range 0 to 65535. char c = (char) 65535; is valid — it represents \uFFFF (a special Unicode character). -1: No directly. char cannot hold negative values — it is unsigned. However, (char)(-1) in Java results in 65535 (\uFFFF) due to binary representation, since -1 in two's complement 16-bit is all 1s = 65535. So the cast works but gives 65535, not -1.

Summary — What You Learned in Java Data Types

You have now mastered the complete Java type system — from the 8 primitive types to non-primitive reference types, wrapper classes, literals, and casting. Here is a quick recap:

Topic	Key Takeaway
Two categories	Primitive (8 types, store value) vs Non-Primitive (store reference)
byte	1 byte, -128 to 127 — raw data, I/O buffers, pixel values
short	2 bytes, -32768 to 32767 — rarely used; legacy protocols
int	4 bytes, ±2.1 billion — default integer type for most use cases
long	8 bytes, ±9.2 × 10¹⁸ — timestamps, IDs, large counts; needs L suffix
float	4 bytes, ~7 digits — memory-constrained decimals; needs f suffix
double	8 bytes, ~15 digits — default decimal type; no suffix needed
char	2 bytes, 0–65535 — single Unicode character; single quotes only
boolean	true or false only — not interchangeable with int unlike C/C++
String	Immutable; use .equals() for comparison, never ==
Wrapper Classes	Byte, Short, Integer, Long, Float, Double, Character, Boolean — for collections, parsing, utility
Autoboxing/Unboxing	Automatic primitive ↔ wrapper conversion; beware null unboxing NPE
Literals	0b prefix=binary, 0x=hex, 0=octal, _ separator for readability
Widening Casting	Automatic, no data loss: byte→short→int→long→float→double
Narrowing Casting	Manual (targetType)value — may lose data; truncates decimals
Money/Exact decimals	Never use float/double — use BigDecimal for financial calculations

The next step is understanding Java Variables in depth — declaration, initialization, scope, naming rules, the var keyword, and the difference between local, instance, and static variables. Continue to the next chapter: Java Variables →

Java Data Types — Primitive & Non-Primitive

Java Data Types — Overview

Two Categories of Java Data Types

Primitive Data Types — All 8 Types

Integer Types — byte, short, int, long

byte — 1 Byte

short — 2 Bytes

int — 4 Bytes (Default Integer Type)

long — 8 Bytes

Floating-Point Types — float, double

float — 4 Bytes, Single Precision

double — 8 Bytes, Double Precision (Default)

Character Type — char

Common Escape Sequences for char

Boolean Type — boolean

Java Literals — Writing Values in Code

Integer Literals

Floating-Point Literals

char, boolean, and String Literals

Non-Primitive (Reference) Data Types

String — Most Used Non-Primitive Type

Wrapper Classes & Autoboxing / Unboxing

Autoboxing and Unboxing (Java 5+)

Type Casting — Widening & Narrowing

1. Widening Casting (Implicit / Automatic)

2. Narrowing Casting (Explicit / Manual)

How to Choose the Right Data Type

Complete Java Program — Putting It All Together

Practice This Code — Live Editor

Java Data Types — Interview Questions

Practice Questions — Test Your Knowledge

Summary — What You Learned in Java Data Types

Frequently Asked Questions (FAQ) — Java Data Types