Java 实例 – 连接字符串（长文讲解）

Java 实例 – 连接字符串：从基础到实战的完整指南

在 Java 编程中，字符串操作是开发者每天都要面对的基础任务之一。无论是拼接用户信息、构建日志消息，还是生成动态 SQL 语句，字符串连接无处不在。尤其在处理用户输入、文件路径、API 参数等场景时，掌握高效的字符串连接方式至关重要。今天我们就来深入探讨 Java 实例 – 连接字符串 的多种实现方式，从最简单的 + 操作到高性能的 StringBuilder，帮助你写出更优雅、更高效的代码。

字符串连接的入门：使用 + 操作符

在 Java 中，最直观的字符串连接方式就是使用 + 操作符。它语法简单，非常适合初学者快速上手。

public class StringConcatenationExample {
    public static void main(String[] args) {
        // 定义几个基础变量
        String firstName = "张";
        String lastName = "三";
        int age = 25;
        String city = "北京";

        // 使用 + 操作符连接字符串
        String message = firstName + " " + lastName + "，今年 " + age + " 岁，来自 " + city;

        // 输出结果
        System.out.println(message);
        // 输出：张 三，今年 25 岁，来自 北京
    }
}

注释说明：

• + 操作符在编译时会被 Java 编译器优化为 StringBuilder 的 append() 方法调用。
• 即使是简单拼接，Java 也会自动处理类型转换，例如 int age 会被自动转为字符串。
• 这种方式适合少量字符串拼接，但不推荐在循环中使用，因为每次拼接都会创建新对象，带来性能开销。

为什么 + 拼接在循环中效率低？

想象一下你正在写一个程序，需要将 1000 个名字拼接成一个长字符串。如果用 + 操作符，会发生什么？

public class InefficientConcatenation {
    public static void main(String[] args) {
        String result = "";

        // 在循环中使用 + 拼接
        for (int i = 0; i < 1000; i++) {
            result = result + "名字" + i + " ";
        }

        System.out.println("拼接完成，长度：" + result.length());
    }
}

注释说明：

• 每次循环中，result = result + "名字" + i + " " 都会创建一个新的 String 对象。
• 原来的 result 对象变成垃圾，等待 JVM 回收。
• 1000 次循环意味着创建了 1000 个临时字符串对象，内存占用高，性能差。
• 这就像你每次搬东西都要重新买个新袋子，效率极低。

推荐方案：使用 StringBuilder 提升性能

为了解决上述性能问题，Java 提供了 StringBuilder 类，它是可变的字符串容器，支持高效的字符串拼接操作。

public class EfficientStringBuilder {
    public static void main(String[] args) {
        // 创建一个 StringBuilder 对象，初始容量可选
        StringBuilder sb = new StringBuilder();

        // 循环拼接，不会创建新对象
        for (int i = 0; i < 1000; i++) {
            sb.append("名字").append(i).append(" ");
        }

        // 最后一次性转为字符串
        String result = sb.toString();

        System.out.println("拼接完成，长度：" + result.length());
    }
}

注释说明：

• StringBuilder 是可变对象，内部维护一个字符数组，支持 append() 方法动态添加内容。
• append() 方法不会创建新对象，而是直接在原数组上修改，极大提升性能。
• toString() 是最后一步，将 StringBuilder 转为不可变 String。
• 适用于大量字符串拼接，特别是循环或频繁操作的场景。

StringBuffer 与 StringBuilder 的区别

StringBuffer 和 StringBuilder 非常相似，但有一个关键区别：线程安全。

public class StringBufferExample {
    public static void main(String[] args) {
        // StringBuffer 是线程安全的，适合多线程环境
        StringBuffer sbf = new StringBuffer();
        sbf.append("线程安全的拼接 ");
        sbf.append("示例 ");
        sbf.append("Java 8");

        System.out.println(sbf.toString());
        // 输出：线程安全的拼接 示例 Java 8
    }
}

