Java基础面试专栏（五）：String、StringBuffer、StringBuilder区别，面试必背核心考点

PeterMap
3 阅读10分钟

承接前四篇专栏，我们先后拆解了Java数据类型、抽象类与接口、final关键字、static关键字的核心考点，今天继续聚焦Java基础面试的高频重点——String、StringBuffer、StringBuilder的区别。这三个类是Java中处理字符串的核心工具，日常开发和面试中都会高频接触，很多面试者能说出“String不可变，后两者可变”，但讲不清底层原理、线程安全的本质的区别，也分不清不同场景下该如何选择，今天我们就从面试答题角度，把三者的区别、底层逻辑、用法和易错点拆透，帮你快速掌握答题思路，轻松应对追问。

先给大家一个面试万能总结（一句话直达核心，适合开场快速应答）：String不可变，每次修改都会生成新对象；StringBuffer和StringBuilder均为可变字符串，可直接修改原对象；其中StringBuffer通过synchronized修饰保证线程安全，性能较低，StringBuilder无同步开销，效率更高；实际开发中，单线程高频字符串操作选StringBuilder，多线程环境选StringBuffer，少量字符串操作或常量定义选String。

一、核心对比：一张表分清三者核心差异（面试直接套用）

面试中，当被问到三者区别时，先给出核心对比表，再逐一拆解，会显得答题有条理、思路清晰。以下是三者核心特性对比，覆盖面试所有高频考点，建议牢记：

核心特性StringStringBufferStringBuilder
可变性不可变（Immutable）可变（Mutable）可变（Mutable）
线程安全天然线程安全（不可变特性决定）线程安全（方法用synchronized修饰）非线程安全（无同步修饰）
性能低（频繁修改产生大量垃圾对象）中（同步锁带来性能开销）高（无同步开销，效率最高）
内存效率低（频繁操作易产生内存碎片）较高（动态扩容，减少对象创建）最高（与StringBuffer结构一致，无锁开销）
适用场景字符串常量、少量拼接、无需修改的场景多线程环境（如并发日志、多线程字符串拼接）单线程环境、高频字符串修改（如循环拼接、SQL构建）

二、逐一拆解：三者底层原理+原创代码示例

掌握对比表后，面试中还会追问三者的底层实现和具体用法，我们结合原创代码示例，逐一拆解每个类的核心特点、底层逻辑和使用场景，帮你吃透本质，避免死记硬背。

1. String：不可变字符串，常量级安全

String类的核心特性是“不可变”，所谓不可变，是指字符串对象一旦创建，其内部的字符内容就无法修改。底层是通过final修饰的char数组（JDK9及以上改为byte数组，优化内存）存储字符，且没有提供修改数组内容的方法，任何看似“修改”的操作（如拼接、截取），本质都是创建一个新的String对象，原对象内容保持不变。

正因为不可变，String对象天然具备线程安全——多个线程同时访问一个String对象，不会出现内容被篡改的情况，因为根本无法修改。

代码示例（结合开发中“常量定义+少量拼接”场景）：

public class StringTest {
    public static void main(String[] args) {
        // 字符串常量，存储在方法区的常量池（复用已有对象）
        String str1 = "Java面试";
        String str2 = "Java面试";
        
        // 看似修改，实则创建新对象
        String str3 = str1.concat("专栏"); // 拼接操作，生成新对象
        String str4 = str1 + "干货"; // 拼接操作，生成新对象
        
        // 验证原对象未被修改
        System.out.println("str1原始值：" + str1); // 输出：Java面试
        System.out.println("str3新对象：" + str3); // 输出：Java面试专栏
        System.out.println("str4新对象：" + str4); // 输出：Java面试干货
        
        // 验证常量池复用（str1和str2指向同一个对象）
        System.out.println("str1 == str2：" + (str1 == str2)); // 输出：true
        // 新创建的对象与原对象地址不同
        System.out.println("str1 == str3：" + (str1 == str3)); // 输出：false
        
        // 少量拼接，JVM会优化为StringBuilder，性能影响可忽略
        String smallJoin = "姓名：" + "张三" + "，年龄：" + 22;
        System.out.println("少量拼接结果：" + smallJoin);
    }
}

