Java

Java Data Types: Complete Reference with Memory Size and Examples

By Utility Zone · 2025-11-06T09:34:37.583267

Java is a statically typed language, meaning every variable must be declared with a data type before use. Java provides a comprehensive set of data types organized into two main categories: primitive data types and reference data types.¹²³

Primitive Data Types (8 Types)

Primitive data types store actual values directly in memory and have fixed sizes defined by the Java language. They are stored on the stack and provide fast access.²⁴⁵⁶

Integer Types (Signed Whole Numbers)

1. byte

The smallest integer type, useful for memory-efficient storage in large arrays.⁷¹²

Size: 1 byte (8 bits)⁵²
Range: -128 to 127¹²
Default Value: 0²⁵
Example:²

byte age = 25;
byte temperature = -50;

2. short

A 16-bit integer type used when memory conservation in large arrays is important but byte range is insufficient.⁸¹

Size: 2 bytes (16 bits)⁵²
Range: -32,768 to 32,767¹²
Default Value: 0⁵²
Example:²

short temp = -200;
short year = 2025;

3. int

The default choice for integer values. Most operations in Java use int by default.⁸⁷¹²

Size: 4 bytes (32 bits)⁵²
Range: -2,147,483,648 to 2,147,483,647³²
Default Value: 0²⁵
Example:²

int population = 2000000;
int count = 100;

4. long

Used for very large integer values that exceed int range.⁷⁸¹

Size: 8 bytes (64 bits)⁵²
Range: -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807³⁵
Default Value: 0L⁵²
Example:²

long worldPopulation = 7800000000L;  // Note the 'L' suffix
long distance = 999999999999L;

Important: When assigning a value to a long variable, append the letter L to indicate it's a long literal.²

Floating-Point Types (Decimal Numbers)

5. float

A single-precision 32-bit floating-point type used to save memory in large arrays of decimal numbers.⁷³¹

Size: 4 bytes (32 bits)⁵²
Precision: ~6-7 significant decimal digits³⁵²
Default Value: 0.0f⁵²
Example:²

float pi = 3.14f;  // Note the 'f' suffix
float distance = 12.5f;

Important: Always append f to float literals. Never use float for precise values like currency.⁷³

6. double

A double-precision 64-bit floating-point type providing better accuracy than float. This is the default choice for decimal numbers.¹³⁷²

Size: 8 bytes (64 bits)⁵²
Precision: ~15-16 significant decimal digits³²⁵
Default Value: 0.0d²⁵
Example:²

double precisePi = 3.141592653589793;
double temperature = 98.6;

Character Type

7. char

Stores a single Unicode character using 16-bit encoding.¹³²

Size: 2 bytes (16 bits)⁵²
Range: 0 to 65,535 (Unicode characters)¹²
Default Value: '\u0000'⁵²
Example:²

char grade = 'A';
char symbol = '@';
char unicode = '\u0041';  // Represents 'A'

Boolean Type

8. boolean

Represents logical values used in conditional statements and control flow.⁸¹²

Size: 1 byte (JVM-dependent, typically 1 byte)⁵²
Values: true or false³²
Default Value: false²⁵
Example:²

boolean isJavaFun = true;
boolean flag = false;

Reference Data Types

Reference data types store references (memory addresses) that point to objects stored in memory (the heap), rather than storing the values directly. All reference types default to null if not initialized.⁴⁹⁵

1. String

The most commonly used reference type, representing sequences of characters.⁹

Size: Variable (stored on heap)⁵²
Default Value: null⁵²
Example:⁹

String language = "Java";
String name = new String("John");
String message = "Hello, World!";

Key Point: Strings are immutable in Java, meaning once created, they cannot be modified.¹⁰

2. Arrays

Collections of elements of the same type stored sequentially.¹¹¹²

Size: Variable (stored on heap)⁵
Default Value: null⁵
Element Access: Uses 0-based indexing¹¹
Example:¹²

int[] numbers = {1, 2, 3, 4, 5};
String[] names = new String[^10];
double[] scores = {95.5, 87.3, 92.1};

// Accessing elements
int first = numbers[^0];  // Returns 1

Important: When arrays are passed to methods, the method receives a copy of the reference. Changes to array elements persist after method execution.¹²

3. Classes (Objects)

Custom data types created by programmers that bundle data and methods together.¹³⁵

Size: Variable (stored on heap)⁵
Default Value: null⁵
Example:

public class Student {
    String name;
    int age;
}

Student student = new Student();

4. Interfaces

Abstract reference types that define a contract for implementing classes.¹³

Size: Variable (stored on heap)⁵
Default Value: null⁵
Example:

interface Animal {
    void speak();
}

class Dog implements Animal {
    public void speak() {
        System.out.println("Woof!");
    }
}

Animal animal = new Dog();

Wrapper Classes

Java provides wrapper classes for each primitive type, allowing you to treat primitives as objects. These classes are useful for:¹⁴¹⁵

Using primitives in collections (which require objects)
Accessing special methods and constants
Converting between types

Primitive	Wrapper Class
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

Example:¹⁵¹⁴

// Autoboxing (primitive to wrapper)
Integer num = 100;
Double value = 3.14;

// Unboxing (wrapper to primitive)
int primitive = num;  // Converts back to int

// Using wrapper class methods
int maxInt = Integer.MAX_VALUE;  // 2,147,483,647
int minInt = Integer.MIN_VALUE;  // -2,147,483,648
double maxDouble = Double.MAX_VALUE;

Key Differences: Primitive vs Reference Types

Aspect	Primitive	Reference
Storage Location	Stack (direct values)	Heap (memory addresses)
Memory	Fixed size	Variable size
Default Value	Type-specific (0, false, etc.)	null
Speed	Faster	Slower
Copy Behavior	Copy by value	Copy by reference
Examples	int, double, boolean	String, Arrays, Objects

Practical Example: Using All Data Types

public class DataTypesDemo {
    public static void main(String[] args) {
        // Primitive Types
        byte myByte = 100;
        short myShort = 5000;
        int myInt = 1000000;
        long myLong = 15000000000L;
        
        float myFloat = 3.14f;
        double myDouble = 3.14159265359;
        
        char myChar = 'J';
        boolean myBoolean = true;
        
        // Reference Types
        String myString = "Java Programming";
        int[] myArray = {1, 2, 3, 4, 5};
        
        // Output
        System.out.println("byte: " + myByte);
        System.out.println("int: " + myInt);
        System.out.println("long: " + myLong);
        System.out.println("double: " + myDouble);
        System.out.println("String: " + myString);
        System.out.println("Array: " + java.util.Arrays.toString(myArray));
    }
}

Output:

byte: 100
int: 1000000
long: 15000000000
double: 3.14159265359
String: Java Programming
Array: [1, 2, 3, 4, 5]

Selection Guide

Use byte or short: When memory is critical and values fit within their range
Use int: For most integer values (default choice)
Use long: For very large numbers (population, distances)
Use float: Rarely, when memory is extremely limited
Use double: For all decimal calculations (default choice)
Use char: For single characters
Use boolean: For true/false conditions
Use String: For text data
Use arrays: For collections of same-type data
Use custom classes: For complex data structures combining multiple types

Understanding these data types and their memory requirements is essential for writing efficient, reliable Java applications.³¹² <span style="display:none">¹⁶¹⁷¹⁸</span>