Java String Interview Questions With Answers for Java 25

Java String interview questions check how well we know the String class, such as its immutability, the string pool, equality checks and the difference from StringBuilder. Almost every Java interview has a few of them, because every app works with text and small mistakes with strings cause real bugs.

We use these questions to prepare for Java developer interviews, from the first job to mid-level roles, and as a quick refresher on how strings behave in current Java versions such as Java 25.

The following example answers the most common questions in a few lines, with the result of each line as a comment.

String a = "java";
String b = "java";
String c = new String("java");
boolean samePooled = a == b;                                  // true (one pooled object)
boolean sameObject = a == c;                                  // false (c is a new object)
boolean sameText = a.equals(c);                               // true
boolean afterIntern = a == c.intern();                        // true
String upper = a.toUpperCase();                               // "JAVA" (a stays "java")
String reversed = new StringBuilder(a).reverse().toString();  // "avaj"

Notice that == compares object references and equals() compares characters, which is the root of many interview questions. The questions are grouped by topic, from the basics and the pool to the classic coding exercises, and each answer shows the code that proves it.

1. String Basics

Interviewers often start with what a String is and why it never changes. These answers changed a little in recent Java versions, so we give the Java 25 view.

1.1. Is String a Keyword or a Primitive Type?

Neither. The String class is a final class in the java.lang package, and Java has only eight primitive types. Because String is not one of the reserved keywords, it is even a legal variable name.

int String = 10;                                  // 10 (compiles, but never do this)
boolean isFinal = java.lang.reflect.Modifier.isFinal(java.lang.String.class.getModifiers());   // true

The class is final, so nobody can write a subclass that changes how strings behave. It implements CharSequence, Comparable<String> and Serializable.

1.2. Why Is String Immutable?

An immutable object cannot change its state after it is created. Every String method that looks like a change, such as toUpperCase() or concat(), returns a new String and leaves the original alone.

String city = "pune";
String upperCity = city.toUpperCase();      // "PUNE"
String full = city.concat(", India");       // "pune, India"
boolean unchanged = city.equals("pune");    // true

Java designs String this way for four reasons, and naming them is the answer interviewers expect.

• The string pool can share one object between many variables, because no variable can change it for the others.
• The hash code is calculated once and cached, so a String works fast as a HashMap key.
• Security checks stay valid, because a file path or a class name cannot change after the check.
• Strings are safe to share between threads without locks.

For example, a web app stores user sessions in a HashMap keyed by the session ID. If the ID string could change after put(), the map would look in the wrong bucket and never find the session again. The full reasoning is in why strings are immutable, and the general recipe is in making a class immutable.

1.3. How Does String Store Its Characters Since Java 9?

Older answers say that a String wraps a char[] with offset and count fields. That has been wrong for years. The offset and count fields were removed in Java 7 update 6, and since Java 9 a String stores its characters in a byte[] plus a coder flag. This change is called compact strings (JEP 254).

Text	Coder	Bytes per character
Only Latin-1 characters, such as “java”	LATIN1	1
Any other character, such as Hindi or emoji	UTF16	2

Compact strings halve the memory for the characters of most strings, because most text in an app is Latin-1. The change is internal, so length() and charAt() still count UTF-16 code units, and our code does not change.

1.4. Is String Thread-Safe?

Yes. A String has no method that changes its characters, and the field that holds them is final, so several threads can read the same String at the same time without locks. A variable that holds a String is a different matter, because assigning a new string to a shared field still needs the usual concurrency rules such as volatile or synchronization.

2. String Pool and Memory

The pool questions check whether we understand where string objects live and why == sometimes returns true for two variables.

2.1. Where Do String Literals Live in Memory?

The string pool is a table inside the JVM that holds one shared String object for each string literal. Every literal with the same text resolves to the same pooled object, in every class of the app. Since Java 7, the pooled strings live in the normal heap, not in PermGen, so the garbage collector removes pooled strings that nothing references any more.

For example, an app reads a CSV file with a million rows, and every row has a country column with one of 20 values. Each split() call creates new strings, so the heap holds a million copies of “India”. Calling intern() on the column value keeps one copy per country.

2.2. How Many Objects Does new String(“java”) Create?

One or two. The literal “java” creates a pooled object the first time the JVM resolves it, unless the pool already has one. The new keyword always creates a second object at run time.