面试重点：String不可变的底层原因——底层存储字符的数组被final修饰，且类没有提供修改数组内容的方法；频繁修改String会产生大量垃圾对象，导致内存开销增大、性能下降，因此不适合高频修改场景。

2. StringBuffer：可变字符串，线程安全的选择

StringBuffer是为了解决String频繁修改效率低的问题而设计的，核心特性是“可变”和“线程安全”。其底层也是通过char数组存储字符，但数组没有被final修饰，支持动态扩容（默认初始容量16，满了之后自动扩容为原来的2倍+2），所有修改操作（如拼接、插入、删除）都是直接操作底层数组，不会创建新对象。

线程安全的实现：StringBuffer的所有公开方法（如append、insert）都被synchronized修饰，保证同一时刻只有一个线程能执行该方法，避免多线程并发修改导致的内容错乱，但同步锁会带来额外的性能开销，因此性能低于StringBuilder。

代码示例（结合开发中“多线程日志拼接”场景）：

import java.util.concurrent.CountDownLatch;

// 多线程环境下使用StringBuffer拼接日志
public class StringBufferTest {
    // 线程安全的StringBuffer
    private static final StringBuffer logBuffer = new StringBuffer();
    // 用于等待所有线程执行完成
    private static final CountDownLatch latch = new CountDownLatch(3);

    public static void main(String[] args) throws InterruptedException {
        // 启动3个线程，并发拼接日志
        new Thread(new LogTask("线程1", "用户登录成功"), "线程1").start();
        new Thread(new LogTask("线程2", "数据查询完成"), "线程2").start();
        new Thread(new LogTask("线程3", "文件上传成功"), "线程3").start();

        // 等待所有线程执行完毕
        latch.await();
        // 输出最终日志
        System.out.println("最终日志：" + logBuffer.toString());
    }

    // 日志拼接任务
    static class LogTask implements Runnable {
        private String threadName;
        private String logContent;

        public LogTask(String threadName, String logContent) {
            this.threadName = threadName;
            this.logContent = logContent;
        }

        @Override
        public void run() {
            try {
                // 拼接日志（synchronized修饰的方法，线程安全）
                logBuffer.append("[").append(threadName).append("] ")
                        .append(logContent).append("\n");
            } finally {
                latch.countDown();
            }
        }
    }
}

运行结果（日志内容无错乱，线程安全）：

[线程1] 用户登录成功

[线程2] 数据查询完成

[线程3] 文件上传成功

面试重点：StringBuffer线程安全的底层原因——所有修改方法都被synchronized修饰；动态扩容机制减少对象创建，内存效率高于String；适合多线程并发修改字符串的场景，如日志收集、多线程数据拼接。

3. StringBuilder：可变字符串，单线程高效之选

StringBuilder与StringBuffer几乎完全一致，底层同样是可动态扩容的char数组，支持直接修改原对象，无需创建新对象，核心区别在于：StringBuilder的方法没有被synchronized修饰，不保证线程安全，但也因此消除了同步锁的性能开销，效率比StringBuffer高很多。

正因为效率高，StringBuilder是单线程环境下高频字符串修改的首选，日常开发中，大部分字符串操作都是单线程场景（如循环拼接SQL、构建JSON字符串、拼接用户信息等），此时优先使用StringBuilder。

代码示例（结合开发中“单线程循环拼接SQL”场景）：

// 单线程环境下，使用StringBuilder拼接SQL语句
public class StringBuilderTest {
    public static void main(String[] args) {
        // 模拟批量插入数据，循环拼接SQL
        StringBuilder sqlBuilder = new StringBuilder();
        // 拼接SQL前缀
        sqlBuilder.append("INSERT INTO user (username, age) VALUES ");
        
        // 循环拼接多条数据（高频修改场景）
        for (int i = 1; i <= 5; i++) {
            sqlBuilder.append("('user").append(i).append("', ").append(20 + i).append(")");
            // 非最后一条数据，拼接逗号
            if (i != 5) {
                sqlBuilder.append(", ");
            }
        }
        // 拼接SQL后缀
        sqlBuilder.append(";");
        
        // 输出最终SQL
        String finalSql = sqlBuilder.toString();
        System.out.println("拼接后的SQL：" + finalSql);
    }
}

运行结果（高效拼接，无额外对象创建）：

