前言

大家好，我是小彭。

过去两年，我们在掘金平台上发布 JetPack 专栏文章，小彭也受到了大家的意见和鼓励。最近，小彭会陆续搬运到公众号上。

在每种编程语言里， 字符串 都是一个躲不开的话题，也是面试常常出现的问题。在这篇文章里，我将总结 Java 字符串中重要的知识点 & 面试题 ，如果能帮上忙，请务必点赞加关注，这真的对我非常重要。

学习路线图：

1. C 和 java 中字符串和 字符数组 的对比

1.1 内存表示不同

• 在 C 语言 中，字符串和字符数组相同。字符串本质上是以 为结束符的字符数组字符数组，因此字符串和字符数组在本质上相同，都是一块连续的内存空间，以需要转义 为结束符。C 语言是不关心 char [] 里存储字符的编码方式的，只有通过程序的上下文确定；
• 在 Java 中，字符串和字符数组不同。字符串是 String 对象，而字符数组是数组对象，均不需要结束符。如果是数组对象，对象内存区域中有一个字段表示数组的长度，而 String 相当于字符数组的包装类。内部包装了一个基于 UTF -16 BE 编码的字符数组（从 Java 9 开始变为字节数组）。其他 字符编码 输入的字节流在进入 String 时都会被转换为 UTF-16 BE 编码。

java.lang .String

 public final class String {

    private final char value[];

    private int hash;

    ...
}
  

1.2 char 类型的数据长度

• 在 C 语言中，char 类型占 1 字节，分为有符号与无符号两种；
• 在 Java 中，char 类型占 2 字节，只有无符号类型。

语言类型存储空间（字节）最小值最大值 Javachar2065535 Cchar（相当于signed char）1-128127 Csigned char1-128127 Cunsigned char10255

2. 为什么 Java 9 String 内部将 char 数组改为 byte 数组？

Java String 的内存表示本质上是基于 UTF-16 BE 编码的字符数组。 UTF-16 是 2 个字节或 4 个字节的变长编码，这意味着即使是 UniCode 字符集的拉丁字母，使用 ASCII 编码只需要一个字节，但是在 String 中需要两个字节的存储空间。

为了优化存储空间，从 Java 9 开始，String 内部将 char 数组改为 byte 数组，String 会判断字符串中是否只包含拉丁字母。如果是的话则采用单字节编码（Latin-1），否则使用 UTF-16 编码。

String.java (since Java 9)

  private  final  byte  coder;
 static  final boolean COMPACT_STRINGS;
static {
    COMPACT_STRINGS = true;
}
byte coder() {
    return COMPACT_STRINGS ? coder : UTF16;
}
@Native static final byte LATIN1 = 0;
@Native static final byte UTF16  = 1;
  

不同 编码 实现的简单区别如下：

编码格式编码单元长度BOM字节序 UTF-8-无BOM1 ~ 4 字节无大端序 UTF-81 ~ 4 字节EF BB BF大端序 UTF-16-无BOM2 / 4 字节无大端序 UTF-16BE（默认）2 / 4 字节FE FF大端序 UTF-16LE2 / 4 字节FF FE小端序 UTF-32-无BOM4 字节无大端序 UTF-32BE（默认）4 字节00 00 FE FF大端序 UTF-32LE4 字节FF EE 00 00小端序

关于字符编码的更多内容，见： 计算机基础：今天一次把 Unicode 和 UTF-8 说清楚

3. String & StringBuilder & StringBuffer 的区别

3.1 效率

String 是不可变的，每次操作都会创建新的变量，而另外两个是可变的，不需要创建新的变量；另外，StringBuffer 的每个操作方法都使用 synchronized 关键字保证线程安全，增加了更多加锁 & 释放锁的时间。因此，操作效率的简单排序为：StringBuilder > StringBuffer > String。

3.2线程安全

String 不可变，所以 String 和 StringBuffer 都是 线程 安全的，而 StringBuilder 是非线程安全的。

类型操作效率线程安全 String低安全（final） StringBuffer中安全（synchronized） StringBuilder高非安全

4. 为什么 String 设计为不可变类？

4.1如何让 String 不可变？

《Effective Java》中 可变性最小化原则 ，阐述了不可变类的规则：

• 1、不对外提供修改对象状态的任何方法；
• 2、保证类不会被扩展（声明为 final 类或 private 构造器）；
• 3、声明所有域为 final；
• 4、声明所有域为 private；
• 5、确保对于任何可变性组件的互斥访问。