注释说明：

• StringBuffer 的所有方法都加了 synchronized 关键字，保证多线程环境下不会出错。
• 但这也带来了额外的性能开销。
• 如果你确定代码不会在多线程中使用，优先选择 StringBuilder，性能更好。

实际案例：构建动态 SQL 查询

在开发数据库应用时，我们经常需要拼接 SQL 语句。下面是一个典型的 Java 实例 – 连接字符串 应用场景。

public class DynamicSQLBuilder {
    public static void main(String[] args) {
        // 用户输入参数
        String tableName = "users";
        String conditionColumn = "age";
        int conditionValue = 18;
        String orderBy = "created_time DESC";

        // 使用 StringBuilder 构建 SQL
        StringBuilder sql = new StringBuilder();

        // 拼接 SELECT 语句
        sql.append("SELECT * FROM ").append(tableName)
           .append(" WHERE ").append(conditionColumn)
           .append(" >= ").append(conditionValue)
           .append(" ORDER BY ").append(orderBy);

        // 输出最终 SQL
        System.out.println("生成的 SQL：");
        System.out.println(sql.toString());
        // 输出：SELECT * FROM users WHERE age >= 18 ORDER BY created_time DESC
    }
}

注释说明：

• StringBuilder 用于构建动态 SQL，避免硬编码，提高灵活性。
• 通过变量控制条件，可轻松支持用户自定义查询。
• 在实际项目中，建议结合 PreparedStatement 使用，防止 SQL 注入。

更现代的方式：使用 String.join() 和 String.format()

Java 8 引入了更简洁的字符串拼接方式，让代码更易读。

使用 String.join() 拼接集合

import java.util.Arrays;
import java.util.List;

public class StringJoinExample {
    public static void main(String[] args) {
        // 定义一个字符串列表
        List<String> colors = Arrays.asList("红色", "绿色", "蓝色");

        // 使用 join 方法拼接，用逗号分隔
        String result = String.join(", ", colors);

        System.out.println("颜色列表：" + result);
        // 输出：颜色列表：红色, 绿色, 蓝色
    }
}

注释说明：

• String.join(delimiter, elements) 是 Java 8 新增方法，用于连接集合中的元素。
• 适用于拼接多个字符串，尤其是来自 List、数组等容器的数据。
• 语法简洁，可读性强，适合处理数据列表。

使用 String.format() 格式化字符串

public class StringFormatExample {
    public static void main(String[] args) {
        String name = "李四";
        int score = 95;
        double percentage = 95.0;

        // 使用 format 方法进行格式化
        String message = String.format("用户 %s 的考试成绩是 %d 分，占比 %.1f%%", name, score, percentage);

        System.out.println(message);
        // 输出：用户 李四 的考试成绩是 95 分，占比 95.0%
    }
}

注释说明：

• %s 表示字符串，%d 表示整数，%.1f 表示保留一位小数的浮点数。
• String.format() 类似于 C 语言的 printf，适合复杂格式化需求。
• 代码清晰，易于维护，适合日志、提示信息等场景。

总结：如何选择合适的连接方式？

在实际开发中，我们应根据使用场景选择最合适的字符串连接方式：

• 少量拼接：使用 + 操作符，代码简洁，适合简单场景。
• 循环或大量拼接：使用 StringBuilder，性能最优，推荐首选。
• 多线程环境：使用 StringBuffer，保证线程安全。
• 拼接集合元素：使用 String.join()，语法优雅。
• 复杂格式化：使用 String.format()，可读性强。

通过掌握这些技巧，你不仅能写出更高效的代码，还能提升程序的整体性能和可维护性。记住：在 Java 实例 – 连接字符串 的实践中，选择合适的方法，比盲目使用 + 更重要。

下次写代码时，不妨先问问自己：我需要拼接多少字符串？是否在循环中？是否多线程？答案会告诉你该用哪种方式。