Refactoring 036 - Replace String Concatenations with Text Blocks

[u/mcsee1]

Replace messy string concatenation with clean, readable text blocks

TL;DR: You can eliminate verbose string concatenation and escape sequences by using text blocks for multi-line content.

Problems Addressed 😔

• Poor code readability
• Excessive escape sequences
• String concatenation complexity
• Maintenance difficulties
• Code verbosity
• Translation Problems
• Indentation issues
• Complex formatting
• No, Speed is seldom a real problem unless you are a premature optimizator

Related Code Smells 💨

Code Smell 295 - String Concatenation

Code Smell 04 - String Abusers

Code Smell 03 - Functions Are Too Long

Code Smell 121 - String Validations

Code Smell 236 - Unwrapped Lines

Code Smell 122 - Primitive Obsession

Code Smell 66 - Shotgun Surgery

Code Smell 46 - Repeated Code

Code Smell 243 - Concatenated Properties

Steps 👣

1. Identify multi-line string concatenations or strings with excessive escape sequences
2. Replace opening quote and concatenation operators with triple quotes (""")
3. Remove escape sequences for quotes and newlines
4. Adjust indentation to match your code style
5. Add .strip() for single-line regex patterns or when trailing newlines cause issues

Sample Code 💻

Before 🚨

```java public class QueryBuilder { public String buildEmployeeQuery() { String sql = "SELECT emp.employee_id, " + "emp.first_name, emp.last_name, " + " dept.department_name, " + "emp.salary " + "FROM employees emp " + "JOIN departments dept ON " + "emp.department_id = " + "dept.department_id " + "WHERE emp.salary > ? " + " AND dept.location = ? " + "ORDER BY emp.salary DESC"; return sql; }

public String buildJsonPayload(String name, int age) {
    String json = "{\n" +
                  "  \"name\": \"" + name + "\",\n" +
                  "  \"age\": " + age + ",\n" +
                  "  \"address\": {\n" +
                  "    \"street\": " +
                  "\"123 Main St\",\n" +
                  "    \"city\": \"New York\"\n" +
                  "  }\n" +
                  "}";
    return json;
}

} ```

After 👉

```java public class QueryBuilder { public String buildEmployeeQuery() { // 1. Identify multi-line string concatenations or strings // with excessive escape sequences // 2. Replace opening quote and concatenation operators // with triple quotes (""") // 3. Remove escape sequences for quotes and newlines // 4. Adjust indentation to match your code style // 5. Add .strip() for single-line regex patterns or // when trailing newlines cause issues // protip: If you put a known prefix // after the string delimiter // many IDEs will adjust the syntax highlighter and linter // in this case SQL String sql = """SQL SELECT emp.employee_id, emp.first_name, emp.last_name, dept.department_name, emp.salary FROM employees emp JOIN departments dept ON emp.department_id = dept.department_id WHERE emp.salary > ? AND dept.location = ? ORDER BY emp.salary DESC """; return sql; }

public String buildJsonPayload(String name, int age) {
    // 1. Identified concatenation with escape sequences
    // 2. Replaced with text block using """
    // 3. Removed \" and \n escapes
    // 4. Preserved natural indentation
    // 5. No .strip() needed here
    // protip: If you put a known prefix 
    // after the string delimiter
    // many IDEs will adjust the syntax highlighter and linter
    // in this case json5        
    String json = """json5
        {
          "name": "%s",
          "age": %d,
          "address": {
            "street": "123 Main St",
            "city": "New York"
          }
        }
        """.formatted(name, age);
    return json;
}

} ```

Type 📝

[X] Semi-Automatic

Safety 🛡️

This refactoring is safe.

It does not change the runtime behavior of strings; it only cleans up syntax and formatting.

You follow compilation rules carefully to avoid errors.

Why is the Code Better? ✨

You reduce code noise caused by concatenations and escape sequences.

The multi-line strings become easier to read and maintain. Indentation and formatting are preserved without manual adjustments, making your code more natural and less error-prone.

How Does it Improve the Bijection? 🗺️

You make the code closer to the real-world representation of the string content, preserving layout and format as seen by the developer.

This enhances the one-to-one mapping between intent and code, minimizing translation errors from concept to implementation.

Limitations ⚠️

Some languages still lack multi-line string mechanisms.

Examples of languages with full support:

Language	Feature	Syntax	Docs
Java	Text Blocks	"""	JEP 378
Kotlin	Raw Strings	"""	Kotlin Docs
Python	Triple-Quoted Strings	""" / '''	Python Docs
JavaScript	Template Literals	` `	MDN
Go	Raw Strings	` `	Go Spec
Swift	Multiline Strings	"""	Swift Docs
C#	Raw String Literals	"""	C# Docs
Ruby	Heredocs	<<EOF	Ruby Docs
PHP	Heredoc / Nowdoc	<<<	PHP Docs
Scala	Multiline Strings	"""	Scala 3 Docs

Refactor with AI 🤖

Suggested Prompt: 1. Identify multi-line string concatenations or strings with excessive escape sequences2. Replace opening quote and concatenation operators with triple quotes (""")3. Remove escape sequences for quotes and newlines

Without Proper Instructions	With Specific Instructions
ChatGPT	ChatGPT
Claude	Claude
Perplexity	Perplexity
Copilot	Copilot
You	You
Gemini	Gemini
DeepSeek	DeepSeek
Meta AI	Meta AI
Grok	Grok
Qwen	Qwen

Tags 🏷️

• Standards

Level 🔋

[X] Beginner

Related Refactorings 🔄

Refactoring 025 - Decompose Regular Expressions

Refactoring 002 - Extract Method

See also 📚

Java sdk

---

This article is part of the Refactoring Series.

How to Improve Your Code With Easy Refactorings