Unit 7: String & StringBuilder

Opening Hook — Every UPI Payment Runs Through Java Strings

Learning Outcomes — Bloom's Taxonomy Mapped (12 Outcomes)

Concept Explanation — String & StringBuilder from Scratch

1. String Immutability & Memory Model

In Java, a String is immutable — once created, its value can never be changed. When you write s = s + " world", you're NOT modifying the original String. Java creates a brand-new String object and points s to it. The old String stays in memory until garbage collected.

Memory
// Code:
String s1 = "hello";        // → Pool: creates "hello"
String s2 = "hello";        // → Pool: reuses same "hello"
String s3 = new String("hello"); // → Heap: NEW object (outside pool)

/*
  ┌──────────── HEAP MEMORY ────────────┐
  │                                      │
  │   ┌──── STRING POOL ────┐           │
  │   │                     │           │
  │   │   ┌───────────┐    │           │
  │   │   │  "hello"  │◄───┼── s1      │
  │   │   └───────────┘    │◄── s2     │
  │   │                     │           │
  │   └─────────────────────┘           │
  │                                      │
  │   ┌───────────┐                     │
  │   │  "hello"  │◄────────── s3       │
  │   └───────────┘  (separate object)  │
  │                                      │
  └──────────────────────────────────────┘

  s1 == s2  → true  (same reference in pool)
  s1 == s3  → false (different objects)
  s1.equals(s3) → true (same content)
*/

// ❌ BAD — creates 10,000 String objects
String result = "";
for (int i = 0; i < 10000; i++) {
    result = result + i;  // New object every iteration!
}

// ✅ GOOD — single mutable object
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10000; i++) {
    sb.append(i);  // Same object modified
}
String result = sb.toString();

2. String Constructors

Java
// 1. Empty String
String s1 = new String();                // s1 = ""

// 2. From another String
String s2 = new String("Namaste");     // s2 = "Namaste"

// 3. From char array
char[] chars = {'J', 'a', 'v', 'a'};
String s3 = new String(chars);          // s3 = "Java"

// 4. From char array with offset and count
String s4 = new String(chars, 1, 2);    // s4 = "av" (start at index 1, take 2 chars)

// 5. From byte array
byte[] bytes = {72, 101, 108, 108, 111};
String s5 = new String(bytes);          // s5 = "Hello"

// 6. From StringBuilder
StringBuilder sb = new StringBuilder("India");
String s6 = new String(sb);              // s6 = "India"

// 7. Most common — String literal (uses String pool)
String s7 = "PhonePe";                  // Preferred! Uses pool.

3. String Methods — Complete Reference

3.1 Length & Character Access

Java
String city = "Bengaluru";

// length() — number of characters
System.out.println(city.length());          // 9

// charAt(index) — character at position
System.out.println(city.charAt(0));          // B
System.out.println(city.charAt(5));          // l

// toCharArray() — convert to char array
char[] arr = city.toCharArray();
for (char c : arr) System.out.print(c + " ");
// B e n g a l u r u

3.2 Searching

Java
String upi = "rahul.kumar@ybl";

// indexOf(String) — first occurrence position (-1 if not found)
System.out.println(upi.indexOf("@"));         // 11
System.out.println(upi.indexOf("xyz"));       // -1

// lastIndexOf(String) — last occurrence position
String path = "com.paytm.app.Main";
System.out.println(path.lastIndexOf("."));    // 14

// contains(CharSequence) — true/false check
System.out.println(upi.contains("@"));        // true
System.out.println(upi.contains("paytm"));    // false

// startsWith(String) and endsWith(String)
System.out.println(upi.startsWith("rahul"));  // true
System.out.println(upi.endsWith("@ybl"));     // true
System.out.println(upi.endsWith("@paytm"));   // false

3.3 Extraction

Java
String aadhaar = "1234-5678-9012";

// substring(beginIndex) — from index to end
System.out.println(aadhaar.substring(5));       // 5678-9012

// substring(beginIndex, endIndex) — from begin to end-1
System.out.println(aadhaar.substring(0, 4));   // 1234
System.out.println(aadhaar.substring(5, 9));   // 5678

3.4 Comparison — The Most Important Section

