String Basics and Memory Representation in DSA Java - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a String in Java?

A String in Java is a sequence of characters stored as an object. It represents text data and is immutable, meaning once created, it cannot be changed.

beginner

What does it mean that Strings are immutable in Java?

Immutability means that once a String object is created, its content cannot be changed. Any modification creates a new String object instead of altering the original.

intermediate

Where are String objects stored in Java memory?

String objects are stored in the String Pool (a special area in the heap memory) if created using string literals. Otherwise, they are stored in the regular heap memory.

intermediate

What is the String Pool in Java?

The String Pool is a special memory area inside the heap where Java stores unique String literals to save memory. If a String literal already exists, Java reuses it instead of creating a new object.

intermediate

How does Java handle String creation with literals vs. new keyword?

When using literals, Java checks the String Pool for an existing object and reuses it if found. Using the new keyword always creates a new String object in heap memory, even if the same content exists in the pool.

What happens when you modify a String in Java?

A The String becomes mutable

B The original String object is changed

C The String is deleted

D A new String object is created with the modification

Strings are immutable, so any modification creates a new String object instead of changing the original.

Where are String literals stored in Java?

A String Pool inside heap memory

B Stack memory

C CPU registers

D Outside JVM memory

String literals are stored in the String Pool, a special area inside the heap memory.

What is the effect of using the new keyword to create a String?

A Reuses existing String from the pool

B Creates a new String object in heap memory regardless of existing literals

C Creates a String on the stack

D Modifies the existing String literal

Using new always creates a new String object in heap memory, even if the same content exists in the String Pool.

Why does Java use a String Pool?

A To store integers

B To make Strings mutable

C To save memory by reusing String literals

D To speed up arithmetic operations

The String Pool helps save memory by storing unique String literals and reusing them.

Which of these is true about Java Strings?

A They are immutable and stored in a special pool if created as literals

B They are mutable and stored on the stack

C They are mutable and stored in CPU registers

D They are immutable and always stored on the stack

Java Strings are immutable and literals are stored in the String Pool inside heap memory.

Explain how Java stores and manages String objects in memory.

Think about the difference between literals and new keyword.

Describe what happens internally when you change a String variable in Java.

Remember Strings cannot be changed once created.

Practice

1. What is the correct way to create a string literal in Java?

easy

A. String s = 'Hello';

B. String s = new String();

C. String s = "Hello";

D. String s = String();

Solution

1. Step 1: Understand string literal syntax

   In Java, string literals are enclosed in double quotes, so "Hello" is correct.

2. Step 2: Check each option

   String s = "Hello"; uses double quotes correctly. String s = new String(); creates an empty string object but not a literal. String s = 'Hello'; uses single quotes which are for characters, not strings. String s = String(); is invalid syntax.

3. Final Answer:

   String s = "Hello"; -> Option C

4. Quick Check:

   String literal uses double quotes = A [OK]

Hint: Use double quotes for string literals in Java [OK]

Common Mistakes:

• Using single quotes for strings
• Trying to call String() like a function
• Confusing new String() with literal

2. Which of the following is the correct syntax to compare two strings s1 and s2 for content equality in Java?

easy

A. if (s1.equals(s2))

B. if (s1 == s2)

C. if (s1 = s2)

D. if (s1.compare(s2))

Solution

1. Step 1: Understand string comparison in Java

   Using == compares references (memory addresses), not content. To compare content, use the equals() method.

2. Step 2: Evaluate each option

   if (s1 == s2) compares references, not content. if (s1.equals(s2)) correctly uses equals() method. if (s1 = s2) uses assignment (=) which is invalid in condition. if (s1.compare(s2)) uses a non-existent method compare().

3. Final Answer:

   if (s1.equals(s2)) -> Option A

4. Quick Check:

   Use equals() for string content comparison = B [OK]

Hint: Use equals() method to compare string contents [OK]

Common Mistakes:

• Using == to compare strings
• Using assignment operator in if condition
• Calling non-existent methods

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

String s1 = "hello";
String s2 = "hello";
String s3 = new String("hello");
System.out.println(s1 == s2);
System.out.println(s1 == s3);
System.out.println(s1.equals(s3));

medium

A. true
false
true

B. false
false
true

C. true
true
true

D. false
true
false

Solution

1. Step 1: Understand string pool and new String()

   s1 and s2 are string literals and point to the same object in the string pool, so s1 == s2 is true. s3 is a new String object, so s1 == s3 is false because they reference different objects.

2. Step 2: Check equals() method

   s1.equals(s3) compares content and both have "hello", so it returns true.

3. Final Answer:

   true false true -> Option A

4. Quick Check:

   == compares references, equals() compares content = C [OK]

Hint: == checks memory, equals() checks string content [OK]

Common Mistakes:

• Assuming new String() shares reference
• Confusing == with equals()
• Ignoring string pool behavior

4. Identify the error in the following code snippet:

String s = "test";
if (s == "test") {
    System.out.println("Match");
} else {
    System.out.println("No Match");
}

medium

A. System.out.println syntax is incorrect

B. Missing semicolon after string declaration

C. String literals cannot be compared

D. Using == to compare strings can cause unexpected results

Solution

1. Step 1: Check string comparison method

   The code uses == to compare strings, which compares references, not content. This can cause unexpected results if strings are not from the pool.

2. Step 2: Verify other syntax

   There is no missing semicolon, string literals can be compared with equals(), and System.out.println syntax is correct.

3. Final Answer:

   Using == to compare strings can cause unexpected results -> Option D

4. Quick Check:

   Use equals() for string comparison, not == = A [OK]

Hint: Avoid == for strings; use equals() instead [OK]

Common Mistakes:

• Thinking == compares string content
• Ignoring string pool behavior
• Assuming syntax errors where none exist

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

String a = "Java";
String b = "Ja" + "va";
String c = new String("Java");
System.out.println(a == b);
System.out.println(a == c);
System.out.println(a.equals(c));

Explain why the outputs are as they are.

hard

A. false
true
false

B. true
false
true

C. true
true
true

D. false
false
true

Solution

1. Step 1: Analyze string concatenation with literals

   Strings "Ja" and "va" are literals concatenated at compile time, so b points to the same string pool object as a. Therefore, a == b is true.

2. Step 2: Understand new String() behavior

   c is a new String object created at runtime, so a == c is false because they reference different objects. However, a.equals(c) compares content and returns true.

3. Final Answer:

   true false true -> Option B

4. Quick Check:

   Compile-time concat shares pool, new String() creates new object = D [OK]

Hint: Compile-time concat shares pool; new String() creates new object [OK]

Common Mistakes:

• Assuming runtime concat shares pool
• Confusing == with equals()
• Ignoring compile-time optimization