In Java, primitive data types are basic data types that are not objects. They include:
int: 32-bit signed integer. Used for storing whole numbers.
double: 64-bit floating-point number. Used for storing decimal numbers.
char: 16-bit Unicode character. Used for storing single characters.
boolean: stores either true or false values. Used for decision making.
byte: 8-bit signed integer. Used for storing small whole numbers.
short: 16-bit signed integer. Used for storing smaller whole numbers.
long: 64-bit signed integer. Used for storing large whole numbers.
float: 32-bit floating-point number. Used for storing decimal numbers with less precision.
Here are the 8 primitive data types in Java along with examples:
byte: 8-bit signed integer. Example: byte b = 100;
short: 16-bit signed integer. Example: short s = 20000;
int: 32-bit signed integer. Example: int i = 2000000000;
long: 64-bit signed integer. Example: long l = 2000000000000000000L;
float: 32-bit floating point. Example: float f = 3.14f;
double: 64-bit floating point. Example: double d = 3.14;
char: 16-bit Unicode character. Example: char c = ‘A’;
boolean: represents a boolean value (true or false). Example: boolean b = true;
Storage Mechanism of Primitive Datatypes in Java:
In Java, primitive data types are stored directly in the memory location designated for the variable. They are stored in the stack, which is a contiguous block of memory that stores data in a Last-In-First-Out (LIFO) order.
Each primitive data type has a specific number of bytes reserved in memory and is stored in the stack as raw binary data. For example, an int type variable is stored as 4 consecutive bytes in memory, while a char type variable is stored as 2 consecutive bytes in memory.
Because primitive data types are stored directly in memory, they are faster to access than objects, which are stored in the heap and require additional memory allocation and deallocation. However, because they are stored in the stack, their memory is freed when the function call that created the variable returns. This makes the stack an efficient way to store data for short-lived variables, but it can also lead to stack overflow errors for large or deeply nested data structures.
Hello World Example with Primitive Datatypes in Java:
public class HelloWorld {
public static void main(String[] args) {
String message = "Hello World";
int age = 30;
double weight = 65.5;
char initial = 'A';
boolean isMale = true;
System.out.println(message);
System.out.println("Age: " + age);
System.out.println("Weight: " + weight);
System.out.println("Initial: " + initial);
System.out.println("Is Male: " + isMale);
}
}Difference between Primitive and Non-Primitive Data types:
The Java language defines primitive data types (such as int, float, char, etc.) as fundamental data types that can represent straightforward things like integers or characters. Non-primitive data types, or reference data types, on the other hand, are data types that refer to actual objects. Among other things, non-primitive data types include classes, arrays, and interfaces.
Non-primitive data types behave more complexly than primitive data types since they can store numerous values and include ways for modifying those values. However, because non-primitive data types are kept on the heap and need more memory than primitive data types, which are stored on the stack, this greater complexity comes at the expense of memory and performance overhead.