拼接后的SQL：INSERT INTO user (username, age) VALUES ('user1', 21), ('user2', 22), ('user3', 23), ('user4', 24), ('user5', 25);

面试重点：StringBuilder与StringBuffer的核心区别——是否有synchronized修饰（线程安全 vs 高效）；两者底层结构、扩容机制完全一致；单线程场景优先选StringBuilder，性能更优。

三、面试核心追问：底层扩容机制（加分项）

面试中，除了三者的基础区别，面试官还常追问“StringBuffer和StringBuilder的扩容机制”，掌握这个知识点，能让你的答题更有深度，轻松加分。

核心扩容逻辑（StringBuffer和StringBuilder一致）：

  1. 默认初始容量：16个字符（底层char数组初始长度为16）；

  2. 扩容时机：当拼接的字符长度超过当前数组容量时，触发扩容；

  3. 扩容规则：新容量 = 原容量 × 2 + 2（例如：16→34→70→142...）；

  4. 优化建议：如果能提前预估字符串最终长度，可在创建StringBuffer/StringBuilder时指定初始容量（如new StringBuilder(100)），避免多次扩容，进一步提升性能。

代码示例（验证扩容机制）：

public class ExpandTest {
    public static void main(String[] args) {
        // 指定初始容量为5，减少扩容次数
        StringBuilder sb = new StringBuilder(5);
        System.out.println("初始容量：" + getCapacity(sb)); // 输出：5
        
        // 拼接字符，触发扩容
        sb.append("123456"); // 超过初始容量5，触发扩容
        System.out.println("扩容后容量：" + getCapacity(sb)); // 输出：12（5×2+2）
        
        // 继续拼接，再次触发扩容
        sb.append("78901234567"); // 超过12，扩容为12×2+2=26
        System.out.println("再次扩容后容量：" + getCapacity(sb)); // 输出：26
    }

    // 反射获取StringBuilder底层数组容量（面试无需写，理解原理即可）
    private static int getCapacity(StringBuilder sb) {
        try {
            java.lang.reflect.Field field = StringBuilder.class.getDeclaredField("value");
            field.setAccessible(true);
            char[] value = (char[]) field.get(sb);
            return value.length;
        } catch (Exception e) {
            e.printStackTrace();
            return -1;
        }
    }
}

四、高频易错点大汇总（必记，避开面试陷阱）

这三个类的面试易错点，主要集中在“不可变的理解”“线程安全的误区”和“场景选择”，记住以下5点，轻松避开所有陷阱：

  1. 易错点1：误以为String的“+”拼接性能高——少量拼接（如常量拼接）JVM会优化为StringBuilder，但若在循环中使用“+”拼接String，会创建大量临时对象，性能极低，此时必须用StringBuilder/StringBuffer。

  2. 易错点2：混淆String的不可变性——String的不可变是“内容不可变”，而非“引用不可变”；引用变量可以指向新的String对象，但原对象的内容始终不变。

  3. 易错点3：认为StringBuffer一定比StringBuilder好——并非如此，单线程场景下，StringBuilder效率更高，只有多线程场景才需要用StringBuffer，否则会浪费同步锁的性能开销。

  4. 易错点4：忽略初始容量的优化——创建StringBuffer/StringBuilder时，若能预估长度，指定初始容量，可避免多次扩容，提升性能（高频面试加分点）。

  5. 易错点5：String的intern()方法误区——String的intern()方法会将字符串存入常量池，实现对象复用，但频繁使用会增加常量池负担，并非所有场景都适合。

五、面试总结与延伸

  1. 答题逻辑：先一句话总结三者核心区别，再给出对比表，接着逐一拆解每个类的底层原理、原创代码示例和适用场景，最后补充扩容机制和易错点，答题全面且有条理，符合面试答题习惯。

  2. 高频面试题（提前准备，直接应答）：

① String、StringBuffer、StringBuilder的区别？（核心考点，按本文对比表+底层原理应答）

② String为什么不可变？（底层final修饰的字符数组，无修改方法）

③ StringBuffer和StringBuilder的扩容机制是什么？（默认容量16，扩容规则2倍+2）

④ 循环中拼接字符串，用哪个类？为什么？（单线程用StringBuilder，多线程用StringBuffer，避免String创建大量临时对象）

avatar
文章
阅读
粉丝