Java Text Blocks Explained — Cleaner Multi-line Strings in Java 15

public class OldStyleStrings {

    public static void main(String[] args) {

        // The OLD way: a JSON object embedded as a traditional string.
        // Notice how unreadable this is — escaped quotes everywhere,
        // plus-signs to join lines, and \n to fake line breaks.
        String customerJson = "{\n" +
                "  \"name\": \"Alice\",\n" +
                "  \"age\": 30,\n" +
                "  \"city\": \"Dublin\"\n" +
                "}";

        // The same SQL query written the old way.
        // Good luck spotting a typo in here during a code review.
        String findActiveUsers =
                "SELECT user_id, email, created_at " +
                "FROM users " +
                "WHERE status = 'active' " +
                "AND created_at > '2024-01-01' " +
                "ORDER BY created_at DESC;";

        System.out.println("--- JSON Output ---");
        System.out.println(customerJson);

        System.out.println("\n--- SQL Output ---");
        System.out.println(findActiveUsers);
    }
}

public class TextBlockBasics {

    public static void main(String[] args) {

        // TEXT BLOCK SYNTAX:
        // 1. Opening delimiter: three double-quotes then IMMEDIATELY a newline.
        // 2. Your content, written exactly as you want it to look.
        // 3. Closing delimiter: three double-quotes.

        // Example 1: A JSON object — looks like real JSON, not a string puzzle.
        String productJson = """
                {
                  "productId": "SKU-9921",
                  "name": "Mechanical Keyboard",
                  "price": 129.99,
                  "inStock": true
                }
                """;

        // Example 2: An HTML snippet — notice, no escaped quotes needed for
        // the href attribute value. Text blocks handle double quotes natively.
        String welcomeHtml = """
                <div class="welcome-banner">
                    <h1>Welcome back!</h1>
                    <p>Your session started at 09:00 AM.</p>
                </div>
                """;

        // Example 3: A multi-line SQL query — readable like actual SQL.
        String topSellerQuery = """
                SELECT p.name, SUM(o.quantity) AS total_sold
                FROM products p
                JOIN order_items o ON p.id = o.product_id
                WHERE p.category = 'electronics'
                GROUP BY p.name
                ORDER BY total_sold DESC
                LIMIT 10;
                """;

        System.out.println("=== JSON ===");
        System.out.println(productJson);

        System.out.println("=== HTML ===");
        System.out.println(welcomeHtml);

        System.out.println("=== SQL ===");
        System.out.println(topSellerQuery);
    }
}

public class IndentationStripping {

    public static void main(String[] args) {

        // SCENARIO A: Closing delimiter on its own line, aligned with content.
        // Java measures the shortest leading whitespace across all lines,
        // which here is 16 spaces (the indentation of the content lines).
        // Those 16 spaces are stripped from every line.
        // The internal 2-space indent of "city" is PRESERVED because it's
        // extra indentation BEYOND the common prefix.
        String addressBlock = """
                Street: 42 Elm Road
                  City: Springfield
                Country: Ireland
                """;

        System.out.println("SCENARIO A — standard stripping:");
        System.out.println(addressBlock);
        // Prints with zero leading spaces. The 2 extra spaces before 'City' are kept.

        // SCENARIO B: Closing delimiter moved LEFT to column 0.
        // Now Java's minimum indent is 0, so NOTHING is stripped.
        // This means every content line keeps all its leading whitespace.
        // Usually NOT what you want — shown here for contrast.
        String withLeadingSpaces = """
                Line one has 16 leading spaces
                Line two also has 16 leading spaces
""";
        // Closing """ is at column 0 — all indentation preserved in the string.

        System.out.println("SCENARIO B — closing delimiter at column 0:");
        // Each line now has 16 spaces of padding before its text.
        System.out.println("|" + withLeadingSpaces.lines().findFirst().orElse("") + "|");
        // The pipe characters reveal the leading spaces clearly.

        // SCENARIO C: Using the indent() method to ADD indentation after the fact.
        // indent(4) adds 4 spaces to every line and ensures a trailing newline.
        String codeSnippet = """
                if (loggedIn) {
                    showDashboard();
                }
                """;

        System.out.println("SCENARIO C — adding 4-space indent with indent():");
        System.out.print(codeSnippet.indent(4));
    }
}

public class TextBlockMethods {

    public static void main(String[] args) {

        // --- formatted(): inline variable substitution on a text block ---
        // formatted() is essentially String.format() called on the instance.
        // %s = insert a String, %d = insert an integer, %.2f = insert a float.
        String userName = "Maria";
        int orderCount = 3;
        double totalAmount = 74.50;

        String orderSummaryEmail = """
                Hi %s,

                Thanks for your order! Here's a quick summary:
                  Orders placed : %d
                  Total charged : $%.2f

                We'll email your receipt shortly.
                """.formatted(userName, orderCount, totalAmount);
        // .formatted() is called directly on the text block — clean and readable.

        System.out.println("=== Order Confirmation Email ===");
        System.out.println(orderSummaryEmail);

        // --- stripIndent(): same logic as text blocks, but for runtime strings ---
        // Imagine reading indented text from a file or another source.
        // stripIndent() removes the common leading whitespace.
        String rawTextFromFile =
                "    SELECT id\n" +
                "    FROM sessions\n" +
                "    WHERE active = true;\n";

        String cleanedQuery = rawTextFromFile.stripIndent();
        System.out.println("=== stripIndent() result ===");
        System.out.println(cleanedQuery);

        // --- translateEscapes(): interprets \t, \n etc in a literal string ---
        // Useful when escape sequences arrive as raw text (e.g., from a database
        // or config file) and need to be processed into actual characters.
        String rawEscapes = "Column1\\tColumn2\\tColumn3\\nRow1\\tRow2\\tRow3";
        // Right now \t is literally backslash-t, not a tab character.

        String processedTable = rawEscapes.translateEscapes();
        // After translateEscapes(), \t becomes a real tab, \n a real newline.
        System.out.println("=== translateEscapes() result ===");
        System.out.println(processedTable);

        // --- Text blocks are just String objects — prove it ---
        String textBlockGreeting = """
                Hello, World!
                """;
        String regularGreeting = "Hello, World!\n";

        // equals() compares content — these two strings are identical.
        boolean contentMatches = textBlockGreeting.equals(regularGreeting);
        System.out.println("\nText block equals regular String: " + contentMatches);
    }
}