String immutability in Java - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does it mean that a String is immutable in Java?

It means once a String object is created, its content cannot be changed. Any modification creates a new String object.

intermediate

Why are Strings designed to be immutable in Java?

Immutability helps with security, thread safety, and performance optimizations like string pooling.

beginner

What happens when you try to change a String using methods like concat() or replace()?

These methods do not change the original String. Instead, they return a new String with the changes.

intermediate

How does String immutability affect memory usage in Java?

Because Strings are immutable, Java can safely share String objects in the string pool, reducing memory use.

beginner

Can you modify the characters inside a String object directly in Java?

No, you cannot change characters inside a String directly because Strings are immutable.

What happens when you call the replace() method on a String in Java?

A A new String is created with the replacements

B The original String is changed

C An error occurs

D The String becomes mutable

Since Strings are immutable, replace() returns a new String with changes, leaving the original unchanged.

Why is String immutability important for thread safety?

A Because immutable objects cannot be changed by multiple threads simultaneously

B Because immutable objects are slower

C Because immutable objects use more memory

D Because immutable objects require synchronization

Immutable objects cannot be changed, so multiple threads can safely use the same String without conflicts.

Which of these is true about Java Strings?

A They are mutable by default

B They can be changed after creation

C They are immutable

D They are only immutable if declared final

All Java String objects are immutable regardless of how they are declared.

What is the benefit of the String pool in Java?

A It stores only mutable Strings

B It makes Strings mutable

C It slows down String creation

D It allows sharing of immutable String objects to save memory

The String pool stores unique String objects to avoid duplicates and save memory.

If you want to change characters in a sequence of text efficiently, what should you use instead of String?

A char array

B StringBuilder or StringBuffer

C int array

D HashMap

StringBuilder and StringBuffer are mutable and allow efficient text modifications.

Explain what String immutability means in Java and why it is useful.

Think about what happens when you try to change a String.

Describe how Java uses the String pool and how immutability makes it possible.

Consider why sharing mutable objects would be risky.

Practice

1. What does it mean that a String in Java is immutable?

easy

A. Once created, the string cannot be changed.

B. The string can be changed anytime.

C. The string changes automatically when printed.

D. The string can only be changed inside loops.

Solution

1. Step 1: Understand the meaning of immutability

   Immutability means the object cannot be changed after creation.

2. Step 2: Apply this to Java Strings

   Java strings cannot be modified once created; any change creates a new string.

3. Final Answer:

   Once created, the string cannot be changed. -> Option A

4. Quick Check:

   String immutability = cannot change after creation [OK]

Hint: Immutable means no change allowed after creation [OK]

Common Mistakes:

• Thinking strings can be changed directly
• Confusing immutability with constant variables
• Assuming strings change when printed

2. Which of the following is the correct way to create a new string by changing a character in an existing string str?

easy

A. str.charAt(0) = 'A';

B. str[0] = 'A';

C. str = "A" + str.substring(1);

D. str.replaceChar(0, 'A');

Solution

1. Step 1: Check syntax for changing characters in strings

   Strings are immutable, so direct assignment like str.charAt(0) = 'A' is invalid.

2. Step 2: Use substring to create a new string

   Concatenate "A" with the substring from index 1 to form a new string.

3. Final Answer:

   str = "A" + str.substring(1); -> Option C

4. Quick Check:

   Use substring + concat to change string [OK]

Hint: Use substring and concat to create new string [OK]

Common Mistakes:

• Trying to assign directly to string characters
• Using array-like indexing on strings
• Using non-existent methods like replaceChar

3. What is the output of the following code?

String s = "hello";
s.toUpperCase();
System.out.println(s);

medium

A. HELLO

B. hello

C. null

D. HELLOhello

Solution

1. Step 1: Understand that strings are immutable

   The method toUpperCase() returns a new string but does not change the original string s.

2. Step 2: Check what is printed

   Since s was not reassigned, printing s outputs the original string "hello".

3. Final Answer:

   hello -> Option B

4. Quick Check:

   Original string unchanged = hello [OK]

Hint: toUpperCase returns new string; original stays same [OK]

Common Mistakes:

• Assuming toUpperCase changes original string
• Expecting uppercase output without reassignment
• Confusing method effect with print output

4. Find the error in this code snippet:

String s = "test";
s.charAt(0) = 'T';
System.out.println(s);

medium

A. Cannot assign to charAt() result; strings are immutable.

B. Missing semicolon after declaration.

C. charAt() method does not exist for String.

D. System.out.println() cannot print strings.

Solution

1. Step 1: Check usage of charAt()

   The method charAt() returns a character but cannot be assigned a new value.

2. Step 2: Understand string immutability

   Strings cannot be changed by assigning to characters; this causes a compile error.

3. Final Answer:

   Cannot assign to charAt() result; strings are immutable. -> Option A

4. Quick Check:

   charAt() result is read-only [OK]

Hint: charAt() returns char, cannot assign to it [OK]

Common Mistakes:

• Trying to assign to charAt()
• Thinking strings are mutable
• Ignoring compile errors on assignment

5. You want to replace all occurrences of the letter 'a' with 'b' in a string input. Which code correctly does this considering string immutability?

hard

A. input.replace('a', 'b'); System.out.println(input);

B. input.charAt(0) = 'b'; System.out.println(input);

C. input.toCharArray()[0] = 'b'; System.out.println(input);

D. input = input.replace('a', 'b'); System.out.println(input);

Solution

1. Step 1: Understand replace() returns new string

   The replace() method returns a new string with replacements but does not change the original.

2. Step 2: Assign the new string back to input

   To update input, assign the result of replace() back to it before printing.

3. Final Answer:

   input = input.replace('a', 'b'); System.out.println(input); -> Option D

4. Quick Check:

   Assign replace result to variable to update string [OK]

Hint: Assign replace() result to variable to update string [OK]

Common Mistakes:

• Calling replace() without assignment
• Trying to assign to charAt() or array elements
• Expecting original string to change automatically