以上规则 String 均满足。

4.2 为什么 String 要设计为不可变？

• 1、不可变类 String 可以避免修改后无法定位散列表键值对： 假设 String 是可变类，当我们在 HashMap 中构建起一个以 String 为 Key 的键值对时，此时对 String 进行修改，那么通过修改后的 String 是无法匹配到刚才构建过的键值对的，因为修改后的 hashCode 可能是变化的。而不可变类可以规避这个问题。
• 2、 线程安全 ： 不可变对象本质是线程安全，不需要同步；

提示： 反射可以破坏 String 的不可变性。

5. String + 的实现原理

String + 操作符是编译器语法糖，编译后会被替换为 StringBuilder#append(…) 语句，例如：

示例程序

 // 源码：

String string = null;
for (String str : strings) {
    string += str;
}
return string;

// 编译产物：

String string = null;
for(String str : strings) {
    StringBuilder builder = new StringBuilder();
    builder.append(string);
    builder.append(str);
    string = builder.toString();
}

//  字节码 ：

 0 aconst_null
 1 astore_1
 2 aload_0
 3 astore_2
 4 aload_2
 5 arraylength
 6 istore_3
 7 iconst_0
 8 istore 4
10 iload 4
12 iload_3
13 if_icmpge 48 (+35)
16 aload_2
17 iload 4
19 aaload
20 astore 5
22 new #7 <java/lang/StringBuilder>
25 dup
26 invokespecial #8 <java/lang/StringBuilder.<init>>
29 aload_1
30 invokevirtual #9 <java/lang/StringBuilder.append>
33 aload 5
35 invokevirtual #9 <java/lang/StringBuilder.append>
38 invokevirtual #10 <java/lang/StringBuilder.toString>
41 astore_1
42 iinc 4 by 1
45 goto 10 (-35)
48 aload_1
49 areturn

  

可以看到，如果在循环里直接使用字符串 + ，会生成非常多中间变量，性能非常差。应该在循环外新建一个 StringBuilder ，在循环内统一操作这个对象。

6. String 对象的内存分配

6.1″abc” 与 new String(“abc”) 的区别

• “abc” => 虚拟机首先检查 运行时常量池 中是否存在 “abc”，如果存在则直接返回，否则在 字符串常量 池中创建 “abc” 对象并返回。因此，多次声明使用的是同一个对象；
• new String(“abc”) => 在编译过程中， Javac 会将 “abc” 加入到 Class 文件常量池 中。在类加载时期，Class 文件常量池会被加载进运行时常量池。在调用 new 字节码指令时，虚拟机会在堆中新建一个对象，并且引用常量池中的 “abc” 对象。

6.2String#intern() 的实现原理

如果字符串常量池中已经包含一个等于此 String 对象的字符串，则返回常量池中的这个字符串；否则，先将此 String 对象包含的字符串拷贝到常量池中，在常量池中的这个字符串。

从 JDK 1.7 开始， String#intern() 不再拷贝字符串到常量池中，而是在常量池中生成一个对原 String 对象的引用，并返回。

 // 举例：
String s = new String("1");
s.intern();
String s2 = "1";
System.out.println(s == s2);

String s3 = new String("1") + new String("1");
s3.intern();
String s4 = "11";
System.out.println(s3 == s4);

// 输出结果为：
JDK1.6以及以下：false false
JDK1.7以及以上：false true
  

7. 为什么 String#haseCode() 要使用 31 作为因子？

 public int hashCode() {
    int h = hash;
    if (h == 0 && value.length > 0) {
        char val[] = value;

        for (int i = 0; i < value.length; i++) {
            h = 31 * h + val[i];
        }
        hash = h;
    }
    return h;
}

  

• 原因 1 – 31 可以被编译器优化 31∗i=(i<<5)−i，位运算和减法运算的效率比乘法运算高。
• 原因 2 – 31 是一个质数： 质数是只能被 1 和自身整除的数，使用质数作为乘法因子获得的散列值，在将来进行取模时，得到相同 index 的概率会降低，即降低了哈希冲突的概率。
• 原因 3 – 31 是一个不大不小的质数： 质数太小容易造成散列值聚集在一个小区间，提供散列冲突概率；质数过大容易造成散列值超出 int 的取值范围（上溢），丢失部分数值信息，散列冲突概率不稳定。

我是小彭，带你构建 Android 知识体系。技术和职场问题，请关注公众号 [彭旭锐]私信我提问。