Object lifetime in Java - Time & Space Complexity

Time Complexity: Object lifetime

O(n)

Understanding Time Complexity

When we talk about object lifetime in Java, we want to understand how long objects stay active during program execution.

We ask: How does the time spent managing objects grow as the program runs?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

public class ObjectLifetime {
    public void createObjects(int n) {
        for (int i = 0; i < n; i++) {
            String obj = new String("Object " + i);
            System.out.println(obj);
        }
    }
}
    

This code creates and prints n String objects one by one inside a loop.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Creating a new String object and printing it inside the loop.
• How many times: Exactly n times, once per loop iteration.

How Execution Grows With Input

As n grows, the number of objects created and printed grows directly with n.

Input Size (n)	Approx. Operations
10	10 objects created and printed
100	100 objects created and printed
1000	1000 objects created and printed

Pattern observation: The work grows in a straight line as n increases.

Final Time Complexity

Time Complexity: O(n)

This means the time to create and print objects grows directly with the number of objects.

Common Mistake

[X] Wrong: "Creating objects inside a loop is free or constant time regardless of n."

[OK] Correct: Each object creation takes time, so more objects mean more total time.

Interview Connect

Understanding how object creation scales helps you write efficient code and explain resource use clearly.

Self-Check

"What if we reused a single String object instead of creating a new one each time? How would the time complexity change?"

Practice

1. Which statement best describes the lifetime of an object in Java?

easy

A. An object exists as long as there is at least one reference to it.

B. An object exists only during the execution of the main method.

C. An object is deleted immediately after it is created.

D. An object exists forever once created, regardless of references.

Solution

1. Step 1: Understand object references in Java

   Objects are created using new and remain in memory while referenced.

2. Step 2: Recognize garbage collection behavior

   When no references point to an object, Java's garbage collector can remove it.

3. Final Answer:

   An object exists as long as there is at least one reference to it. -> Option A

4. Quick Check:

   Object lifetime depends on references [OK]

Hint: Remember: objects live while referenced, else garbage collected [OK]

Common Mistakes:

• Thinking objects exist only during main method
• Believing objects are deleted immediately after creation
• Assuming objects live forever regardless of references

2. Which of the following is the correct way to create a new object in Java?

easy

A. MyClass obj = MyClass();

B. MyClass obj = create MyClass();

C. MyClass obj = new MyClass();

D. MyClass obj = new MyClass;

Solution

1. Step 1: Recall Java object creation syntax

   Objects are created using the new keyword followed by the constructor call with parentheses.

2. Step 2: Check each option's syntax

   MyClass obj = new MyClass(); uses correct syntax: new MyClass();. Options A, C, and D are incorrect due to missing new, wrong keywords, or missing parentheses.

3. Final Answer:

   MyClass obj = new MyClass(); -> Option C

4. Quick Check:

   Use new ClassName() to create objects [OK]

Hint: Use 'new' keyword plus parentheses to create objects [OK]

Common Mistakes:

• Omitting the 'new' keyword
• Forgetting parentheses after class name
• Using incorrect keywords like 'create'

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

class Test {
  public static void main(String[] args) {
    Test obj1 = new Test();
    Test obj2 = obj1;
    obj1 = null;
    if (obj2 != null) {
      System.out.println("Object alive");
    } else {
      System.out.println("Object dead");
    }
  }
}

medium

A. Runtime exception

B. Object dead

C. Compilation error

D. Object alive

Solution

1. Step 1: Analyze object references

   Initially, obj1 points to the new object. Then obj2 also points to the same object.

2. Step 2: Check effect of setting obj1 to null

   Setting obj1 to null removes one reference, but obj2 still references the object, so it remains alive.

3. Final Answer:

   Object alive -> Option D

4. Quick Check:

   Object lives while any reference exists [OK]

Hint: Object stays alive if any reference points to it [OK]

Common Mistakes:

• Assuming object is dead after one reference is null
• Confusing references with object existence
• Expecting compilation or runtime errors

4. Identify the error in the following code related to object lifetime:

public class Demo {
  public static void main(String[] args) {
    String s = new String("Hello");
    s = null;
    System.out.println(s.length());
  }
}

medium

A. Compilation error due to missing import

B. NullPointerException at runtime

C. No error, prints length of string

D. Syntax error in object creation

Solution

1. Step 1: Understand object reference and null assignment

   The variable s initially references a String object, then is set to null, removing the reference.

2. Step 2: Analyze method call on null reference

   Calling s.length() when s is null causes a NullPointerException at runtime.

3. Final Answer:

   NullPointerException at runtime -> Option B

4. Quick Check:

   Calling methods on null causes NullPointerException [OK]

Hint: Never call methods on null references [OK]

Common Mistakes:

• Thinking code compiles but runs fine
• Expecting compilation errors instead of runtime
• Ignoring null assignment effect

5. Consider the following code snippet:

class Node {
  Node next;
  int value;
  Node(int v) { value = v; }
}

public class Test {
  public static void main(String[] args) {
    Node a = new Node(1);
    Node b = new Node(2);
    a.next = b;
    b = null;
    // Which objects are eligible for garbage collection here?
  }
}

Which objects are eligible for garbage collection after setting b = null;?

hard

A. No objects are eligible because a still references b through next.

B. Only object b is eligible because b reference is null.

C. Both a and b objects are eligible for garbage collection.

D. Only object a is eligible because b is null.

Solution

1. Step 1: Analyze references to objects

   Variable a references the first Node object. Its next field references the second Node object originally referenced by b.

2. Step 2: Understand effect of setting b to null

   Setting b to null removes one reference to the second Node, but a.next still references it, so it is not eligible for garbage collection.

3. Final Answer:

   No objects are eligible because a still references b through next. -> Option A

4. Quick Check:

   Objects live while any reference exists [OK]

Hint: Check all references, including fields, before assuming garbage collection [OK]

Common Mistakes:

• Assuming null variable means object is collectible
• Ignoring references inside other objects
• Confusing variable nullification with object lifetime