String s1 = "java";
String s2 = "java";
String s3 = new String("java");
boolean s1s2 = s1 == s2;          // true (both use the pooled object)
boolean s1s3 = s1 == s3;          // false (s3 is a new object)

So the three lines create two String objects in total, the pooled one and the one from new. The constructor new String(String) is almost never needed in real code, because strings are immutable and a copy gives us nothing.

2.3. What Does intern() Do?

The method intern() returns the pooled String with the same characters. If the pool has no such string yet, the JVM adds the current one to the pool and returns it. The method does not move or change the object we call it on, so we must use the return value.

String fromInput = new String("india");
String pooled = fromInput.intern();
boolean sameAsLiteral = pooled == "india";       // true
boolean original = fromInput == "india";         // false (fromInput is unchanged)

For any two strings, s.intern() == t.intern() is true only when s.equals(t) is true.

2.4. Does Concatenation at Run Time Use the Pool?

No. The compiler joins constant expressions, such as two literals or final variables with constant values, and puts the result in the pool. Concatenation with a normal variable happens at run time and creates a new object.

String full = "howto" + "doinjava";
boolean compileTime = full == "howtodoinjava";       // true (constant expression)

String part = "howto";
String joined = part + "doinjava";
boolean runTime = joined == "howtodoinjava";         // false (built at run time)

final String constPart = "howto";
String joinedConst = constPart + "doinjava";
boolean finalConst = joinedConst == "howtodoinjava";  // true (constPart is a constant)

Only constant expressions are pooled for us. Tricky questions of this kind test whether we know that == on strings depends on how the strings were created.

3. String Equality and Ordering

Equality questions come up in nearly every interview, because comparing strings with == is one of the most common bugs in Java code.

3.1. What Is the Difference Between == and equals()?

The == operator compares references, so it returns true only when both variables point to the same object. The method equals() compares the characters, so it returns true for two different objects with the same text.

Say a login service compares the role from the database with role == “ADMIN”. The check passes in a unit test that uses a literal, but in production the role comes from a JDBC result set as a new String, so the admin is refused.

String fromDb = new String("ADMIN");
boolean byReference = fromDb == "ADMIN";               // false
boolean byValue = fromDb.equals("ADMIN");              // true
boolean nullSafe = "ADMIN".equals(null);               // false (no NullPointerException)
boolean bothNull = Objects.equals(null, null);         // true

We always compare strings with equals(), and we call it on the literal or use Objects.equals() when the variable can be null.

3.2. How Do compareTo() and equalsIgnoreCase() Work?

The method compareTo() compares two strings character by character, which is what sorting needs. It returns 0 for equal strings, a negative number when the first string comes first, and a positive number otherwise. The number is the difference of the first characters that differ, or the difference of the lengths.

int before = "apple".compareTo("banana");               // -1 ('a' - 'b')
int same = "apple".compareTo("apple");                  // 0
int upperFirst = "Apple".compareTo("apple");            // -32 ('A' - 'a')
int shorter = "app".compareTo("apple");                 // -2 (length 3 - 5)
int ignoreCase = "Apple".compareToIgnoreCase("apple");  // 0
boolean equalText = "Apple".equalsIgnoreCase("APPLE");  // true

Notice that uppercase letters sort before lowercase letters, because compareTo() uses the character codes. For sorting names the way people expect in a given language, we use a java.text.Collator.

3.3. Why Is String a Good HashMap Key?

A HashMap finds an entry by the key’s hash code first and by equals() second. The String class overrides both methods by its characters, as the hashCode() and equals() contract requires, and its immutability means the hash code never changes after put().

Map<String, Integer> stock = new HashMap<>();
stock.put("apple", 5);
int found = stock.get(new String("apple"));    // 5 (equal text, different object)
int hash = "apple".hashCode();                 // 93029210

The String class also caches the hash code in a field after the first call, so later lookups with the same key object skip the calculation.

4. String, StringBuilder and StringBuffer

The builder question is the most asked String question for developers with a few years of experience, and the answer is a short comparison.

4.1. What Is the Difference Between Them?

A String cannot change, whereas StringBuilder and StringBuffer hold a changeable sequence of characters. The two builders have the same methods, and they differ only in synchronization.

	String	StringBuilder	StringBuffer