Java
// equals() — compares CONTENT
String a = "Java";
String b = new String("Java");
System.out.println(a.equals(b));              // true  (same content)

// == — compares REFERENCE (memory address)
System.out.println(a == b);                   // false (different objects!)

// equalsIgnoreCase() — case-insensitive content check
System.out.println("JAVA".equalsIgnoreCase("java")); // true

// compareTo() — lexicographic comparison (returns int)
System.out.println("Apple".compareTo("Banana"));  // negative (A < B)
System.out.println("Cat".compareTo("Cat"));      // 0 (equal)
System.out.println("Dog".compareTo("Cat"));      // positive (D > C)

3.5 Modification (Returns New String)

Java
String name = "  Rahul Sharma  ";

// trim() — removes leading/trailing whitespace
System.out.println(name.trim());               // "Rahul Sharma"

// toUpperCase() and toLowerCase()
System.out.println("india".toUpperCase());      // "INDIA"
System.out.println("JAVA".toLowerCase());       // "java"

// replace(old, new) — replace all occurrences
String phone = "98765-43210";
System.out.println(phone.replace("-", ""));    // "9876543210"
System.out.println(phone.replace('9', 'X'));  // "X8765-43210"

// replaceAll(regex, replacement)
String data = "Price: Rs.500, Tax: Rs.90";
System.out.println(data.replaceAll("[0-9]+", "***"));
// "Price: Rs.***, Tax: Rs.***"

3.6 Splitting & Joining

Java
// split(regex) — break string into array
String csv = "Rahul,BCA,Mumbai,8.5";
String[] parts = csv.split(",");
System.out.println(parts[0]);  // Rahul
System.out.println(parts[1]);  // BCA
System.out.println(parts[2]);  // Mumbai
System.out.println(parts[3]);  // 8.5

// String.join(delimiter, elements) — combine with separator
String result = String.join(" | ", "PhonePe", "GPay", "Paytm");
System.out.println(result);  // PhonePe | GPay | Paytm

// split with limit
String upi = "rahul.kumar@ybl";
String[] upiParts = upi.split("@", 2);
System.out.println("Username: " + upiParts[0]);  // rahul.kumar
System.out.println("Handle: " + upiParts[1]);    // ybl

3.7 Conversion & Formatting

Java
// valueOf() — convert other types to String
String numStr = String.valueOf(42);           // "42"
String boolStr = String.valueOf(true);       // "true"
String dblStr = String.valueOf(3.14);        // "3.14"

// format() — formatted String (like printf)
String msg = String.format("Name: %s, Age: %d, CGPA: %.1f",
                           "Priya", 21, 8.754);
System.out.println(msg);
// Name: Priya, Age: 21, CGPA: 8.8

3.8 Checking

Java
// isEmpty() — true if length is 0
System.out.println("".isEmpty());       // true
System.out.println(" ".isEmpty());      // false (has a space)

// isBlank() — true if empty or only whitespace (Java 11+)
System.out.println("   ".isBlank());   // true
System.out.println("Hi".isBlank());    // false

4. String Comparison Deep-Dive: == vs equals() vs compareTo()

This is the #1 most-asked topic in Java interviews and MCQ exams. Getting this wrong in a TCS NQT or Infosys exam means losing easy marks. Let's break it down with tricky examples:

Tricky Example 1: String Pool Trap

Java
String s1 = "hello";
String s2 = "hello";
String s3 = new String("hello");

System.out.println(s1 == s2);       // true  — both from pool, same reference
System.out.println(s1 == s3);       // false — s3 is on heap, different reference
System.out.println(s1.equals(s3));  // true  — same content "hello"

Tricky Example 2: Concatenation Trap

Java
String s1 = "hello";
String s2 = "hel" + "lo";    // Compile-time constant → optimised to "hello"
String s3 = "hel";
String s4 = s3 + "lo";         // Runtime concatenation → NEW object

System.out.println(s1 == s2);   // true  — compiler optimises "hel" + "lo" to "hello"
System.out.println(s1 == s4);   // false — s4 created at runtime, new object
System.out.println(s1.equals(s4)); // true  — same content

Tricky Example 3: intern() Method

Java
String s1 = "hello";
String s2 = new String("hello");
String s3 = s2.intern();  // Returns pool reference of "hello"

