String handling

The Architectural Immutability of Strings:

In Java, strings are represented by the java.lang.String class. Unlike primitive characters, a String object is immutable—its character array cannot be modified, resized, or overwritten after creation. Any method that appears to modify a String (such as concat(), replace(), or toUpperCase()) does not alter the original instance; it allocates and returns a completely new String object on the Heap.

String Constant Pool (SCP) vs Standard Heap:

To conserve RAM, the JVM manages a specialized cache in Heap memory called the String Constant Pool (SCP):

• Literal Creation (String s1 = "INDIA";): The JVM checks the SCP. If "INDIA" already exists, no new memory is allocated; s1 simply receives the reference to the existing pooled instance.
• Keyword Creation (String s2 = new String("INDIA");): The new operator bypasses the SCP check and forcibly instantiates an independent, distinct object in regular Heap memory.

The Three Modes of String Comparison:

1. charAt(int index):

Returns the character at the specified index ($0$ to $\text{length} - 1$).

String s = "COMPUTER";
char ch = s.charAt(3); // Returns 'P' (indices: 0:C, 1:O, 2:M, 3:P)

2. substring(int beginIndex):

Returns a new string containing characters from beginIndex to the end of the string.

String s = "UNDERSTAND";
String sub = s.substring(5); // Returns "STAND" (indices 5 through 9)

3. substring(int beginIndex, int endIndex):

Extracts characters starting at beginIndex (inclusive) up to endIndex - 1 (exclusive). The character at endIndex is NEVER included!

String s = "WONDERFUL";
String sub = s.substring(0, 6); // Returns "WONDER" (indices 0, 1, 2, 3, 4, 5)

Standard Utility Operations:

Why StringBuffer / StringBuilder?

Because String is immutable, repeated concatenation inside loops creates hundreds of discarded intermediate objects on the Heap, degrading performance. To solve this, Java provides two mutable companion classes:

• StringBuffer: Thread-safe, synchronized, thread-safe for multi-threaded environments.
• StringBuilder: Non-synchronized, faster performance, ideal for single-threaded algorithms.

StringBuilder sb = new StringBuilder("Java");
sb.append(" Programming"); // Mutates in-place!
sb.reverse();              // Reverses character order directly!
System.out.println(sb);    // Prints reversed string without creating intermediate objects

Palindrome Word vs Special Word:

• Palindrome Word: Reads the same backward as forward (e.g., MADAM, NITIN, RACECAR).
• Special Word: Begins and ends with the exact same letter (e.g., WINDOW begins with 'W' and ends with 'W'; EXIST begins and ends with 'E').

// Special Word & Palindrome Evaluation
String w = "MADAM";
w = w.toUpperCase();

// 1. Special Word Check:
boolean isSpecial = (w.charAt(0) == w.charAt(w.length() - 1));

// 2. Palindrome Check:
String rev = "";
for (int i = w.length() - 1; i >= 0; i--) {
    rev += w.charAt(i);
}
boolean isPalindrome = w.equals(rev);

System.out.println("Special Word   : " + isSpecial);
System.out.println("Palindrome Word: " + isPalindrome);

Model Program 1: Pig Latin Translation Algorithm

Pig Latin Definition: A word is converted to Pig Latin by locating the first vowel in the word ($A, E, I, O, U$). All characters from that vowel to the end of the word form the beginning of the Pig Latin word, followed by the consonants preceding the vowel, and finally suffixed with "AY". If no vowel is found, "AY" is simply appended at the end.

Examples: "LONDON" → "ONDONLAY"; "TROUBLE" → "OUBLETRAY"; "EAT" → "EATAY".

import java.util.Scanner;

public class PigLatinTranslator {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a word: ");
        String word = sc.next().toUpperCase();

        int vowelIndex = -1;
        for (int i = 0; i < word.length(); i++) {
            char ch = word.charAt(i);
            if (ch == 'A' || ch == 'E' || ch == 'I' || ch == 'O' || ch == 'U') {
                vowelIndex = i;
                break;
            }
        }

        String pigLatin;
        if (vowelIndex != -1) {
            pigLatin = word.substring(vowelIndex) + word.substring(0, vowelIndex) + "AY";
        } else {
            pigLatin = word + "AY";
        }

        System.out.println("Original Word : " + word);
        System.out.println("Pig Latin Word: " + pigLatin);
    }
}

Model Program 2: Bubble Sort on Array of Names using compareTo()

import java.util.Scanner;

public class SortNamesLexicographical {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String[] names = new String[5];

        System.out.println("Enter 5 names:");
        for (int i = 0; i < names.length; i++) {
            System.out.print("Name " + (i + 1) + ": ");
            names[i] = in.nextLine().trim();
        }

        // Bubble Sort using compareTo()
        for (int i = 0; i < names.length - 1; i++) {
            for (int j = 0; j < names.length - 1 - i; j++) {
                // If names[j] comes alphabetically after names[j+1]:
                if (names[j].compareTo(names[j + 1]) > 0) {
                    String temp = names[j];
                    names[j] = names[j + 1];
                    names[j + 1] = temp;
                }
            }
        }

        System.out.println("
Names in Alphabetical (Lexicographical) Order:");
        for (String n : names) {
            System.out.println(n);
        }
    }
}