Can change	no	yes	yes
Thread-safe	yes (immutable)	no	yes (synchronized methods)
Speed for many appends	slow, creates new objects	fastest	slower because of locks
Since	Java 1.0	Java 5	Java 1.0
Use for	values, keys, constants	building text in one thread	legacy code shared by threads

In current code, we use StringBuilder almost always. A builder is rarely shared between threads, and when it is, the code needs higher-level locking anyway, so StringBuffer is mostly found in old APIs.

StringBuilder sb = new StringBuilder("java");
sb.append(" 25").insert(0, "Hello ").replace(0, 5, "Hi");
String text = sb.toString();                    // "Hi java 25"
int size = sb.length();                         // 10

4.2. Should We Use + or StringBuilder for Concatenation?

For a single expression, we use +. Since Java 9, the compiler turns + into an invokedynamic call to StringConcatFactory (JEP 280), which sizes the result once, so a StringBuilder is not faster there.

Inside a loop, += creates a new string on every pass and copies all previous characters, so the work grows with the square of the number of items. For example, an export job that builds a CSV line for 10,000 orders with += copies millions of characters, whereas a StringBuilder appends to one buffer.

List<String> names = List.of("Lokesh", "Alex", "Maria");

StringBuilder line = new StringBuilder();
for (String name : names) {
  line.append(name).append(';');
}
String built = line.toString();                 // "Lokesh;Alex;Maria;"
String joined = String.join(", ", names);       // "Lokesh, Alex, Maria"

When the items are already in a collection, String.join() or a StringJoiner is the shortest choice. The measured differences are in string concatenation performance.

5. Questions About Common String Methods

Interviewers like method questions with a trap, such as a regex that matches more than expected or an empty string that is not blank.

5.1. What Is the Difference Between replace() and replaceAll()?

Both methods replace every match, not only the first one. The method replace() takes plain text, whereas replaceAll() takes a regular expression, so characters such as the dot have a special meaning there.

String version = "25.0.1";
String plain = version.replace(".", "_");              // "25_0_1"
String regex = version.replaceAll(".", "_");           // "______" (dot matches any character)
String escaped = version.replaceAll("\\.", "_");       // "25_0_1"
String first = version.replaceFirst("\\.", "_");       // "25_0.1"
String removed = "java".replace("a", "");              // "jv"

To remove characters, we replace them with an empty string, as the last line shows.

5.2. Why Does split() Drop Empty Values?

The method split() also takes a regex, and by default it removes empty strings at the end of the result. A CSV line with empty last columns loses those columns unless we pass a negative limit.

String row = "Lokesh,37,,";
int dropped = row.split(",").length;            // 2 (trailing empty values removed)
int kept = row.split(",", -1).length;           // 4
int wrongDot = "a.b.c".split(".").length;       // 0 (every character is a separator)
int rightDot = "a.b.c".split("\\.").length;     // 3

More options, such as limits and multiple separators, are in the String.split() guide.

5.3. Is an Empty String the Same as a Blank String?

The method isEmpty() returns true only for a string of length 0. The method isBlank(), added in Java 11, also returns true for a string that contains only whitespace. The matching pair for removing whitespace is trim() and strip(), which we compare in removing leading and trailing whitespace.

boolean emptyCheck = "  ".isEmpty();           // false
boolean blankCheck = "  ".isBlank();           // true
boolean bothEmpty = "".isEmpty();              // true
String stripped = "  java  ".strip();          // "java"

5.4. Can We Use a String in a switch?

Yes, since Java 7. The switch compares the value with equals(), after a quick check of the hash code, and it throws a NullPointerException when the value is null. Since Java 14, a switch expression with arrow labels returns a value.

String size = "M";
String label = switch (size) {
  case "S" -> "Small";
  case "M" -> "Medium";
  case "L" -> "Large";
  default -> "Unknown";
};
boolean medium = label.equals("Medium");        // true

6. String Coding Questions

Most interviews include one short coding task on strings. Interviewers also check how the code treats null, case and empty input, so we mention these cases while we write the solution.

6.1. How Do We Reverse a String?

The shortest answer is new StringBuilder(text).reverse().toString(). When the interviewer asks for a solution without a builder, we swap characters in a char[] from both ends.

