Java Strings

You create strings by wrapping text in double quotes. You can combine strings using the + operator (concatenation):

// Creating strings
String name = "Alice";
String greeting = "Hello, World!";

// Concatenation — joining strings together
String message = "Hello, " + name + "!";
// → "Hello, Alice!"

// Concatenating different types (auto-converted to String)
int age = 25;
String info = name + " is " + age + " years old";
// → "Alice is 25 years old"

// ⚠️ Watch out for order of operations!
System.out.println("Score: " + 5 + 3);   // "Score: 53" (strings!)
System.out.println("Score: " + (5 + 3));  // "Score: 8"  (math first)

Immutability means once a String is created, it can never be changed. Every method that seems to "modify" a string actually creates a brand new string and returns it. The original is untouched.

String name = "Alice";
name.toUpperCase();         // Creates "ALICE" but we don't store it!
System.out.println(name);   // Still "Alice" — original unchanged!

name = name.toUpperCase();  // ✅ Now name points to "ALICE"
System.out.println(name);   // "ALICE"

Java also maintains a String Pool — a special memory area that reuses identical string literals:

String a = "Hello";              // Goes to String Pool
String b = "Hello";              // Reuses same object!
String c = new String("Hello");  // Forces NEW object (bypasses pool)

a == b     // true  (same pool object)
a == c     // false (different objects!)
a.equals(c) // true  (same content ✓)

These are the methods you'll use every day. Memorize these and you'll handle 90% of string tasks:

String text = "Hello, World!";

// === INSPECTING ===
text.length()              // 13 (number of characters)
text.charAt(0)             // 'H' (first character)
text.charAt(6)             // 'W' 
text.isEmpty()             // false
text.isBlank()             // false (Java 11+, checks whitespace too)

// === SEARCHING ===
text.contains("World")     // true
text.indexOf("World")      // 7 (position where "World" starts)
text.indexOf("xyz")        // -1 (not found)
text.lastIndexOf("l")      // 10 (last occurrence)
text.startsWith("Hello")   // true
text.endsWith("!")          // true

// === TRANSFORMING (returns NEW string!) ===
text.toUpperCase()         // "HELLO, WORLD!"
text.toLowerCase()         // "hello, world!"
text.substring(0, 5)       // "Hello" (from index 0 to 4)
text.substring(7)          // "World!" (from index 7 to end)
text.replace("World", "Java") // "Hello, Java!"
"  spaces  ".trim()        // "spaces"

// === SPLITTING & JOINING ===
"a,b,c".split(",")        // String[] {"a", "b", "c"}
String.join(" - ", "a", "b", "c")  // "a - b - c"

This is the single most common bug Java beginners make. Let's be absolutely clear about it:

// ❌ WRONG — compares memory addresses, not content!
String input = scanner.nextLine();  // user types "yes"
if (input == "yes") { ... }  // MIGHT work, might not! Unreliable!

// ✅ CORRECT — compares actual text content
if (input.equals("yes")) { ... }

// ✅ Case-insensitive comparison
if (input.equalsIgnoreCase("YES")) { ... }

// ✅ Null-safe trick — put the constant first
if ("yes".equals(input)) { ... }  // Won't crash even if input is null!

// ❌ CRASH if input is null
if (input.equals("yes")) { ... }  // NullPointerException!

Because strings are immutable, concatenation in a loop creates a new string object every iteration. For large loops, this wastes massive amounts of memory. Use StringBuilder instead:

// ❌ SLOW — creates 1000 temporary String objects!
String result = "";
for (int i = 0; i < 1000; i++) {
    result += i + ", ";  // New String EVERY time
}

// ✅ FAST — uses one mutable buffer
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append(i).append(", ");
}
String result = sb.toString();

// StringBuilder methods:
sb.append("text");      // Add to end
sb.insert(0, "start");  // Insert at position
sb.delete(0, 5);        // Remove characters
sb.reverse();            // Reverse the content
sb.length();             // Current length
sb.toString();           // Convert to String

Instead of ugly concatenation with lots of + signs, use String.format() for readable, clean string construction:

String name = "Alice";
int age = 30;
double gpa = 3.857;

// ❌ Hard to read with concatenation
String msg1 = "Name: " + name + ", Age: " + age + ", GPA: " + gpa;

// ✅ Clean with String.format()
String msg2 = String.format("Name: %s, Age: %d, GPA: %.1f", name, age, gpa);
// → "Name: Alice, Age: 30, GPA: 3.9"

// Format specifiers:
// %s  = String
// %d  = integer
// %f  = floating-point
// %.2f = 2 decimal places
// %n  = newline
// %10s = right-padded to 10 chars
// %-10s = left-padded to 10 chars

Here are patterns you'll use constantly in real Java applications:

// Email validation (basic)
boolean validEmail = email.contains("@") && email.contains(".");

// File extension check
if (filename.endsWith(".java")) { ... }
if (filename.endsWith(".pdf") || filename.endsWith(".doc")) { ... }

// Parsing CSV data
String line = "Alice,25,3.85";
String[] parts = line.split(",");
String name = parts[0];        // "Alice"
int age = Integer.parseInt(parts[1]);  // 25
double gpa = Double.parseDouble(parts[2]); // 3.85

// Creating URL slugs
String slug = title.toLowerCase()
    .replaceAll("[^a-z0-9]+", "-")  // Replace non-alphanumeric
    .replaceAll("^-|-$", "");        // Remove leading/trailing dashes

// Sanitizing user input
String clean = input.trim()             // Remove leading/trailing spaces
    .replaceAll("\\s+", " ");        // Collapse multiple spaces