String Operations & Fast Input for Java DSA

Quick Reference

The whole sheet at a glance. Telegraphic by design; everything here is unpacked below. Watch the ★/⚠/💡 lines.

String = immutable seq of chars (UTF-16). Any "edit" → NEW object.
len         → s.length()      // method, () needed
char at i   → s.charAt(i)
find        → s.indexOf(x) / lastIndexOf(x)   // -1 if absent
slice       → s.substring(i)  /  s.substring(i, j)  // [i, j)
contains    → s.contains(sub)  |  startsWith / endsWith
case        → toUpperCase / toLowerCase
trim edges  → strip() (Unicode) / trim() (ASCII)
⚠EQUALITY: use .equals(), NEVER ==  (== compares references)
⚠substring(i,j) end is EXCLUSIVE; len = j - i
💡char c = s.charAt(i); int d = c - '0';  // digit char → int

split  s.split(regex)  → String[]   // ARG IS REGEX!
⚠split(".") splits on EVERY char (. = any). Escape: split("\\.")
💡split(regex, -1) keeps trailing empty tokens
join   String.join(delim, parts)  → one String
chars → str: new String(charArr)  |  String.valueOf(charArr)
str → chars: s.toCharArray()

reverse  new StringBuilder(s).reverse().toString()
💡no String.reverse(). SB is the idiom.
DOODLE: box "abc" → arrow → box "cba"; two fingers swap ends inward

StringBuilder = editable char buffer. Build, then toString() ONCE.
append(x) · insert(i,x) · deleteCharAt(i) · delete(i,j)
setCharAt(i,c) · charAt(i) · reverse() · length()
⚠Building a String in a loop with + = O(n²). Use SB = O(n).
💡StringBuffer = SB but synchronized (slower). Single thread → SB.
DOODLE: growing box, append arrows pushing chars in the right end

            String     | StringBuilder | StringBuffer
mutable?    NO         | YES           | YES
thread-safe -          | NO            | YES
speed       -          | FAST          | slower
use for     fixed text | building/edit | rarely (MT)

char is an int → index an array with it.
count letters: int[] f = new int[26]; f[c-'a']++;
💡mixed / ASCII → int[128] or int[256], f[c]++
anagram: ++ for A, -- for B → all zero ⇒ match
anagram key: Arrays.sort(s.toCharArray()) → group by it
shift w/ wrap: (c-'a'+k) % 26 + 'a'
test  Character.isDigit / isLetter / isLetterOrDigit / isWhitespace
num  Integer.parseInt(s) · String.valueOf(n) · parseInt(s,2)=base
💡SB as stack: charAt(len-1) peek, deleteCharAt(len-1) pop

Scanner       easy, SLOW (regex + boxing). Small input only.
BufferedReader read whole LINES fast; split/parse yourself.
br.readLine(); Integer.parseInt(...); new StringTokenizer(line)
StreamTokenizer token-by-token numbers; st.nextToken(); st.nval
Custom DataInputStream read bytes yourself = fastest.
💡Order of speed: Scanner < BufferedReader ≤ StreamTokenizer < custom
⚠Output: use StringBuilder / PrintWriter, flush at END. Never print in a tight loop.
★Slow on 10⁵+ ints? Swap Scanner → BufferedReader FIRST. Usually fixes it.
💡recipes below (§12): read n ints, a grid, T cases, until EOF
DOODLE: 4 boxes L→R, "slow/easy" → "fast/manual", arrow labeled speed

Detailed Walkthrough

Two things quietly make correct string code slow on large inputs: building output with + inside a loop, and reading input with Scanner. This reference fixes both and lays out the string moves you actually reach for while solving — slicing, building, comparing, and counting with characters.

1. What a String really is

A String is a fixed, read-only sequence of characters. Think of it like a word printed on a laminated card: you can read it, copy it, cut a piece out onto a new card, but you can never rub out one letter and write another on the same card. In Java this property is called immutability — once created, a String's contents never change.

