Data Types Size & Range

Primitive types (int, char, boolean) are the basic building blocks. They store single values directly in memory (Stack). Non-Primitive (or Reference) types (Arrays, Strings, Objects) store a memory address pointing to a complex structure in the Heap.

A standard 32-bit Integer uses 32 bits (4 bytes) of memory. This allows it to store values up to 2^31 - 1 (approx 2.1 billion). This is a balance between range and memory efficiency for most calculations.

This is called "Overflow". In many languages (like Java/C++), the value "wraps around" to the minimum negative value. For example, adding 1 to the maximum Integer turns it into -2,147,483,648. This can cause catastrophic bugs.

Precision. A float is 32-bit (single precision) and has about 7 decimal digits of accuracy. A double is 64-bit (double precision) and has 15 digits of accuracy. Always use double for math unless you are extremely memory constrained.

Because computers use binary floating-point math (IEEE 754). Numbers like 0.1 cannot be represented perfectly in binary, just like 1/3 cannot be represented perfectly in decimal (0.333...). This results in tiny rounding errors.

Theoretically, a boolean is 1 bit (0 or 1). However, CPUs typically address memory in bytes, not bits. So, a single boolean variable often takes up a full byte (8 bits) for faster access. Arrays of booleans can be packed to use 1 bit each.

Signed types uses one bit (the Most Significant Bit) to represent the sign (+ or -), so they can store negative numbers. Unsigned types use all bits for the value, so they can store larger positive numbers but no negatives.

Type casting is converting a variable from one type to another. "Widening" (int -> double) is usually safe and automatic. "Narrowing" (double -> int) must be done manually because you might lose data (e.g., the decimal part is truncated).

A char stores a single character code (like ASCII or Unicode). Strings are simply arrays of chars. In Java/C#, a char is 2 bytes (16-bit) to support Unicode characters from different languages.

In many languages (Java, Python, C#), Strings cannot be changed once created. Modifying a string actually creates a brand new String object in memory. This improves security and thread-safety.

Void technically means "no type" or "absence of value". It is used as the return type for functions that perform an action but do not produce a result.

It depends on its fields + overhead. An empty object in Java takes about 16 bytes of overhead (header). Then you add the size of all its variables. Plus padding to align it to 8-byte boundaries.

Null is a special value for Reference types indicating that the variable does not point to any object in memory. Accessing a property of a null variable causes a "Null Pointer Exception" (the billion-dollar mistake).

Naming history. In standard C, int was 16-bit. long was 32-bit. As computers grew to 32-bit and 64-bit architectures, int became 32-bit standard, so we needed long long for 64-bit. Java simplified this: int is 32, long is 64.

The Stack is fast, organized memory for function calls and primitive variables; it cleans itself up automatically. The Heap is a large pool for objects (complex types); it requires Garbage Collection to free up unused memory.