static String reverse(String text) {
  if (text == null) {
    return null;
  }
  char[] chars = text.toCharArray();
  for (int i = 0, j = chars.length - 1; i < j; i++, j--) {
    char tmp = chars[i];
    chars[i] = chars[j];
    chars[j] = tmp;
  }
  return new String(chars);
}

Both ways give the same result for normal text.

String byBuilder = new StringBuilder("howtodoinjava").reverse().toString();   // "avajniodotwoh"
String byLoop = reverse("howtodoinjava");                                     // "avajniodotwoh"

A recursive version is a common follow-up question, and it is covered in reversing a string with recursion.

6.2. How Do We Check a Palindrome?

A palindrome reads the same in both directions, such as “level”. Instead of building a reversed copy, we compare characters from both ends and stop at the first difference, so the method needs no extra memory.

static boolean isPalindrome(String text) {
  String s = text.toLowerCase();
  for (int i = 0, j = s.length() - 1; i < j; i++, j--) {
    if (s.charAt(i) != s.charAt(j)) {
      return false;
    }
  }
  return true;
}

The method ignores case, so “Madam” counts as a palindrome.

boolean level = isPalindrome("level");      // true
boolean madam = isPalindrome("Madam");      // true
boolean java = isPalindrome("java");        // false

Variants that ignore spaces and punctuation are in checking a palindrome string.

6.3. How Do We Check if Two Strings Are Anagrams?

Two strings are anagrams when they contain the same characters the same number of times, such as “listen” and “silent”. We sort the characters of both strings and compare the arrays.

static boolean isAnagram(String first, String second) {
  char[] a = first.toLowerCase().toCharArray();
  char[] b = second.toLowerCase().toCharArray();
  Arrays.sort(a);
  Arrays.sort(b);
  return Arrays.equals(a, b);
}

Sorting costs O(n log n). An int[26] counter array works in O(n) for the letters a to z, which is a typical follow-up question.

boolean anagram = isAnagram("Listen", "Silent");   // true
boolean notAnagram = isAnagram("java", "jav");     // false

6.4. How Do We Count Each Character in a String?

We put each character into a map with its count. A TreeMap keeps the keys sorted, so the output is stable, and merge() adds 1 to the existing count or starts it at 1.

Map<Character, Integer> counts = new TreeMap<>();
for (char ch : "banana".toCharArray()) {
  counts.merge(ch, 1, Integer::sum);
}
String result = counts.toString();             // "{a=3, b=1, n=2}"

A Stream version with Collectors.groupingBy() and the related task of finding repeated characters are in finding duplicate characters.

6.5. How Do We Find the First Non-Repeated Character?

We count the characters in a LinkedHashMap, which keeps the insertion order, and return the first character with a count of 1. The method returns an Optional, because a string such as “aabb” has no such character.

static Optional<Character> firstUnique(String text) {
  Map<Character, Long> counts = text.chars()
      .mapToObj(c -> (char) c)
      .collect(Collectors.groupingBy(Function.identity(), LinkedHashMap::new, Collectors.counting()));
  return counts.entrySet().stream()
      .filter(e -> e.getValue() == 1)
      .map(Map.Entry::getKey)
      .findFirst();
}

For “swiss”, the letters s repeat, so the first unique letter is w.

Optional<Character> unique = firstUnique("swiss");   // Optional[w]
Optional<Character> none = firstUnique("aabb");       // Optional.empty

6.6. How Do We Print All Permutations of a String?

A permutation is one ordering of all the characters, and a string of length N has N! permutations. The recursive solution fixes each character in turn as the first one and permutes the rest.

static void permute(String prefix, String rest, List<String> result) {
  if (rest.isEmpty()) {
    result.add(prefix);
    return;
  }
  for (int i = 0; i < rest.length(); i++) {
    permute(prefix + rest.charAt(i), rest.substring(0, i) + rest.substring(i + 1), result);
  }
}

For “abc”, the method finds 3! = 6 permutations in order. With repeated characters, such as in “aab”, we collect into a Set to remove the duplicates.

List<String> perms = new ArrayList<>();
permute("", "abc", perms);
String all = perms.toString();                 // "[abc, acb, bac, bca, cab, cba]"

6.7. How Do We Reverse Each Word in a Sentence?

We split the sentence on spaces, reverse each word with a StringBuilder, and join the words again. The word order stays the same.

