String Handling Interview Questions

Strings are immutable to improve security, thread safety, performance through string pooling, and reliability when used as keys in collections.

String is immutable. StringBuffer is mutable and thread-safe. StringBuilder is mutable and not thread-safe but provides better performance in single-threaded environments.

The String Pool is a special memory area in the heap where Java stores string literals to reduce memory usage and improve performance.

The intern() method returns a canonical representation of a string from the String Pool. If the string does not exist in the pool, it is added.

The == operator compares object references, whereas equals() compares the actual character content of strings.

String literals are stored in the String Pool, while strings created using the new keyword are allocated separately in heap memory.

A new String object is created in heap memory even if the literal already exists in the String Pool.

String concatenation combines multiple strings into one. The compiler often uses StringBuilder internally for concatenation operations.

A String can be reversed using StringBuilder's reverse() method or by manually iterating through the characters in reverse order.

Compare the original string with its reversed version. If both are equal, the string is a palindrome.

Duplicate characters can be removed using a Set, StringBuilder, or frequency-counting approach while preserving unique characters.

substring() returns a String object, while subSequence() returns a CharSequence representing the specified portion of the string.

compareTo() compares two strings lexicographically and returns a negative, zero, or positive value based on their ordering.

StringTokenizer is a utility class used to break a string into tokens based on specified delimiters.

Common programs include reversing a string, checking palindromes, finding duplicate characters, checking anagrams, counting character frequencies, and removing duplicates.

Name concrete APIs (collections, concurrency, streams, annotations) tied to String Handling. Interviewers want syntax-level clarity plus when you would reach for each feature in production.

Prefer specific checked/unchecked exceptions, wrap lower-level failures with context, and avoid empty catch blocks. For String Handling, decide what is recoverable vs fatal to the request thread.

JUnit 5 with Arrange-Act-Assert, Mockito for collaborators, and parameterized tests for edge cases. Keep String Handling logic pure where possible so tests stay fast.

Incorrect equals/hashCode break HashMap/HashSet behavior. If String Handling stores objects in collections, explain the contract and mutability pitfalls.

Retain only needed references, prefer streaming for large datasets, and avoid accidental caches. Relate leaks or GC pressure to a concrete String Handling scenario.