📝 Strings and Text Processing

Master Java's text manipulation powerhouse through memory diagrams, performance optimizations, and real-world text processing scenarios

🎯 Learning Objectives

By the end of this lesson, you will:

• Master String immutability and memory management with visual diagrams
• Optimize text processing performance using StringBuilder and StringBuffer
• Implement advanced text manipulation techniques for real-world applications
• Apply regular expressions and text parsing for data processing tasks

🏗️ String Architecture Overview

<aside> 📚

String Philosophy

Strings in Java are like books in a library - once published (created), they cannot be modified. Any "changes" create new books (new String objects). StringBuilder is like a draft manuscript where you can edit freely before publishing!

</aside>

String Memory Architecture

Java String Memory Management - The Library System
══════════════════════════════════════════════════════════════════════════════════

          📚 String Pool (Method Area)              🏗️ Heap Memory
    ┌─────────────────────────────────────┐      ┌─────────────────────────────────┐
    │        SHARED LIBRARY               │      │       INDIVIDUAL COPIES        │
    │                                     │      │                                 │
    │  "Hello" ◄─────┬─────┐              │      │  String obj1 = new String(...)│
    │  "World" ◄───┐ │     │              │      │  ┌─────────────────────────────┐│
    │  "Java"  ◄─┐ │ │     │              │      │  │ String Object              ││
    │           │ │ │     │              │      │  │ value: "Hello"             ││
    └───────────┼─┼─┼─────┼──────────────┘      │  │ (references pool if intern)││
                │ │ │     │                     │  └─────────────────────────────┘│
      ┌─────────┘ │ │     │                     └─────────────────────────────────┘
      │     ┌─────┘ │     │
      │     │       │     │
      ▼     ▼       ▼     ▼
    
    Stack Memory (Local Variables)
    ┌─────────────────────────────────────┐
    │ String s1 = "Hello";  ────────────────────► String Pool
    │ String s2 = "Hello";  ────────────────────► Same Reference!
    │ String s3 = new String("Hello"); ──────► Heap Object
    │ String s4 = s3.intern(); ─────────────► Back to Pool!
    └─────────────────────────────────────┘

🔐 String Immutability Mastery

The Immutability Principle Visualization

<aside> 🔒

Immutability Benefits

String immutability enables thread safety, caching optimization, and security - once created, a String cannot be maliciously modified, making it perfect for sensitive data like passwords and URLs.

</aside>

📋 Document Management System Example

public class DocumentManagementSystem {
    
    // 📋 Demonstrating String immutability in document processing
    public void processDocument(String originalContent) {
        System.out.println("📄 Processing document with content: " + originalContent.substring(0, 50) + "...");
        
        // 🔐 Every "modification" creates a new String object
        String step1 = originalContent.toUpperCase();        // New String object
        String step2 = step1.replace("OLD", "NEW");          // Another new String
        String step3 = step2.trim();                         // Yet another new String
        String step4 = step3.concat(" [PROCESSED]");         // And another one!
        
        // 📊 Original string remains unchanged - immutability in action!
        System.out.println("Original: " + originalContent.equals(originalContent)); // Always true
        System.out.println("Final result: " + step4);
        
        // 🔍 Demonstrating object identity vs content equality
        demonstrateStringComparison();
    }
    
    private void demonstrateStringComparison() {
        // 📚 String Pool magic
        String literal1 = "Java Programming";
        String literal2 = "Java Programming";
        String constructed = new String("Java Programming");
        String interned = constructed.intern();
        
        System.out.println("\\n🔍 String Comparison Analysis:");
        
        // Reference equality (same object in memory?)
        System.out.println("literal1 == literal2: " + (literal1 == literal2));         // true
        System.out.println("literal1 == constructed: " + (literal1 == constructed));   // false
        System.out.println("literal1 == interned: " + (literal1 == interned));         // true
        
        // Content equality (same characters?)
        System.out.println("literal1.equals(constructed): " + literal1.equals(constructed)); // true
        System.out.println("literal1.equals(interned): " + literal1.equals(interned));       // true
        
        // 🎯 Practical implications for document versioning
        trackDocumentVersions(literal1, constructed, interned);
    }
    
    private void trackDocumentVersions(String version1, String version2, String version3) {
        System.out.println("\\n📊 Document Version Tracking:");
        
        // Using HashMap to track document versions
        Map<String, String> documentVersions = new HashMap<>();
        
        // Since Strings are immutable and have proper hashCode/equals,
        // they work perfectly as Map keys
        documentVersions.put(version1, "Version from string pool");
        documentVersions.put(version2, "Version from new constructor");
        documentVersions.put(version3, "Version from intern() method");
        
        System.out.println("Map size: " + documentVersions.size()); // Only 1 entry!
        System.out.println("All versions have same content, so Map treats them as same key");
        
        // This demonstrates why String immutability is crucial for data structures
        System.out.println("Retrieved value: " + documentVersions.get("Java Programming"));
    }
    
    // 📊 Performance impact demonstration
    public void demonstratePerformanceImpact() {
        System.out.println("\\n⏱️ String Concatenation Performance Test:");
        
        // ❌ INEFFICIENT: String concatenation in loop
        long startTime = System.nanoTime();
        String result = "";
        for (int i = 0; i < 1000; i++) {
            result += "Line " + i + "\\n";  // Creates 2000+ String objects!
        }
        long inefficientTime = System.nanoTime() - startTime;
        
        // ✅ EFFICIENT: StringBuilder for multiple concatenations
        startTime = System.nanoTime();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 1000; i++) {
            sb.append("Line ").append(i).append("\\n");  // Modifies existing buffer
        }
        String efficientResult = sb.toString();
        long efficientTime = System.nanoTime() - startTime;
        
        System.out.println("Inefficient approach: " + (inefficientTime / 1_000_000) + " ms");
        System.out.println("Efficient approach: " + (efficientTime / 1_000_000) + " ms");
        System.out.println("Performance improvement: " + (inefficientTime / efficientTime) + "x faster");
        
        // Both results are identical, but performance difference is massive
        System.out.println("Results identical: " + result.equals(efficientResult));
    }
}