System.out.println(s1 == s2);   // false — s2 is on heap
System.out.println(s1 == s3);   // true  — intern() returned the pool copy

Tricky Example 4: compareTo() Returns

Java
System.out.println("A".compareTo("B"));   // -1  (A comes before B)
System.out.println("B".compareTo("A"));   // +1  (B comes after A)
System.out.println("A".compareTo("A"));   // 0   (equal)
System.out.println("a".compareTo("A"));   // +32 (lowercase 'a' = 97, uppercase 'A' = 65)
System.out.println("Apple".compareTo("App")); // +2 (difference in length)

5. StringBuilder — Mutable Strings

Since Strings are immutable, Java provides StringBuilder for situations where you need to modify text frequently. StringBuilder is mutable — you can change its content without creating new objects.

StringBuilder Constructors

Java
// Default capacity: 16 characters
StringBuilder sb1 = new StringBuilder();

// Custom initial capacity
StringBuilder sb2 = new StringBuilder(100);

// From String
StringBuilder sb3 = new StringBuilder("Hello");
System.out.println(sb3.capacity());  // 21 (16 + 5 chars of "Hello")

StringBuilder Methods

Java
StringBuilder sb = new StringBuilder("Hello");

// append() — add to end
sb.append(" World");         // "Hello World"
sb.append(2025);              // "Hello World2025"
sb.append('!');               // "Hello World2025!"

// insert(offset, data) — insert at position
sb = new StringBuilder("Hello World");
sb.insert(5, " Beautiful");  // "Hello Beautiful World"

// delete(start, end) — remove characters
sb.delete(5, 15);             // "Hello World"

// deleteCharAt(index)
sb = new StringBuilder("Hello!");
sb.deleteCharAt(5);           // "Hello"

// replace(start, end, str)
sb = new StringBuilder("Hello World");
sb.replace(6, 11, "India");  // "Hello India"

// reverse()
sb = new StringBuilder("MADAM");
sb.reverse();                 // "MADAM" (palindrome!)

// toString() — convert back to String
String result = sb.toString();

// capacity() and length()
sb = new StringBuilder();
System.out.println(sb.capacity());  // 16 (default)
System.out.println(sb.length());    // 0  (no chars yet)

// charAt(index) and setCharAt(index, char)
sb = new StringBuilder("Java");
System.out.println(sb.charAt(0));    // J
sb.setCharAt(0, 'L');              // "Lava"

6. String vs StringBuilder vs StringBuffer

7. String Formatting (printf / format)

Java
// printf — prints formatted output directly
System.out.printf("Student: %-15s | CGPA: %.1f | Rank: %03d%n",
                  "Priya Sharma", 8.754, 5);
// Student: Priya Sharma    | CGPA: 8.8 | Rank: 005

// String.format — returns formatted String
String receipt = String.format(
    "UPI Txn: ₹%,.2f sent to %s via %s",
    1500.50, "rahul@ybl", "PhonePe"
);
System.out.println(receipt);
// UPI Txn: ₹1,500.50 sent to rahul@ybl via PhonePe

8. Complete Programs

Program 1: Palindrome Checker

Java
public class PalindromeChecker {
    public static boolean isPalindrome(String str) {
        str = str.toLowerCase().replaceAll("[^a-z0-9]", "");
        String reversed = new StringBuilder(str).reverse().toString();
        return str.equals(reversed);
    }

    public static void main(String[] args) {
        String[] tests = {"MADAM", "RaceCar", "Hello", "A man a plan a canal Panama"};
        for (String test : tests) {
            System.out.printf("%-35s → %s%n", "\"" + test + "\"",
                isPalindrome(test) ? "✅ Palindrome" : "❌ Not Palindrome");
        }
    }
}

Program 2: Anagram Detector

Java
import java.util.Arrays;

public class AnagramDetector {
    public static boolean areAnagrams(String s1, String s2) {
        s1 = s1.toLowerCase().replaceAll("\\s", "");
        s2 = s2.toLowerCase().replaceAll("\\s", "");
        if (s1.length() != s2.length()) return false;
        char[] arr1 = s1.toCharArray();
        char[] arr2 = s2.toCharArray();
        Arrays.sort(arr1);
        Arrays.sort(arr2);
        return Arrays.equals(arr1, arr2);
    }