So what happens when you write s = s + "!"? Java doesn't edit s. It builds a brand-new String holding the old contents plus "!", and points s at it. The old one is left for the garbage collector. This one fact explains almost every String performance trap you'll hit.

The everyday read-only toolkit

2. Substring — cutting a slice

substring returns a new string covering a range of the original. Picture a ruler laid along the word, with the tick marks between the letters. substring(i, j) cuts from tick i up to (but not including) tick j. That "not including" is where everyone slips.

String s = "DSAROX";
s.substring(2, 5);  // "ARO"  (length = 5 - 2 = 3)
s.substring(2);     // "AROX" (from 2 to end)
s.substring(6);     // ""     (empty, legal)
s.substring(7);     // StringIndexOutOfBoundsException

3. Split & Join — text to pieces and back

Splitting chops a string into an array on a separator; joining glues an array back with a separator between items. Think of a train: splitting uncouples the cars at the couplings, joining hooks them back together with couplings between.

String line = "12,7,90,3";
String[] parts = line.split(",");   // ["12","7","90","3"]
String back = String.join("-", parts); // "12-7-90-3"

Converting between String and char[]

char[] cs = s.toCharArray();          // String -> char[]
String t = new String(cs);          // char[] -> String
String u = String.valueOf(cs);       // same thing, null-safe style

4. Reverse — and why there's no String.reverse()

Reversing flips a string end-for-end. Because String is immutable, it deliberately offers no reverse() — that would imply mutation. The canonical move is to hand the string to a StringBuilder, which is mutable, and reverse there.

String r = new StringBuilder(s).reverse().toString();

If you're doing something custom (reverse only part, reverse words, palindrome check), fall back to a char array and a two-pointer swap:

char[] a = s.toCharArray();
int i = 0, j = a.length - 1;
while (i < j) { char t = a[i]; a[i]=a[j]; a[j]=t; i++; j--; }
String r = new String(a);

5. The mutable string: StringBuilder

A StringBuilder is an editable buffer of characters — the mutable counterpart to String. The analogy: String is ink on paper, StringBuilder is a whiteboard. You scribble, erase, insert, and rearrange freely; when you're done you take one photo of the board (toString()) to get a finished, immutable String.

This is the tool you reach for whenever you're building text piece by piece or editing it in place. It over-allocates its internal array and grows in chunks, so appends are amortized O(1).

Core methods

// GOOD: O(n)
StringBuilder sb = new StringBuilder();
for (int i = 0; i < n; i++) sb.append(arr[i]).append(' ');
String result = sb.toString();

String vs StringBuilder vs StringBuffer

6. Working with characters — counting, tests & conversions

A char is really a small integer, so it can index an array directly. Subtracting a base letter turns a character into a slot: c - 'a' maps 'a'…'z' onto 0…25. That single move powers most counting-based string problems — frequency tables, anagram checks, "first unique character" — in O(n) time and O(1) extra space.

int[] freq = new int[26];
for (char c : s.toCharArray()) freq[c - 'a']++;   // tally each letter

Shifting a letter, with wrap-around

Rotating a letter through the alphabet (a Caesar shift, or "move each letter forward by k") is the same circular-index trick from modular arithmetic: map to 0–25, add the shift, wrap with % 26, map back.

char shift(char c, int k) {
    return (char) ((c - 'a' + k) % 26 + 'a');
}

Testing a character: the Character helpers

Before parsing or validating, you often need to ask what a character is. The Character class answers directly — no character ranges to memorize.

Number ↔ String

Turning text into numbers and back shows up in almost every parsing problem.

int n   = Integer.parseInt("42");      // String -> int   (throws on bad input)
long big = Long.parseLong("9000000000");
String s = Integer.toString(n);         // int -> String
String t = String.valueOf(n);           // same, works for any type
int b   = Integer.parseInt("1011", 2);   // binary string -> 11
String h = Integer.toString(255, 16);    // 255 -> "ff"

