Data Types in Java

Data types in Java define the type and size of data that can be stored in a variable. They are broadly classified into two categories: primitive and non-primitive. Data types help programmers create variables to store data efficiently and ensure the correct type of value is assigned.

Primitive Data Types

Primitive data types are basic types used to store single values. They are predefined in Java and have fixed sizes.

Overview Table of Primitive Data Types

Detailed Explanation of Primitive Data Types

1. Byte

   • A primitive data type used to store small integer values.
   • Size: 1 byte (8 bits).
   • Range: -128 to 127.
   • Example: byte age = 25;

   Note: Ideal for saving memory when dealing with small numbers.

2. Short

   • A primitive data type for slightly larger integers than byte.
   • Size: 2 bytes (16 bits).
   • Range: -32,768 to 32,767.
   • Example: short temperature = -5000;

   Note: Less commonly used but helpful in specific scenarios like legacy systems.

3. Int

   • The default primitive data type for integers in Java.
   • Size: 4 bytes (32 bits).
   • Range: -2,147,483,648 to 2,147,483,647.
   • Example: int count = 100000;

   Note: Any integer literal (e.g., 42) is treated as an int by default.

4. Long

   • A primitive data type for very large integers.
   • Size: 8 bytes (64 bits).
   • Range: -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807.
   • Example: long distance = 12345678901L;

   Note: Use the suffix L or l for literals exceeding int capacity (e.g., 12345678901L). If the value fits within int range, the suffix is optional, but L is preferred for clarity.

5. Float

   • A primitive data type for single-precision floating-point numbers (decimals).
   • Size: 4 bytes (32 bits).
   • Range: Approximately ±3.4E-38 to ±3.4E+38 with 7-digit precision.
   • Example: float price = 19.99f;

   Note: Requires the suffix f or F for literals (e.g., 5.75f). Integers stored in float are converted to decimals (e.g., 5 becomes 5.0). Precision is limited beyond 7 digits.

6. Double

   • The default primitive data type for floating-point numbers with higher precision.
   • Size: 8 bytes (64 bits).
   • Range: Approximately ±1.7E-308 to ±1.7E+308 with 15-digit precision.
   • Example: double pi = 3.14159;

   Note: No suffix is needed for decimal literals, as double is the default. For large integers exceeding int or long ranges assigned to double, use L (e.g., 12345678901L), though this is rare.

7. Char

   • A primitive data type for storing single characters.
   • Size: 2 bytes (16 bits).
   • Range: 0 to 65,535 (Unicode values).
   • Example: char letter = 'A';

   Note: Characters are enclosed in single quotes (' '). Java uses Unicode, but ASCII (0–127) is common (e.g., 'A' = 65, 'a' = 97, '0' = 48). The extra 8 bits support international characters.

8. Boolean

   • A primitive data type for storing logical values.
   • Size: 1 bit (though implementation may vary).
   • Values: true or false.
   • Example: boolean isActive = true;

   Note: Used for conditions and flags.

Non-Primitive Data Types

Non-primitive data types are derived from classes or interfaces and can store multiple values or complex data. They are created by the programmer or provided by Java.

Examples of Non-Primitive Data Types