Strings

A string is a read-only array of characters

In Java, a String wraps a character array and gives you array-flavored tools to inspect it. length() tells you how many characters it holds. charAt(i) hands you the character at index i in O(1), exactly like arr[i]. Indexes run from 0 to length() - 1, and going outside that range throws StringIndexOutOfBoundsException.

When a problem needs heavy character-by-character work, it is often cleaner to call toCharArray(), which copies the string's characters into a real char[] you can index and even modify freely. The copy costs O(n) once, and afterward you are back in familiar array territory. One more useful trick: characters are numbers underneath, so arithmetic like s.charAt(i) - 'a' converts a lowercase letter into an index from 0 to 25. The backbone of counting problems.

String word = "interview";

char first = word.charAt(0);
int len = word.length();

char[] chars = word.toCharArray();
for (int i = 0; i < chars.length; i++) {
    System.out.println(i + ": " + chars[i]);
}

Immutability: strings never change

Here is the sharpest edge: Java strings are immutable, meaning once a String object is created, its characters can never be altered. There is no s.setCharAt(2, 'x'). Methods that look like they modify a string (toUpperCase, replace, substring, trim) actually build and return a brand-new string, leaving the original untouched. If you ignore the return value, nothing happens.

Why design it this way? Immutability makes strings safe to share between parts of a program and lets Java cache and reuse them internally. The practical consequences for you: every "modification" allocates a new string and copies characters, costing O(n); and if you truly need in-place edits, convert to a char[] first, edit the array, and build a new String from it at the end.

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

String shout = s.toUpperCase();
System.out.println(shout);

char[] arr = s.toCharArray();
arr[0] = 'j';
String edited = new String(arr);
System.out.println(edited);

StringBuilder: how to build strings in a loop

Immutability creates a classic performance trap. Concatenating with += in a loop looks harmless, but each += builds an entirely new string by copying everything so far plus the new piece. After n rounds, you have copied roughly 1 + 2 + 3 + ... + n characters, that sum is on the order of n squared, so the loop is O(n squared) even though it looks like one pass.

The fix is StringBuilder, a mutable companion class that works like an ArrayList of characters. Its append method drops characters into an internal resizable array in amortized O(1), and one final toString() call produces the result. Total cost: O(n). The rule is simple and worth stating in interviews: any time you assemble a string piece by piece in a loop, reach for StringBuilder. It also gives you reverse(), the one-liner behind many palindrome and reversal problems.

String repeatBad(String piece, int times) {
    String result = "";
    for (int i = 0; i < times; i++) {
        result += piece;
    }
    return result;
}

String repeatGood(String piece, int times) {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < times; i++) {
        sb.append(piece);
    }
    return sb.toString();
}

Comparing strings, and where to go next

The other famous Java gotcha: never compare string contents with ==. The == operator asks whether two references point to the same object in memory, not whether the characters match. Two strings can hold identical text and still fail ==. Always use s.equals(t) for content equality, equalsIgnoreCase for case-blind comparison, and compareTo for alphabetical ordering. This is a one-line mistake that can sink an otherwise correct solution.

Zoom out and the toolkit is compact: charAt and toCharArray for inspection, StringBuilder for construction, equals for comparison, and the knowledge that every hidden copy costs O(n). Most interview string problems (counting characters, detecting anagrams, checking palindromes) combine these tools with one more idea: a fast way to count and look things up. That idea is the hash map, and it is next.

Frequently asked