Primitive Data Types

Values and Types

  • The atomic indivisible unit of data in computer programming is called a value.

  • Values are the most basic things that a computer program manipulates or calculates.

For example, the number 42 is a value. So is "Hello World!".

  • Each value belongs to a type.

  • The type of a value determines its interpretation by the computer and the operations that can be performed on it.

For example, the value 42 is of type int (short for integer) and the value "Hello World!" is of type str (short for string, so-called because it contains a string of letters).

  • In Java, every value has a type, and every type is defined by the Java programming language.

Primitive Data Types

Java comes with the following built-in numeric data types:

  1. byte: 8-bit signed integer. Range: -128 to 127.
  2. short: 16-bit signed integer. Range: -32,768 to 32,767.
  3. int: 32-bit signed integer. Range: -2,147,483,648 to 2,147,483,647.
  4. long: 64-bit signed integer. Range: -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807.
  5. float: 32-bit floating point number.
  6. double: 64-bit floating point number.

Other primitive data types include:

  1. boolean: Represents true or false values.
  2. char: Represents a single 16-bit Unicode character.

Comparison with Python

Primitive Data Types vs. Objects

  • Java has a clear distinction between primitive data types (e.g., int, char, float, boolean) and objects. Primitive data types in Java are not objects and are stored directly in memory. They are more efficient but have fewer capabilities compared to objects.

  • Python does not have primitive data types in the same way Java does. In Python, everything is an object, including what Java would consider primitives like integers and floats. This means even simple data types in Python have methods and are more versatile, though potentially less efficient in terms of memory.

Wrappers and Autoboxing

Java has wrapper classes for each primitive type (e.g., Integer for int, Float for float). These wrappers allow primitive values to be treated as objects when necessary. Java also supports autoboxing, which automatically converts between primitives and their corresponding wrapper types.

In Python, since everything is an object, there is no need for separate wrapper classes or autoboxing.

Fixed-Size Memory Allocation

Java uses fixed-size memory allocation for primitive types, which makes memory usage predictable and efficient. For example, an int always uses 4 bytes, a float uses 4 bytes, etc.

In contrast, Python’s objects (including what would be primitives in Java) are dynamically allocated, meaning their memory size can vary. Python integers and floats use more memory than their Java counterparts because they are objects and include metadata.

Type Conversion

In Java, there are two types of type conversion:

  1. Automatic Type Conversion: Java supports automatic type conversion when values of different types are combined in an expression. This is known as type promotion.

  2. Explicit Type Conversion (Type Casting): Java also supports explicit type conversion, known as type casting, which allows you to convert a value from one type to another.

Automatic Type Conversion (Type Promotion)

  • When values of different types are combined in an expression, Java automatically promotes the values to a common type.

  • The rules for type promotion are as follows:

  1. If one of the values is a double, the other value is converted to a double.
  2. If one of the values is a float, the other value is converted to a float.
  3. If one of the values is a long, the other value is converted to a long.
  4. Otherwise, both values are converted to an int.

For example:

int a = 10;
long b = 20;
float c = 30.0f;
double d = 40.0;

double result = a * b + c / d;

In this example, the int value a is promoted to a long, the float value c is promoted to a double, and the result is a double.

In other words, the data type of the result is determined by the data type of the most precise or the operand with the highest memory size.

Explicit Type Conversion (Type Casting)

  • Java allows you to explicitly convert a value from one type to another using type casting.

  • Type casting is done by placing the desired type in parentheses before the value to be converted.

For example:

int a = 10;
long b = (long) a;

In this example, the int value a is explicitly cast to a long.

  • Type casting can result in data loss if the value being converted cannot be represented in the target type.

For example:

int a = 1000;
byte b = (byte) a;

In this example, the int value a is cast to a byte. Since a byte can only represent values from -128 to 127, the result is -24, which is the remainder of 1000 divided by 256.