Primitive vs reference storage in Java - Performance Comparison

Time Complexity: Primitive vs reference storage

O(1)

Understanding Time Complexity

We want to understand how storing data as primitive types or as references affects the time it takes to access or copy them.

How does the type of storage change the work done when handling data?

Scenario Under Consideration

Analyze the time complexity of copying primitive and reference types.

int a = 5;               // primitive
int b = a;               // copy primitive

int[] arr1 = {1, 2, 3};  // reference
int[] arr2 = arr1;       // copy reference
    

This code copies a primitive value and a reference to an array.

Identify Repeating Operations

Look at what happens when copying each type.

• Primary operation: Copying a primitive value is a simple assignment.
• Primary operation: Copying a reference copies the address, not the whole object.
• How many times: Each copy happens once per assignment.

How Execution Grows With Input

Copying a primitive value always takes the same small amount of time, no matter the value.

Copying a reference also takes the same small amount of time, regardless of the object size.

Input Size (n)	Approx. Operations for Primitive Copy	Approx. Operations for Reference Copy
10	1	1
100	1	1
1000	1	1

Pattern observation: Copying either a primitive or a reference is constant time, no matter the data size.

Final Time Complexity

Time Complexity: O(1)

This means copying a primitive or a reference takes the same small, fixed amount of time regardless of data size.

Common Mistake

[X] Wrong: "Copying a reference copies the whole object, so it takes longer for big objects."

[OK] Correct: Copying a reference only copies the address, not the object itself, so it stays fast no matter the object size.

Interview Connect

Understanding how primitives and references are stored and copied helps you explain performance differences clearly in coding interviews.

Self-Check

"What if we copied the entire array instead of just the reference? How would the time complexity change?"

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