String sentence = "how to do in java";
String reversedWords = Arrays.stream(sentence.split(" "))
    .map(word -> new StringBuilder(word).reverse().toString())
    .collect(Collectors.joining(" "));          // "woh ot od ni avaj"

More exercises of this kind are in the interview puzzles and coding exercises collection.

7. Passwords and Encoding

Two questions about security and bytes round off the list, and both have answers that changed with newer Java versions.

7.1. Why Is char[] Preferred Over String for Passwords?

We can overwrite a char[] after use, but we cannot change a String. A password in a String stays in memory until the garbage collector removes it, and that can take a long time, so a heap dump or a memory-reading attack can find it. This is why Console.readPassword() and JPasswordField.getPassword() return a char[].

Many older answers clear the array with a for-each loop, which does not work, because the loop variable is a copy of each element. We clear the array with Arrays.fill().

char[] pin = {'1', '2', '3', '4'};
for (char ch : pin) {
  ch = '0';
}
String stillThere = new String(pin);                                    // "1234" (the loop changed only copies)
Arrays.fill(pin, '\0');
long remaining = new String(pin).chars().filter(ch -> ch != 0).count(); // 0

Clearing the array limits how long the password stays in memory, but it is not encryption. We still store passwords only as a salted hash, as shown in password hashing in Java.

7.2. How Do We Convert a String to Bytes?

We call getBytes() with an explicit charset. Since Java 18, the default charset is UTF-8 on every operating system (JEP 400), but passing StandardCharsets.UTF_8 keeps the code clear and safe on older versions.

String word = "caf\u00e9";
int chars = word.length();                                        // 4
int utf8Bytes = word.getBytes(StandardCharsets.UTF_8).length;     // 5 (the accented e needs 2 bytes)
int latin1Bytes = word.getBytes(StandardCharsets.ISO_8859_1).length;   // 4
String back = new String(word.getBytes(StandardCharsets.UTF_8), StandardCharsets.UTF_8);   // "caf\u00e9"

The number of characters and the number of bytes differ for any text outside ASCII. A length check on bytes, such as a database column limit, must therefore count the encoded bytes, not length().

8. String Interview Preparation FAQs

Candidates who prepare for a String round often ask the same few questions about the interview itself.

8.1. Which String Questions Are Asked Most Often?

The top five are == vs equals(), why String is immutable, the string pool and intern(), String vs StringBuilder vs StringBuffer, and one coding task such as reversing a string or checking a palindrome. The intro snippet of this page covers the first four in a few lines.

8.2. Do the Answers Differ Between Java 8 and Java 25?

Yes, in a few places, and interviewers for current projects notice old answers.

Topic	Java 8 answer	Java 25 answer
Internal storage	char[]	byte[] plus a coder flag (compact strings, Java 9)
+ in one expression	compiled to StringBuilder	invokedynamic with StringConcatFactory (Java 9)
Default charset of getBytes()	platform-dependent	UTF-8 (Java 18)
Newer String methods	trim(), isEmpty()	strip(), isBlank(), lines(), repeat() (Java 11)
Multiline text	concatenated literals	text blocks (Java 15)
switch on a String	statement only	switch expressions with arrow labels (Java 14)

8.3. Is a Text Block Also a String?

Yes. A text block, written between triple quotes since Java 15, is only another way to write a string literal. The result is a normal String that goes into the pool like any other literal, as shown in multiline strings in Java.

8.4. Where Can I Practice More Java Interview Questions?

The core Java interview questions cover the language as a whole, and the Java String guide explains every method of the class with examples.

9. Conclusion

Most String interview questions come back to two facts. A String never changes, and == compares references while equals() compares characters. The pool, intern(), the HashMap key question and the thread-safety question all follow from them.

For the comparison questions, we know when to pick StringBuilder, why replaceAll() and split() treat the dot as a regex, and how isBlank() differs from isEmpty(). For the coding round, short methods that handle case, null and empty input make a better impression than clever one-liners.

Answers based on Java 8 still circulate, so we mention compact strings, the UTF-8 default and text blocks where they fit.

10. References

• String JavaDoc (Java 25)
• StringBuilder JavaDoc (Java 25)
• JLS 25, String Literals
• JEP 254, Compact Strings
• JEP 280, Indify String Concatenation
• JEP 400, UTF-8 by Default

Happy Learning !!

Source Code on Github