Data Types

🔍 What Is It?

Primitive Types (8 total)

• →byte: 8-bit signed, range -128 to 127
• →short: 16-bit signed, range -32,768 to 32,767
• →int: 32-bit signed, range -2^31 to 2^31-1 (default for integers)
• →long: 64-bit signed, use L suffix: 100L
• →float: 32-bit IEEE 754, use f suffix: 3.14f
• →double: 64-bit IEEE 754 (default for decimals)
• →char: 16-bit Unicode character, range 0 to 65,535
• →boolean: true or false

Reference Types

• →String — immutable sequence of characters
• →Wrapper Classes — Integer, Long, Double, Boolean, etc. (primitives as objects)
• →Arrays — fixed-size ordered collection
• →Classes/Interfaces — any object type

Type Hierarchy

• →All reference types extend Object
• →Primitives do NOT extend Object (this is why generics don't support primitives directly)

🎯 Why Do We Need It?

Primitives exist for performance:

• →An int is 4 bytes on the stack — direct value access
• →An Integer is an object on the heap — pointer + object header overhead (~16 bytes)
• →For a list of 1 million numbers, int[] uses ~4MB; List<Integer> uses ~20MB+

Reference types exist for:

• →Null representation (primitives cannot be null)
• →Object-oriented features (methods, inheritance)
• →Collections API compatibility (generics require objects)
• →Nullable database columns (Integer can be null, int cannot)

🏗️ What Happens in Real Projects?

Common patterns in enterprise code:

• →Database mapping — use Integer (not int) for nullable columns
• →Financial calculations — use BigDecimal (not double) for money
• →Bit flags — use int or long for performance-critical flags
• →Enums — prefer over int constants for type safety
• →var keyword — use for local type inference (Java 10+)

⚙️ How It Works

Autoboxing/Unboxing

Java automatically converts between primitives and wrappers:

Integer boxed = 42;        // autoboxing: int -> Integer
int primitive = boxed;     // unboxing: Integer -> int

Integer Cache (-128 to 127)

Java caches Integer objects from -128 to 127. This is why == works for small integers but fails for larger ones — a classic interview trap.

String Pool

String literals are interned in the String Pool (part of Heap). Two literals with the same value share the same object. new String("hello") bypasses the pool.

💻 Example

Data Type Gotchas and Best Practices — The bugs that trip up developers who do not understand Java type internals.

// Integer cache: -128 to 127 are cached
Integer x = 127;
Integer y = 127;
System.out.println(x == y);  // true (same cached object)

Integer p = 128;
Integer q = 128;
System.out.println(p == q);  // FALSE! (different objects)
System.out.println(p.equals(q));  // true (always use equals)

// String pool
String s1 = "hello";
String s2 = "hello";
System.out.println(s1 == s2);  // true (same pool object)

String s3 = new String("hello");
System.out.println(s1 == s3);  // FALSE! (new object on heap)
System.out.println(s1.equals(s3));  // true (always use equals)

// NullPointerException from unboxing
Integer nullableValue = null;  // from database: nullable column
int primitive = nullableValue;  // NPE! unboxing null throws NPE

🤔 Common Confusions

🚨 Common Production Issues

✅ Best Practices

🏛️ Architect's Note

💬 Frequently Asked Questions

🎯 Key Takeaways

🔗 Related Topics

🎯 Practice this topic in interviews

↗ Where this topic fits