    public static void main(String[] args) {
        System.out.println(areAnagrams("listen", "silent"));     // true
        System.out.println(areAnagrams("Triangle", "Integral")); // true
        System.out.println(areAnagrams("Hello", "World"));      // false
        System.out.println(areAnagrams("Dormitory", "Dirty Room")); // true
    }
}

Program 3: CSV Parser

Java
public class CSVParser {
    public static void main(String[] args) {
        String[] csvData = {
            "Rahul Sharma,BCA,Mumbai,8.5,PhonePe",
            "Priya Patel,B.Tech,Ahmedabad,9.1,Google",
            "Amit Kumar,MCA,Delhi,7.8,Paytm",
            "Sneha Reddy,BCA,Hyderabad,8.9,Infosys"
        };

        System.out.printf("%-18s %-8s %-14s %-6s %-10s%n",
                          "NAME", "COURSE", "CITY", "CGPA", "COMPANY");
        System.out.println("─".repeat(60));

        double totalCgpa = 0;
        int count = 0;

        for (String line : csvData) {
            String[] fields = line.split(",");
            String name = fields[0].trim();
            String course = fields[1].trim();
            String city = fields[2].trim();
            double cgpa = Double.parseDouble(fields[3].trim());
            String company = fields[4].trim();

            System.out.printf("%-18s %-8s %-14s %-6.1f %-10s%n",
                              name, course, city, cgpa, company);
            totalCgpa += cgpa;
            count++;
        }

        System.out.println("─".repeat(60));
        System.out.printf("Average CGPA: %.2f%n", totalCgpa / count);
    }
}

Program 4: UPI ID Validator

Java
public class UPIIDValidator {
    static final String[] VALID_HANDLES = {
        "ybl", "paytm", "oksbi", "okaxis", "okhdfcbank",
        "okicici", "ibl", "axl", "sbi", "upi", "apl"
    };

    public static String validate(String upiId) {
        if (upiId == null || upiId.isEmpty()) return "❌ Empty UPI ID";
        upiId = upiId.trim().toLowerCase();

        // Check @ symbol
        if (!upiId.contains("@")) return "❌ Missing @ symbol";

        String[] parts = upiId.split("@");
        if (parts.length != 2) return "❌ Invalid format (multiple @ symbols)";

        String username = parts[0];
        String handle = parts[1];

        // Validate username: 3-50 chars, alphanumeric and dots only
        if (username.length() < 3 || username.length() > 50)
            return "❌ Username must be 3-50 characters";
        if (!username.matches("[a-z0-9.]+"))
            return "❌ Username can only contain lowercase letters, digits, dots";

        // Validate handle against known PSPs
        boolean validHandle = false;
        for (String vh : VALID_HANDLES) {
            if (handle.equals(vh)) { validHandle = true; break; }
        }
        if (!validHandle) return "❌ Unknown handle: @" + handle;

        return "✅ Valid UPI ID → User: " + username + ", PSP: @" + handle;
    }

    public static void main(String[] args) {
        String[] testIds = {
            "rahul.kumar@ybl", "priya@paytm", "amit@unknown",
            "ab@oksbi", "invalid_id", "sneha.reddy@okhdfcbank"
        };
        for (String id : testIds) {
            System.out.printf("%-25s → %s%n", id, validate(id));
        }
    }
}

Learn by Doing — 3-Tier Lab Structure

Java
public class UPIValidator {
    public static void main(String[] args) {
        String upiId = "rahul.kumar@ybl";
        System.out.println("Testing: " + upiId);
    }
}

Java
if (upiId.contains("@")) {
    System.out.println("✅ Contains @ symbol");
} else {
    System.out.println("❌ Missing @ symbol");
}

Java
String[] parts = upiId.split("@");
String username = parts[0];
String handle = parts[1];
System.out.println("Username: " + username);
System.out.println("Handle: " + handle);

Java
if (username.length() >= 3 && username.length() <= 50) {
    System.out.println("✅ Username length OK");
} else {
    System.out.println("❌ Username too short or too long");
}

Java
String[] validHandles = {"ybl", "paytm", "oksbi", "okaxis", "ibl"};
boolean found = false;
for (String vh : validHandles) {
    if (handle.equals(vh)) { found = true; break; }
}
System.out.println(found ? "✅ Valid handle" : "❌ Unknown handle");

