• String in Java is an object that represents a sequence of characters.
• String is immutable (cannot be changed after creation). Any modification creates a new String.
• For editable strings use StringBuilder or StringBuffer (mutable).

1) String Class (Creation)

• Create using literal: String s = "Java";
• Create using new: String s = new String("Java");
• String literals are stored in String Constant Pool for memory optimization.

class StringCreate {
    public static void main(String[] args) {
        String a = "Java";
        String b = new String("Java");
        System.out.println(a);
        System.out.println(b);
    }
}

2) Common String Methods

• length() - returns length
• charAt(i) - character at index
• substring(start, end) - part of string
• toUpperCase(), toLowerCase()
• trim() - removes leading/trailing spaces
• replace(old, new) - replace text
• contains(), startsWith(), endsWith()
• indexOf(), lastIndexOf()
• split(regex) - split using regex

class StringMethods {
    public static void main(String[] args) {
        String name = "  Sourav Sahu  ";

        System.out.println(name.length());
        System.out.println(name.trim());
        System.out.println(name.trim().toUpperCase());
        System.out.println(name.trim().substring(0, 6)); // Sourav
        System.out.println(name.contains("Sahu"));
        System.out.println(name.replace("Sahu", "Kumar"));
    }
}

3) Mutable Strings (StringBuilder & StringBuffer)

• StringBuilder: faster, not thread-safe (single-thread use).
• StringBuffer: thread-safe (synchronized), slightly slower.
• Common methods: append(), insert(), delete(), reverse(), replace()

class MutableStrings {
    public static void main(String[] args) {

        StringBuilder sb = new StringBuilder("Hello");
        sb.append(" Java");
        sb.insert(5, ",");
        System.out.println(sb); // Hello, Java
        sb.reverse();
        System.out.println(sb); // avaJ ,olleH

        StringBuffer sf = new StringBuffer("Mock");
        sf.append(" Test");
        System.out.println(sf); // Mock Test
    }
}

4) String Comparison

• == compares references (memory address), not content.
• equals() compares actual content (recommended).
• equalsIgnoreCase() ignores case.
• compareTo() returns: 0 (equal), +ve (greater), -ve (smaller).

class StringCompare {
    public static void main(String[] args) {

        String s1 = "Java";
        String s2 = "Java";
        String s3 = new String("Java");
        String s4 = "java";

        System.out.println(s1 == s2);        // true (same pool reference)
        System.out.println(s1 == s3);        // false (different object)
        System.out.println(s1.equals(s3));   // true (content same)
        System.out.println(s1.equals(s4));   // false
        System.out.println(s1.equalsIgnoreCase(s4)); // true

        System.out.println("A".compareTo("B")); // negative
        System.out.println("B".compareTo("A")); // positive
        System.out.println("Java".compareTo("Java")); // 0
    }
}

5) Tokenizer (StringTokenizer)

• StringTokenizer breaks a string into tokens using delimiters (like comma, space).
• Useful for simple token splitting (legacy but still used).

import java.util.StringTokenizer;

class TokenizerDemo {
    public static void main(String[] args) {

        String data = "Java,Python,C,SQL";
        StringTokenizer st = new StringTokenizer(data, ",");

        while (st.hasMoreTokens()) {
            System.out.println(st.nextToken());
        }
    }
}

6) Regex Basics (Regular Expressions)

• Regex is a pattern used for matching/searching strings.
• Common patterns:
• \d digit, \D non-digit, \w word, \s space
• [A-Z] uppercase, [a-z] lowercase, [0-9] digit
• Quantifiers: + (one or more), * (zero or more), ? (optional), {n} exactly n
• Java supports regex using: matches(), replaceAll(), split() or Pattern and Matcher.

import java.util.regex.Pattern;

class RegexBasics {
    public static void main(String[] args) {

        // matches(): full string must match the regex
        String mobile = "9876543210";
        boolean ok = mobile.matches("\\d{10}");
        System.out.println("Valid mobile? " + ok);

        // split() using regex
        String line = "Java Python  SQL";
        String[] parts = line.trim().split("\\s+");
        for (String p : parts) {
            System.out.println(p);
        }

        // replaceAll() using regex
        String msg = "ID: 45, Code: 900";
        String onlyDigitsRemoved = msg.replaceAll("\\d", "X");
        System.out.println(onlyDigitsRemoved);

        // Pattern (compiled regex)
        System.out.println(Pattern.matches("[A-Za-z ]+", "Sourav Sahu")); // true
    }
}