How Strings Work Differently Across Languages in DSA Java - Debugging & Practice

Challenge - 5 Problems

❓ Predict Output

intermediate

String Immutability in Java

What is the output of this Java code snippet?

DSA Java

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

A null

B hello

C HELLO

D Compilation error

💡 Hint

Remember that String methods like toUpperCase() return a new String.

The toUpperCase() method returns a new String with all uppercase letters. Since s is reassigned, the printed value is HELLO.

❓ Predict Output

intermediate

String Comparison Using == vs equals()

What will be the output of this Java code?

DSA Java

String a = "test";
String b = new String("test");
System.out.println(a == b);
System.out.println(a.equals(b));

A

true
true

B

false
true

C

false
false

D

true
false

💡 Hint

Remember that == compares references, equals() compares content.

The == operator checks if both variables point to the same object, which is false here. The equals() method checks if the contents are the same, which is true.

🔧 Debug

advanced

Why Does String Concatenation Inside a Loop Cause Performance Issues?

Consider this Java code snippet that concatenates strings inside a loop. What is the main reason this code is inefficient?

DSA Java

String result = "";
for (int i = 0; i < 1000; i++) {
    result += i;
}
System.out.println(result.length());

A The += operator is not valid for strings in Java.

B The loop runs too many times causing a stack overflow error.

C The code will not compile because result is not initialized.

D Strings are immutable, so each concatenation creates a new object causing overhead.

💡 Hint

Think about what happens when you add strings repeatedly in Java.

Strings in Java cannot be changed once created. Each concatenation creates a new String object, which is slow and uses more memory.

🧠 Conceptual

advanced

Difference Between String and StringBuilder in Java

Which statement correctly explains the difference between String and StringBuilder in Java?

A String is immutable, StringBuilder is mutable and better for frequent modifications.

B StringBuilder is immutable, String is mutable and better for frequent modifications.

C StringBuilder is slower than String for concatenation operations.

D Both String and StringBuilder are immutable and behave the same.

💡 Hint

Consider which class allows changing the content without creating new objects.

String objects cannot be changed after creation. StringBuilder allows changing the content without creating new objects, making it faster for many modifications.

🚀 Application

expert

Predict the Output of String Interning Behavior

What is the output of this Java code snippet?

DSA Java

String s1 = "code";
String s2 = new String("code");
String s3 = s2.intern();
System.out.println(s1 == s2);
System.out.println(s1 == s3);

A

false
true

B

true
false

C

true
true

D

false
false

💡 Hint

Remember what intern() does to string references.

s1 points to the string pool object. s2 is a new object. s3 is the interned version of s2, which points to the string pool object. So s1 == s2 is false, s1 == s3 is true.

Practice

1. In Java, which of the following statements about String objects is true?

easy

A. Strings are stored as linked lists of characters.

B. Strings can be changed directly by modifying their characters.

C. Strings are immutable, meaning once created, they cannot be changed.

D. Strings are always stored in the stack memory.

Solution

1. Step 1: Understand Java String immutability

   In Java, String objects cannot be changed after creation. Any modification creates a new String object.

2. Step 2: Compare other options

   Strings are not linked lists, and they are stored in heap memory, not stack.

3. Final Answer:

   Strings are immutable, meaning once created, they cannot be changed. -> Option C

4. Quick Check:

   Java String immutability = true [OK]

Hint: Remember: Java Strings never change after creation [OK]

Common Mistakes:

• Thinking Strings can be changed in place
• Confusing String storage with primitive types
• Assuming Strings are linked lists

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

easy

A. String s = new String("hello");

B. String s = String("hello");

C. String s = new string("hello");

D. String s = 'hello';

Solution

1. Step 1: Check Java String creation syntax

   The correct syntax uses the keyword new and capitalized String class: new String("hello").

2. Step 2: Identify incorrect options

   String s = String("hello"); misses new, C uses lowercase string, and D uses single quotes which are for chars, not Strings.

3. Final Answer:

   String s = new String("hello"); -> Option A

4. Quick Check:

   Correct String constructor syntax = String s = new String("hello"); [OK]

Hint: Use new String("text") with capital S and double quotes [OK]

Common Mistakes:

• Using single quotes for Strings
• Using lowercase 'string' instead of 'String'
• Omitting the new keyword

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

String a = "hello";
String b = "hello";
System.out.println(a == b);

medium

A. Runtime exception

B. false

C. Compilation error

D. true

Solution

1. Step 1: Understand String literals and pooling in Java

   Both a and b refer to the same String literal in the String pool, so a == b compares the same object reference.

2. Step 2: Evaluate the == operator on String literals

   Since both point to the same object, a == b returns true.

3. Final Answer:

   true -> Option D

4. Quick Check:

   String literal pooling makes == true [OK]

Hint: String literals share references, so == returns true [OK]

Common Mistakes:

• Confusing == with .equals() for content check
• Assuming == always returns false for Strings
• Ignoring String pool behavior

4. Identify the error in the following Java code snippet:

String s = "hello";
s[0] = 'H';
System.out.println(s);

medium

A. Strings are immutable; characters cannot be changed by index.

B. Syntax error: single quotes cannot be used for characters.

C. Runtime error: index out of bounds.

D. No error; output will be "Hello".

Solution

1. Step 1: Check String immutability in Java

   Strings cannot be changed by modifying characters at an index because they are immutable.

2. Step 2: Analyze the code error

   Attempting s[0] = 'H'; causes a compile-time error since Strings do not support indexing for assignment.

3. Final Answer:

   Strings are immutable; characters cannot be changed by index. -> Option A

4. Quick Check:

   Immutable Strings prevent index assignment [OK]

Hint: Strings can't change characters by index in Java [OK]

Common Mistakes:

• Trying to modify String characters directly
• Confusing char arrays with Strings
• Expecting runtime error instead of compile error

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

String s1 = new String("test");
String s2 = "test";
String s3 = s1.intern();
System.out.println(s1 == s2);
System.out.println(s2 == s3);

hard

A. true\nfalse

B. false\ntrue

C. false\nfalse

D. true\ntrue

Solution

1. Step 1: Understand new String() vs String literal

   s1 is a new object in heap, s2 is a String literal from the pool, so s1 == s2 is false.

2. Step 2: Understand intern() method

   s3 is the interned version of s1, which returns the pooled String equal to "test", same as s2. So s2 == s3 is true.

3. Final Answer:

   false true -> Option B

4. Quick Check:

   new String != literal, intern() returns pooled String [OK]

Hint: intern() returns pooled String; new String creates new object [OK]

Common Mistakes:

• Assuming new String equals literal by ==
• Ignoring intern() effect on references
• Confusing == with .equals()