7. Reading input: why Scanner betrays you

Input reading is often the real bottleneck, not your algorithm. Scanner is the friendly one you learned first, and it's fine for a handful of values. But it parses with regular expressions and boxes primitives, so on hundreds of thousands of tokens it becomes shockingly slow — frequently the sole reason an otherwise-correct solution times out.

Think of it as a checkout line. Scanner is a cashier who inspects and re-bags every single item individually — safe, but glacial when the cart is huge. The faster readers below are like scanning items in bulk off a conveyor belt.

// Level 0 - Scanner: fine for small input, slow at scale
import java.util.Scanner;
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
String w = sc.next();      // one token
String line = sc.nextLine(); // rest of line

8. BufferedReader — the workhorse upgrade

BufferedReader reads big chunks of input at once into a buffer, then hands you whole lines. You do the parsing (splitting, parseInt), which is exactly why it's fast: no regex tokenizing, no autoboxing per value, no per-character system calls.

import java.io.*;
import java.util.*;

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

int n = Integer.parseInt(br.readLine().trim());   // single int on a line

// a line of space-separated ints -> array
StringTokenizer stk = new StringTokenizer(br.readLine());
int[] a = new int[n];
for (int i = 0; i < n; i++) a[i] = Integer.parseInt(stk.nextToken());

9. StreamTokenizer — when input is mostly numbers

StreamTokenizer streams the input token by token and can parse numbers for you. If a problem is a flood of integers with no tricky formatting, this is clean and fast: it hands you each number directly, no split or parseInt needed.

import java.io.*;
StreamTokenizer st = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));

st.nextToken();  int n = (int) st.nval;   // nval is a double
int[] a = new int[n];
for (int i = 0; i < n; i++) { st.nextToken(); a[i] = (int) st.nval; }

10. The custom fast reader — maximum speed

The fastest approach reads raw bytes from the stream and assembles numbers by hand. You skip character decoding, regex, tokenizing, and boxing entirely. It's overkill for most problems, but for the rare monster input — millions of integers under a tight limit — it's the tool that guarantees reading isn't your bottleneck. The pattern below is a well-known idiom worth keeping in your back pocket.

import java.io.*;

class FastReader {
    private final DataInputStream in;
    private final byte[] buf = new byte[1 << 16];
    private int ptr = 0, len = 0;

    FastReader() { in = new DataInputStream(System.in); }

    private int readByte() throws IOException {
        if (ptr == len) { len = in.read(buf, 0, buf.length); ptr = 0; }
        return len == -1 ? -1 : buf[ptr++];
    }

    int nextInt() throws IOException {
        int c, x = 0; boolean neg = false;
        do { c = readByte(); } while (c <= ' ');   // skip spaces/newlines
        if (c == '-') { neg = true; c = readByte(); }
        while (c > ' ') { x = x * 10 + (c - '0'); c = readByte(); }
        return neg ? -x : x;
    }
}

11. Which reader do I actually use?

Rule of thumb: start at BufferedReader. Drop down to a custom reader only after it's proven necessary.

12. Common input recipes

The handful of shapes that cover most problems. All assume BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

// one int on its own line
int n = Integer.parseInt(br.readLine().trim());

// n space-separated ints on one line -> array
StringTokenizer st = new StringTokenizer(br.readLine());
int[] a = new int[n];
for (int i = 0; i < n; i++) a[i] = Integer.parseInt(st.nextToken());

// an r x c grid of characters
char[][] g = new char[r][];
for (int i = 0; i < r; i++) g[i] = br.readLine().toCharArray();

// T test cases
int T = Integer.parseInt(br.readLine().trim());
while (T-- > 0) { /* read and solve one case */ }

// read until end of input
String line;
while ((line = br.readLine()) != null) { /* process line */ }

Interview & Practice Q&A

Question visible; tap to reveal the answer. Each answer is short enough to say out loud.

Key Takeaways

Self-contained study reference · theme-aware · built for Java DSA revision.