Problem Set — Syntax, Programming & Interview Questions

Part 1: Syntax & Tracing (5 Questions)

E1. What is the output?

Java
String s1 = "Java";
String s2 = new String("Java");
System.out.println(s1 == s2);
System.out.println(s1.equals(s2));

E2. What is the output?

Java
String s1 = "Hello";
String s2 = "Hel" + "lo";
String s3 = "Hel";
String s4 = s3 + "lo";
System.out.println(s1 == s2);
System.out.println(s1 == s4);

E3. What is the output?

Java
String s = "Hello";
s.concat(" World");
System.out.println(s);

E4. What is the output?

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

E5. What is the output?

Java
StringBuilder sb = new StringBuilder("Hello");
sb.append(" World");
sb.insert(5, ",");
System.out.println(sb);

Part 2: Programming Questions (8 Questions)

P1. Write a program to reverse a String without using StringBuilder.reverse(). Use a for loop and charAt().

P2. Write a program to count the number of vowels, consonants, digits, and spaces in a given String.

P3. Write a program to remove duplicate characters from a String (e.g., "programming" → "progamin").

P4. Write a program to check if a String is a valid Indian mobile number (starts with 6/7/8/9, exactly 10 digits).

P5. Write a program to find the most frequently occurring character in a String.

P6. Write a program to convert a sentence to Title Case (e.g., "hello world" → "Hello World").

P7. Write a program to compress a String using run-length encoding (e.g., "aaabbbcc" → "a3b3c2").

P8. Write a program that takes a student's name and roll number, then generates an email ID in the format: firstname.rollno@university.edu.

Part 3: Industry Questions (3 Questions)

I1. A Paytm log file contains transaction records in the format: "TXN|timestamp|amount|status|upiId". Write a program to parse 5 such records, calculate total successful transaction amount, and display failed transactions.

I2. You're building a spam filter for an Indian email service. Write a program that checks if an email subject line contains any of these spam keywords: "lottery", "winner", "free", "click here", "urgent". Use toLowerCase() and contains().

I3. An Indian e-commerce site stores product descriptions as pipe-separated values: "name|price|category|rating". Write a program to parse and display products with rating > 4.0, sorted by price.

Part 4: Interview Questions (3 Questions)

