洞察 String字符串

java基础教程栏目介绍洞察 String字符串

推荐（免费）：java基础教程

实现原理

在 Java6 以及之前的版本中，String 对象是对 char 数组进行了封装实现的对象，主要有四个成员变量：char 数组、偏移量 offset、字符数量 count、哈希值 hash。

从 Java7 版本开始到 Java8 版本，String 类中不再有 offset 和 count 两个变量了。这样的好处是 String 对象占用的内存稍微少了些。

从 Java9 版本开始，将 char[]字段改为了 byte[]字段，又维护了一个新的属性 coder，它是一个编码格式的标识。

一个 char 字符占 16 位，2 个字节。这个情况下，存储单字节编码内的字符（占一个字节的字符）就显得非常浪费。JDK1.9 的 String 类为了节约内存空间，于是使用了占 8 位，1 个字节的 byte 数组来存放字符串。

而新属性 coder 的作用是，在计算字符串长度或者使用 indexOf（）函数时，我们需要根据这个字段，判断如何计算字符串长度。coder 属性默认有 0 和 1 两个值，0 代表 Latin-1（单字节编码），1 代表 UTF-16。如果 String 判断字符串只包含了 Latin-1，则 coder 属性值为 0，反之则为 1。

不可变

查看String类的代码可以发现，String类被final关键字修饰，因此这个类不能被继承，并且String类里面的变量char 数组也被 final 修饰了，因此String对象不能被修改。

String对象不可变主要有如下几个优点：

第一，保证 String 对象的安全性。假设 String 对象是可变的，那么 String 对象将可能被恶意修改。

第二，保证 hash 属性值不会频繁变更，确保了唯一性，使得类似 HashMap 容器才能实现相应的 key-value 缓存功能。

第三，可以实现字符串常量池。

在 Java 中，通常有两种创建字符串对象的方式:

第一种是通过字符串常量的方式创建，如String str = "abc"。

第二种是字符串变量通过new 形式的创建，如 String str = new String("abc")。

当代码中使用第一种方式创建字符串对象时，在编译类文件时，”abc”常量字符串将会放入到常量结构中，在类加载时，“abc”将会在常量池中创建；然后，str将引用常量池中的字符串对象。这种方式可以减少同一个值的字符串对象的重复创建，节约内存。

String str = new String("abc") 这种方式，首先在编译类文件时，”abc”常量字符串将会放入到常量结构中，在类加载时，“abc”将会在常量池中创建；其次，在调用new时，JVM 命令将会调用 String 的构造函数，String 对象中的 char 数组将会引用常量池中”abc”字符串的char 数组，在堆内存中创建一个 String 对象；最后，str 将引用 String 对象，String对象的引用跟常量池中”abc”字符串的引用是不一样的。

对象与引用：对象的内容存储在内存中，操作系统通过内存地址来找到存储的内容，引用就是指内存的地址。

比如：String str = new String("abc")，变量str指向的是String对象的存储地址，也就是说 str 并不是对象，而只是一个对象引用。

字符串拼接

常量相加

String str = "ab" + "cd" + "ef";

查看编译后的字节码

0 ldc #2 <abcdef>2 astore_13 return

可以发现编译器将代码优化成如下所示

String str= "abcdef";

变量相加

String a = "ab";String b = "cd";String c = a + b;

查看编译后的字节码

 0 ldc #2 <ab>
 2 astore_1 3 ldc #3 <cd>
 5 astore_2 6 new #4 <java/lang/StringBuilder>
 9 dup10 invokespecial #5 <java/lang/StringBuilder.<init>>13 aload_114 invokevirtual #6 <java/lang/StringBuilder.append>17 aload_218 invokevirtual #6 <java/lang/StringBuilder.append>21 invokevirtual #7 <java/lang/StringBuilder.toString>24 astore_325 return

可以发现，Java在进行字符串相加的时候，底层使用的是StringBuilder，代码被优化成如下所示：

