Primitive vs reference storage in Java

Introduction

We use primitive and reference storage to hold data in Java. Primitives store simple values directly, while references store addresses to objects.

When you want to store simple data like numbers or true/false values.

When you want to store complex data like a group of values or behaviors in objects.

When you want to understand how Java handles memory for different types of data.

When you want to avoid unexpected changes by knowing if you are copying values or references.

When debugging issues related to data changes or memory usage.

Syntax

Java

public class PrimitiveVsReference {
    public static void main(String[] args) {
        // Primitive type example
        int number = 5;

        // Reference type example
        String text = new String("Hello");
    }
}

Primitive types store actual values directly in memory.

Reference types store a reference (address) to the object in memory.

Examples

Changing b does not affect a because primitives store values directly.

Java

int a = 10;
int b = a;
b = 20;
System.out.println(a); // prints 10

Changing s2 to a new string does not change s1 because strings are immutable and s2 now points to a new object.

Java

String s1 = new String("Hi");
String s2 = s1;
s2 = "Bye";
System.out.println(s1); // prints Hi

Arrays are reference types, so changing arr2 changes arr1 because both refer to the same object.

Java

int[] arr1 = {1, 2, 3};
int[] arr2 = arr1;
arr2[0] = 10;
System.out.println(arr1[0]); // prints 10

Changing x after copying does not affect y because primitives are copied by value.

Java

int x = 5;
int y = x;
x = 7;
System.out.println(y); // prints 5

Sample Program

This program shows how changing a copied primitive does not affect the original, but changing a copied reference affects the original object.

Java

public class PrimitiveVsReference {
    public static void main(String[] args) {
        // Primitive example
        int originalNumber = 100;
        int copiedNumber = originalNumber;
        copiedNumber = 200;

        System.out.println("Original number: " + originalNumber);
        System.out.println("Copied number: " + copiedNumber);

        // Reference example
        int[] originalArray = {1, 2, 3};
        int[] copiedArray = originalArray;
        copiedArray[0] = 99;

        System.out.print("Original array after change: ");
        for (int num : originalArray) {
            System.out.print(num + " ");
        }
        System.out.println();

        System.out.print("Copied array after change: ");
        for (int num : copiedArray) {
            System.out.print(num + " ");
        }
        System.out.println();
    }
}

Important Notes

Time complexity for copying primitives is O(1) because it copies the value directly.

Copying references is also O(1) but both variables point to the same object, so changes affect both.

A common mistake is thinking that copying a reference creates a new object; it does not.

Use primitives for simple data and references for objects or collections.

Summary

Primitives store actual values; references store addresses to objects.

Changing a copied primitive does not affect the original; changing a copied reference affects the original object.

Understanding this helps avoid bugs and manage memory better in Java.

Practice

1. Which of the following correctly describes how primitive types are stored in Java?

easy

A. They store values as strings internally.

B. They store the actual value directly in the variable.

C. They store the memory address of the variable.

D. They store a reference to an object in memory.

Solution

1. Step 1: Understand primitive storage

   Primitive types like int, double, and boolean store the actual data value directly in the variable's memory location.

2. Step 2: Compare with reference types

   Reference types store addresses pointing to objects, not the actual data value.

3. Final Answer:

   They store the actual value directly in the variable. -> Option B

4. Quick Check:

   Primitive = actual value [OK]

Hint: Primitives hold values; references hold addresses [OK]

Common Mistakes:

• Thinking primitives store memory addresses
• Confusing reference storage with primitive storage
• Assuming primitives store objects

2. Which of the following is the correct way to declare a reference variable for a String in Java?

easy

A. int s = new String();

B. boolean s = new String();

C. String s = 10;

D. String s = new String();

Solution

1. Step 1: Check variable type and assignment

   String is a reference type, so it can be assigned with new String() to create a new object.

2. Step 2: Verify type compatibility

   int and boolean are primitive types and cannot be assigned a String object.

3. Final Answer:

   String s = new String(); -> Option D

4. Quick Check:

   Reference declaration matches object creation [OK]

Hint: Reference types use 'new' with matching type [OK]

Common Mistakes:

• Assigning objects to primitive types
• Using incompatible types in declaration
• Missing 'new' keyword for object creation

3. What will be the output of the following code?

int a = 5;
int b = a;
b = 10;
System.out.println(a);

medium

A. 5

B. 10

C. 0

D. Compilation error

Solution

1. Step 1: Understand primitive assignment

   Variable b copies the value of a (which is 5). Changing b to 10 does not affect a.

2. Step 2: Print value of a

   Since a was not changed, printing a outputs 5.

3. Final Answer:

   5 -> Option A

4. Quick Check:

   Primitive copy keeps original value [OK]

Hint: Changing copied primitive doesn't affect original [OK]

Common Mistakes:

• Assuming a changes when b changes
• Confusing reference behavior with primitive
• Expecting compilation error

4. Consider the code below. What is the error and how to fix it?

String s1 = "hello";
String s2 = s1;
s2 = "world";
System.out.println(s1);

medium

A. Output is 'world' because s2 changes s1.

B. Error: Strings cannot be assigned like this.

C. No error; output is 'hello'.

D. Compilation error due to missing new keyword.

Solution

1. Step 1: Analyze reference assignment

   s2 points to the same String object as s1 initially, but assigning s2 = "world" makes s2 point to a new String object.

2. Step 2: Check effect on s1

   s1 still points to "hello" because Strings are immutable and s2 reassignment does not affect s1.

3. Final Answer:

   No error; output is 'hello'. -> Option C

4. Quick Check:

   Reference reassignment doesn't change original object [OK]

Hint: Reassigning reference doesn't change original object [OK]

Common Mistakes:

• Thinking s1 changes when s2 changes
• Expecting compilation error for String assignment
• Confusing mutable and immutable objects

5. Given the following code, what will be the output?

class Box {
  int value;
  Box(int v) { value = v; }
}

Box b1 = new Box(5);
Box b2 = b1;
b2.value = 10;
System.out.println(b1.value);

hard

A. 10

B. 5

C. Compilation error

D. NullPointerException

Solution

1. Step 1: Understand reference assignment for objects

   b2 is assigned the reference of b1, so both point to the same Box object.

2. Step 2: Modify object through b2

   Changing b2.value to 10 changes the single Box object's value.

3. Step 3: Print b1.value

   Since b1 points to the same object, b1.value is now 10.

4. Final Answer:

   10 -> Option A

5. Quick Check:

   Reference change affects original object [OK]

Hint: Object references share same data; change affects all [OK]

Common Mistakes:

• Assuming b1.value stays 5 after b2 changes it
• Confusing primitive and reference behavior
• Expecting compilation or runtime errors