MCQ Assessment Bank — 30 Questions (Bloom's Mapped)

Remember / Identify (Q1–Q5)

Understand / Explain (Q6–Q10)

Apply / Use (Q11–Q15)

Analyze / Compare (Q16–Q20)

Evaluate / Justify (Q21–Q25)

Create / Design (Q26–Q30)

Short Answer Questions (8 Questions)

SA1. What is String immutability? Give one advantage and one disadvantage.

SA2. Explain the String pool with an example.

SA3. Explain the difference between == and equals() for Strings.

SA4. What is the difference between StringBuilder and StringBuffer?

SA5. What does String.format() do? Give an example with format specifiers.

SA6. What does the intern() method do?

SA7. Why is the String class declared final in Java?

SA8. What is the use of toCharArray()? Give a practical example.

Long Answer Questions (3 Questions)

LA1. Explain String immutability with a memory diagram. Discuss advantages and disadvantages of immutability. (10 marks)

String s1 = "Hello";   // Creates "Hello" in String pool
String s2 = s1;        // s2 points to same "Hello"
s1 = s1 + " World";   // Creates NEW "Hello World", s1 re-pointed

BEFORE s1 = s1 + " World":
  s1 ──→ "Hello" ←── s2    (same object in pool)

AFTER s1 = s1 + " World":
  s1 ──→ "Hello World"     (new object on heap)
  s2 ──→ "Hello"            (still points to original)

LA2. Compare String, StringBuilder, and StringBuffer with code examples and performance analysis. (10 marks)

String s = "Hello";
s = s + " World";  // New object created, old "Hello" is garbage

StringBuilder sb = new StringBuilder("Hello");
sb.append(" World");  // Same object modified

StringBuffer sbuf = new StringBuffer("Hello");
sbuf.append(" World");  // Thread-safe modification

LA3. Write and explain a complete program that processes student data stored as CSV strings. Include parsing, validation, and formatted output. (10 marks)

public class StudentCSVProcessor {
    public static void main(String[] args) {
        String[] records = {
            "101,Rahul Sharma,BCA,8.5,Mumbai",
            "102,Priya Patel,B.Tech,9.2,Ahmedabad",
            "103,,MCA,7.0,Delhi",              // Missing name
            "104,Amit Kumar,BCA,invalid,Pune"   // Invalid CGPA
        };

        StringBuilder report = new StringBuilder();
        report.append(String.format("%-6s %-20s %-8s %-6s %-12s%n",
                "ROLL", "NAME", "COURSE", "CGPA", "CITY"));
        report.append("─".repeat(55)).append("\n");

        int valid = 0, invalid = 0;
        double totalCgpa = 0;

        for (String record : records) {
            String[] fields = record.split(",");
            if (fields.length != 5) { invalid++; continue; }

            String roll = fields[0].trim();
            String name = fields[1].trim();
            String course = fields[2].trim();
            String cgpaStr = fields[3].trim();
            String city = fields[4].trim();

            // Validate name
            if (name.isEmpty()) {
                report.append("⚠️ Record " + roll + ": Missing name\n");
                invalid++; continue;
            }

            // Validate CGPA
            double cgpa;
            try {
                cgpa = Double.parseDouble(cgpaStr);
            } catch (NumberFormatException e) {
                report.append("⚠️ Record " + roll + ": Invalid CGPA\n");
                invalid++; continue;
            }

            report.append(String.format("%-6s %-20s %-8s %-6.1f %-12s%n",
                    roll, name, course, cgpa, city));
            totalCgpa += cgpa;
            valid++;
        }

        report.append("─".repeat(55)).append("\n");
        report.append("Valid: " + valid + " | Invalid: " + invalid);
        if (valid > 0)
            report.append(" | Avg CGPA: " +
                String.format("%.2f", totalCgpa / valid));

        System.out.println(report);
    }
}

Lab Program — Lab 6: String and StringBuilder

Java
public class Lab6_StringAndStringBuilder {

    public static void main(String[] args) {

        // ═══════════════════════════════════════
        // PART 1: String Creation — Literal vs new
        // ═══════════════════════════════════════
        System.out.println("══ PART 1: String Creation ══");
        String s1 = "Hello";             // String pool
        String s2 = "Hello";             // Same pool reference
        String s3 = new String("Hello"); // Heap (new object)

        System.out.println("s1 == s2 (pool): " + (s1 == s2));       // true
        System.out.println("s1 == s3 (new):  " + (s1 == s3));       // false
        System.out.println("s1.equals(s3):   " + s1.equals(s3));    // true

        // ═══════════════════════════════════════
        // PART 2: All Major String Methods
        // ═══════════════════════════════════════
        System.out.println("\n══ PART 2: String Methods ══");
        String str = "  Programming in Java  ";

        System.out.println("Original:      '" + str + "'");
        System.out.println("length():      " + str.length());
        System.out.println("trim():        '" + str.trim() + "'");
        System.out.println("toUpperCase(): " + str.trim().toUpperCase());
        System.out.println("toLowerCase(): " + str.trim().toLowerCase());
        System.out.println("charAt(2):     " + str.trim().charAt(2));
        System.out.println("indexOf('Java'):" + str.indexOf("Java"));
        System.out.println("contains('Java'):" + str.contains("Java"));
        System.out.println("startsWith('  P'):" + str.startsWith("  P"));
        System.out.println("endsWith('a  '):" + str.endsWith("a  "));
        System.out.println("substring(2,13):" + str.substring(2, 13));
        System.out.println("replace:       " + str.trim().replace("Java", "Python"));
        System.out.println("isEmpty():     " + str.isEmpty());
        System.out.println("isEmpty(''):   " + "".isEmpty());

        // split and join
        String csv = "Rahul,BCA,Mumbai,8.5";
        String[] parts = csv.split(",");
        System.out.println("\nCSV split: " + csv);
        for (int i = 0; i < parts.length; i++)
            System.out.println("  Field " + i + ": " + parts[i]);
        System.out.println("join:      " + String.join(" | ", parts));

        // compareTo
        System.out.println("\ncompareTo('Apple','Banana'): " + "Apple".compareTo("Banana"));
        System.out.println("compareTo('Cat','Cat'):     " + "Cat".compareTo("Cat"));
        System.out.println("equalsIgnoreCase:           " + "java".equalsIgnoreCase("JAVA"));

        // valueOf and format
        System.out.println("\nvalueOf(42):  " + String.valueOf(42));
        System.out.println("format:       " + String.format("₹%,.2f", 1500.5));

        // ═══════════════════════════════════════
        // PART 3: StringBuilder Operations
        // ═══════════════════════════════════════
        System.out.println("\n══ PART 3: StringBuilder ══");
        StringBuilder sb = new StringBuilder("Hello");

        System.out.println("Initial:    " + sb);
        System.out.println("capacity(): " + sb.capacity());
        System.out.println("length():   " + sb.length());

        sb.append(" World");
        System.out.println("append:     " + sb);

        sb.insert(5, ",");
        System.out.println("insert:     " + sb);

        sb.replace(7, 12, "India");
        System.out.println("replace:    " + sb);

        sb.delete(5, 6);
        System.out.println("delete:     " + sb);

        sb.reverse();
        System.out.println("reverse:    " + sb);

        sb.reverse();  // Reverse back
        sb.setCharAt(0, 'h');
        System.out.println("setCharAt:  " + sb);

        System.out.println("toString(): " + sb.toString());

        // ═══════════════════════════════════════
        // PART 4: Immutability vs Mutability Proof
        // ═══════════════════════════════════════
        System.out.println("\n══ PART 4: Mutability Comparison ══");

        // String — immutable
        String original = "Hello";
        String modified = original.concat(" World");
        System.out.println("String original after concat: " + original);  // Still "Hello"
        System.out.println("String modified:              " + modified); // "Hello World"

        // StringBuilder — mutable
        StringBuilder sbOrig = new StringBuilder("Hello");
        sbOrig.append(" World");
        System.out.println("StringBuilder after append:    " + sbOrig);   // "Hello World" — changed!

        // ═══════════════════════════════════════
        // PART 5: Performance Comparison
        // ═══════════════════════════════════════
        System.out.println("\n══ PART 5: Performance Test ══");
        int iterations = 50000;

        // String concatenation
        long start = System.currentTimeMillis();
        String strConcat = "";
        for (int i = 0; i < iterations; i++) {
            strConcat = strConcat + "a";
        }
        long stringTime = System.currentTimeMillis() - start;

        // StringBuilder
        start = System.currentTimeMillis();
        StringBuilder sbConcat = new StringBuilder();
        for (int i = 0; i < iterations; i++) {
            sbConcat.append("a");
        }
        String sbResult = sbConcat.toString();
        long sbTime = System.currentTimeMillis() - start;

        System.out.println("String concat (" + iterations + " iterations): " + stringTime + " ms");
        System.out.println("StringBuilder (" + iterations + " iterations): " + sbTime + " ms");
        System.out.println("StringBuilder is ~" + (stringTime / Math.max(sbTime, 1)) + "x faster!");

        System.out.println("\n✅ Lab 6 Complete!");
    }
}

Industry Spotlight — A Day in the Life

Earn With It — Freelance & Income Roadmap

⏱️ Time to First Earning: 2–4 weeks (build 2 text processing tools, create a Fiverr gig, share on LinkedIn)

Chapter Summary & Code Tweet

🐦 Code Tweet — The Entire Chapter in One Snippet

Java
// Unit 7 in 7 lines 🚀
String s = "hello";                      // Pool ✓
boolean b = s.equals(new String("hello")); // true (use this, not ==)
String[] parts = "a@b".split("@");      // ["a","b"]
String up = s.toUpperCase();               // "HELLO" (new String!)
StringBuilder sb = new StringBuilder(s);  // Mutable 🔥
sb.append(" world").reverse();            // "dlrow olleh"
System.out.printf("₹%,.2f%n", 1500.5);  // ₹1,500.50

Earning Checkpoint — What You Can Do Now

✅ Unit 7 complete. MCQs: 30. Lab 6 covered. Ready for Unit 8!

[QR: Link to EduArtha video tutorial — Java Strings & StringBuilder]