Java - Data Types

---

---

Java data types define the type and value range of the data for the different types of variables, constants, method parameters, return types, etc. The data type tells the compiler about the type of data to be stored and the required memory. To store and manipulate different types of data, all variables must have specified data types.

Based on the data type of a variable, the operating system allocates memory and decides what can be stored in the reserved memory. Therefore, by assigning different data types to variables, you can store integers, decimals, or characters in these variables.

The Java data types are categorized into two main categories −

• Primitive Data Types
• Reference/Object Data Types

Java Primitive Data Types

Primitive data types are predefined by the language and named by a keyword. There are eight primitive data types supported by Java. Below is the list of the primitive data types:

• byte
• short
• int
• long
• float
• double
• boolean
• char

byte Data Type

The byte data type is an 8-bit signed two's complement integer with a minimum value of -128 (-2⁷) and a maximum value of 127 (inclusive) (2⁷ -1). 

The default value of a byte variable is 0, which is used to save space in large arrays, which is mainly beneficial in integers since a byte is four times smaller than an integer.

Example

byte a = 100;
byte b = -50;

short Data Type

The short data type is a 16-bit signed two's complement integer, which provides a range of values from -32,768 (-2¹⁵) to 32,767 (inclusive) (2¹⁵ -1). Like the byte data type, the short data type is also beneficial for saving memory, as it occupies less space compared to an integer, being only half the size.

The default value for a short variable is 0.

Example

short s = 10000;
short r = -20000;

int Data Type

The int data type is a 32-bit signed two's complement integer, allowing for a wide range of values from -2,147,483,648 (-2³¹) to 2,147,483,647 (inclusive) (2³¹ -1). Here the integer is generally used as the default data type for integral values unless there is a concern about memory.

The default value for an int variable is 0.

Example

int a = 100000;
int b = -200000;

long Data Type

The long data type is a 64-bit signed two's complement integer, capable of representing a vast range of values from -9,223,372,036,854,775,808 (-2⁶³) to 9,223,372,036,854,775,807 (inclusive) (2⁶³ -1). This data type is used when a wider range than int is needed, where its default value is 0L.

Example

long a = 100000L;
long b = -200000L;

float Data Type

The float data type is a single-precision 32-bit IEEE 754 floating-point representation. It is particularly useful for saving memory in large arrays of floating-point numbers. Its default value is 0.0f. However, it's important to note that the float data type is not suitable for precise values, such as currency, due to potential rounding errors in floating-point arithmetic.

Example

float f1 = 234.5f;

double Data Type

The double data type is a double-precision 64-bit IEEE 754 floating-point representation, which is generally used as the default data type for decimal values, generally the default choice. Double data type should never be used for precise values such as currency, where its default value is 0.0d.

Example

double d1 = 123.4;

boolean Data Type

The boolean data type represents a single bit of information and can hold one of two possible values: true or false. This data type is used for simple flags that track true/false conditions where its default value is false.

Example

boolean one = true;

char Data Type

The char data type is a single 16-bit Unicode character, which represents a wide range of characters from different languages and symbols. With a range '\u0000' (or 0) to '\uffff' (or 65,535 inclusive). This data type is primarily used to store individual characters.

Example

char letterA = 'A'

Example of Primitive Data Types

Following examples shows the usage of the various primitive data types we've discussed above. We've used add operations on numeric data types, whereas boolean and char variables are printed as such.

public class JavaTester {
   public static void main(String args[]) {

      byte byteValue1 = 2;
      byte byteValue2 = 4;
      byte byteResult = (byte)(byteValue1 + byteValue2);

      System.out.println("Byte: " + byteResult);

      short shortValue1 = 2;
      short shortValue2 = 4;
      short shortResult = (short)(shortValue1 + shortValue2);

      System.out.println("Short: " + shortResult);

      int intValue1 = 2;
      int intValue2 = 4;
      int intResult = intValue1 + intValue2;

      System.out.println("Int: " + intResult);

      long longValue1 = 2L;
      long longValue2 = 4L;
      long longResult = longValue1 + longValue2;

      System.out.println("Long: " + longResult);

      float floatValue1 = 2.0f;
      float floatValue2 = 4.0f;
      float floatResult = floatValue1 + floatValue2;

      System.out.println("Float: " + floatResult);

      double doubleValue1 = 2.0;
      double doubleValue2 = 4.0;
      double doubleResult = doubleValue1 + doubleValue2;

      System.out.println("Double: " + doubleResult);

      boolean booleanValue = true;

      System.out.println("Boolean: " + booleanValue);

      char charValue = 'A';

      System.out.println("Char: " + charValue);     
   }
}

Output

Byte: 6
Short: 6
Int: 6
Long: 6
Float: 6.0
Double: 6.0
Boolean: true
Char: A

Java Non-Primitive (Reference/Object) Data Types

The non-primitive data types are not predefined. The reference data types are created using defined constructors of the classes. They are used to access objects. These variables are declared to be of a specific type that cannot be changed. For example, Employee, Puppy, etc.

The following are the non-primitive (reference/object) data types −

• String: The string is a class in Java, and it represents the sequences of characters.
• Arrays: Arrays are created with the help of primitive data types and store multiple values of the same type.
• Classes: The classes are the user-defined data types and consist of variables and methods.
• Interfaces: The interfaces are abstract types that are used to specify a set of methods.

The default value of any reference variable is null. A reference variable can be used to refer to any object of the declared type or any compatible type.

Example

The following example demonstrates the reference (or, object) data types.

// Creating an object of 'Animal' class
Animal animal = new Animal("giraffe");

// Creating an object of 'String' class
String myString = new String("Hello, World!");