String c = new StringBuilder().append("ab").append("cd").toString();

String.intern

String a = new String("abc").intern();String b = new String("abc").intern();System.out.print(a == b);

输出结果：

true

在字符串常量中，默认会将对象放入常量池。例如：String a = "123"

在字符串变量中，对象是会创建在堆内存中，同时也会在常量池中创建一个字符串对象，String 对象中的 char 数组将会引用常量池中的 char 数组，并返回堆内存对象引用。例如：String b = new String("abc")

如果调用 intern 方法，会去查看字符串常量池中是否有等于该对象的字符串的引用，如果没有，在 JDK1.6 版本中会复制堆中的字符串到常量池中，并返回该字符串引用，堆内存中原有的字符串由于没有引用指向它，将会通过垃圾回收器回收。

在 JDK1.7 版本以后，由于常量池已经合并到了堆中，所以不会再复制具体字符串了，只是会把首次遇到的字符串的引用添加到常量池中；如果有，就返回常量池中的字符串引用。

下面开始分析上面的代码块：

在一开始字符串”abc”会在加载类时，在常量池中创建一个字符串对象。

创建 a 变量时，调用 new Sting() 会在堆内存中创建一个 String 对象，String 对象中的 char 数组将会引用常量池中字符串。在调用 intern 方法之后，会去常量池中查找是否有等于该字符串对象的引用，有就返回常量池中的字符串引用。

创建 b 变量时，调用 new Sting() 会在堆内存中创建一个 String 对象，String 对象中的 char 数组将会引用常量池中字符串。在调用 intern 方法之后，会去常量池中查找是否有等于该字符串对象的引用，有就返回常量池中的字符串引用。

而在堆内存中的两个String对象，由于没有引用指向它，将会被垃圾回收。所以 a 和 b 引用的是同一个对象。

如果在运行时，创建字符串对象，将会直接在堆内存中创建，不会在常量池中创建。所以动态创建的字符串对象，调用 intern 方法，在 JDK1.6 版本中会去常量池中创建运行时常量以及返回字符串引用，在 JDK1.7 版本之后，会将堆中的字符串常量的引用放入到常量池中，当其它堆中的字符串对象通过 intern 方法获取字符串对象引用时，则会去常量池中判断是否有相同值的字符串的引用，此时有，则返回该常量池中字符串引用，跟之前的字符串指向同一地址的字符串对象。

以一张图来总结 String 字符串的创建分配内存地址情况：

使用 intern 方法需要注意的一点是，一定要结合实际场景。因为常量池的实现是类似于一个 HashTable 的实现方式，HashTable 存储的数据越大，遍历的时间复杂度就会增加。如果数据过大，会增加整个字符串常量池的负担。

判断字符串是否相等

// 运行环境 JDK1.8String str1 = "abc";String str2 = new String("abc");String str3= str2.intern();System.out.println(str1==str2); // falseSystem.out.println(str2==str3); // falseSystem.out.println(str1==str3); // true

// 运行环境 JDK1.8String s1 = new String("1") + new String("1");s1.intern();String s2 = "11";System.out.println(s1 == s2); // true , 如果不执行1.intern()，则返回false

String s1 = new String("1") + new String("1")会在堆中组合一个新的字符串对象"11"，在s1.intern()之后，由于常量池中没有该字符串的引用，所以常量池中生成一个堆中字符串"11"的引用，此时String s2 = "11"返回的是堆字符串"11"的引用，所以s1==s2。

在JDK1.7版本以及之后的版本运行以下代码，你会发现结果为true，在JDK1.6版本运行的结果却为false：

String s1 = new String("1") + new String("1");System.out.println( s1.intern()==s1);

StringBuilder与StringBuffer

由于String的值是不可变的，这就导致每次对String的操作都会生成新的String对象，这样不仅效率低下，而且大量浪费有限的内存空间。

和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的对象。

StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。

由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。

Atas ialah kandungan terperinci 洞察 String字符串. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!