String源码解读

最新推荐文章于 2024-04-26 09:59:38 发布

小C卷Java

最新推荐文章于 2024-04-26 09:59:38 发布

阅读量141

点赞数

分类专栏： Java源码学习文章标签：性能优化 java 算法 c++ spring 链表

本文链接：https://blog.csdn.net/m0_51808048/article/details/132463260

版权

Java源码学习专栏收录该内容

6 篇文章 0 订阅

订阅专栏

在Java8及之前，String、StringBuilder、StringBuffer的实现为char数组。
在Java9之后，String、StringBuilder、StringBuffer的实现改为byte数组。

1、Java9之后为什么要把char[]替换为byte[]呢？

新版的 String 其实支持两个编码方案：Latin-1 和 UTF-16。如果字符串中包含的汉字没有超过 Latin-1 可表示范围内的字符，那就会使用 Latin-1 作为编码方案。Latin-1 编码方案下，byte 占一个字节(8 位)，char 占用 2 个字节（16），byte 相较 char 节省一半的内存空间。
JDK 官方就说了绝大部分字符串对象只包含 Latin-1 可表示的字符。
而当字符串中的汉字超过Latin-1可表示的范围时，byte和char占用的空间相同。

2、String为什么是不可变的？

首先我们来看String类的源码

public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
    private final char value[];
	//...
}

1.保存字符串的数组被final修饰且为private，且String类并没有提供/暴露修改这个字符串的方法。
2.String类被final修饰，避免了子类继承来破坏。

3、字符串拼接用“+”还是StringBuilder呢？

Java8之前：
通过“+”的方式拼接字符串其实是通过StringBuilder调用append()方法来完成的，拼接完之后再调用toString()方法得到String对象。

不过这就会导致一个问题，当在一个循环内使用“+”拼接字符串的话就会重复的创建StringBuilder对象，如果直接使用StringBuilder来拼接字符串就不会出现这种问题。
Java9之后：
JDK9的JEP 280提出了优化，字符串“+”拼接改为了makeConcatWithConstants()来实现，而不是使用大量的StringBuilder。

4、String的equals()和Object的equals()有何区别？

String类通过重写equals方法来实现比较String字符串的值是否相等。
Object类的equals方法是比较对象的内存地址。

5、字符串常量池

字符串常量池 是 JVM 为了提升性能和减少内存消耗针对字符串（String 类）专门开辟的一块区域，主要目的是为了避免字符串的重复创建。

String s1 = new String(“abc”);这句话创建了几个字符串对象？

会创建1或2个字符串对象。
1、如果字符串常量池中不存在字符串对象“abc”的引用，那么它将首先在字符串常量池中创建，然后再堆中空间中创建，因此将创建总共2个字符串对象。
2、如果字符串常量池中已存在字符串对象“abc”的引用，则只会在堆中创建1个字符串对象"abc"

6、String的intern方法有什么作用？

String.intern()是一个native(本地)方法，其作用是将指定的字符串对象的引用保存在字符串常量池中：

如果字符串常量池中保存了对应的字符串对象的引用，直接返回该引用。
如果字符串常量池中没有保存了对应的字符串对象的引用，那就在常量池中创建一个指向该字符串对象的引用并返回。

// 在堆中创建字符串对象”Java“
// 将字符串对象”Java“的引用保存在字符串常量池中
String s1 = "Java";
// 直接返回字符串常量池中字符串对象”Java“对应的引用
String s2 = s1.intern();
// 会在堆中在单独创建一个字符串对象
String s3 = new String("Java");
// 直接返回字符串常量池中字符串对象”Java“对应的引用
String s4 = s3.intern();
// s1 和 s2 指向的是堆中的同一个对象
System.out.println(s1 == s2); // true
// s3 和 s4 指向的是堆中不同的对象
System.out.println(s3 == s4); // false
// s1 和 s4 指向的是堆中的同一个对象
System.out.println(s1 == s4); //true

7、String类型的变量和常量做"+"运算时发生了什么？

字符串不加final关键字的情况(JDK1.8)：

String str1 = "str";
String str2 = "ing";
String str3 = "str" + "ing";
String str4 = str1 + str2;
String str5 = "string";
System.out.println(str3 == str4);//false
System.out.println(str3 == str5);//true
System.out.println(str4 == str5);//false

在编译过程中，Javac 编译器（下文中统称为编译器）会进行一个叫做 常量折叠(Constant Folding) 的代码优化。
常量折叠会把常量表达式的值求出来作为常量嵌在最终生成的代码中，这是 Javac 编译器会对源代码做的极少量优化措施之一(代码优化几乎都在即时编译器中进行)。
对于 String str3 = “str” + “ing”; 编译器会给你优化成 String str3 = “string”; 。
并不是所有的常量都会进行折叠，只有编译器在程序编译期就可以确定值的常量才可以：

基本数据类型( byte、boolean、short、char、int、float、long、double)以及字符串常量。
final 修饰的基本数据类型和字符串变量
字符串通过 “+”拼接得到的字符串、基本数据类型之间算数运算（加减乘除）、基本数据类型的位运算（<<、>>、>>> ）

引用的值在程序编译期是无法确定的，编译器无法对其进行优化。
对象引用和“+”的字符串拼接方式，实际上是通过 StringBuilder 调用 append() 方法实现的，拼接完成之后调用 toString() 得到一个 String 对象。
String str4 = new StringBuilder().append(str1).append(str2).toString();
所以我们平时写代码尽量避免多个字符串对象的拼接，这样会重新创建新的对象。如果需要改变字符串，使用StringBuilder或StringBuffer。

final String str1 = "str";
final String str2 = "ing";
// 下面两个表达式其实是等价的
String c = "str" + "ing";// 常量池中的对象
String d = str1 + str2; // 常量池中的对象
System.out.println(c == d);// true

被 final 关键字修饰之后的 String 会被编译器当做常量来处理，编译器在程序编译期就可以确定它的值，其效果就相当于访问常量。
如果，编译器在运行时才能知道其确切值的话，就无法对其优化。

final String str1 = "str";
final String str2 = getStr();
String c = "str" + "ing";// 常量池中的对象
String d = str1 + str2; // 在堆上创建的新的对象
System.out.println(c == d);// false
public static String getStr() {
      return "ing";
}