当前位置：首页 > news >正文

字符串和常量池的进一步研究

news 来源：原创 2025/5/24 15:01:54

1、字符串常量池

1.1、具体位置

1.2、位置变化

2、字符串分类

2.1. String

2.2. StringBuffer

2.3. StringBuilder

3. final修饰的原因

4. 扩展

4.1、final修饰

4.2、String 拼接性能问题

4.3、字符串常量池

前言

在 Java 中，String、StringBuffer 和 StringBuilder 都是 final 修饰的类，用来出来是处理字符串的核心类。但它们的行为差异（如是否可变）与 final 的作用 完全无关。final 的作用是限制类的继承，而类的可变性是由其内部设计决定的。

如下图所示：

⚠️注意：

String 的不可变性源于其内部 final char[] 且不提供修改方法。而对于可变字符串StringBuffer/StringBuilder 的可源于其内部可变的 char[] 和提供修改方法。

1、字符串常量池

可先了解下jvm的模型，可参考：

1、关于对JVM的知识整理_谈谈你对jvm的理解-CSDN博客

2、JVM如何处理多线程内存抢占问题-CSDN博客

3、谈谈jvm的调优思路-CSDN博客

4、Java对象的内存布局及GC回收年龄的研究-CSDN博客

1.1、具体位置

位于方法区与永久代。

1.方法区（Method Area）：

在 Java 1.7 及之前版本中，方法区的实现是永久代（PermGen），它存储类的元数据（如类定义、静态变量、常量池等）。

字符串常量池：在 Java 6 及之前版本中，字符串常量池也位于永久代中。

2.问题：

永久代大小有限，容易导致 OOM。

Java 7 的变化：

为了减少永久代的负担，字符串常量池被移出永久代，放入堆内存。同时，类的静态变量和运行时常量池也被部分移到堆中。

Java 8 的变化：

永久代被彻底移除，取而代之的是 元空间（Metaspace），它使用本地内存（Native Memory）存储类的元数据（如类结构、方法信息等）。

字符串常量池：在 Java 8 中，字符串常量池仍然位于 堆内存 中，而非元空间。

1.2、位置变化

因此字符串常量池的演变，如下：

为什么字符串常量池要移到堆中？

1、内存管理优化

永久代的限制：
永久代的大小是固定的（通过 -XX:MaxPermSize 设置），无法动态扩展。大量字符串常量可能导致永久代溢出。
堆的灵活性：
堆内存可以通过 -Xmx 和 -Xms 动态调整，且垃圾回收器（如 G1、ZGC）能更高效地管理堆内存。

2、避免内存泄漏

永久代的垃圾回收困难：
永久代的垃圾回收效率低，容易导致内存泄漏（如类加载器未卸载导致的类元数据堆积）。
堆的垃圾回收支持：
字符串常量池位于堆中后，可以被垃圾回收器（如 CMS、G1）回收，避免内存泄漏。

3、提升性能

减少跨区域访问：
将字符串常量池与对象存储在同一堆中，减少跨内存区域（如堆与永久代）的访问开销。

2、字符串分类

分为可变字符串、不可变字符串。

2.1. String

不可变字符串。在jvm内存区域如下图：

1.1、核心特性

不可变性：创建后内容不可修改。
线程安全：由于不可变性，无需同步。
字符串常量池：相同值的字符串共享内存，减少内存开销。

1.2、内部实现

底层结构：String 的底层是一个 private final char[]，且 String 类本身是 final修饰的。

public final class String {private final char[] value;...
}

不可变性原理：
- final 修饰的 char[] 不能被修改（数组引用不可变，数组内容也不能修改）。
- 所有修改操作（如 concat、sunstring、replace）都会返回新 String 对象。

1.3、操作方式

拼接操作：
每次拼接会生成新对象，原始对象未被修改。

String s = "hello";
s = s + " world"; // 创建新 String 对象，原 "hello" 未被修改

1.4、优点

线程安全：不可变对象无需同步。
哈希值缓存：常用于 HashMap 的键。
字符串常量池：节省内存，避免重复创建相同值的字符串。

1.5、缺点

频繁修改导致性能问题：
每次修改生成新对象，频繁拼接会创建大量中间对象，浪费内存和 CPU。

2.2. StringBuffer

可变字符串，线程安全。在jvm内存区域可参考：

2.1、核心特性

可变性：内容可修改。
线程安全：所有方法通过 synchronized 修饰。
适用场景：多线程环境下的字符串操作。

2.2、内部实现

底层结构：
使用 char[] 存储字符，初始容量为 16。通过 append()、insert() 等方法直接修改内部字符数组，不生成新对象。

public final class StringBuffer {private transient char[] value;private int count;@Overridepublic synchronized int length() {return count;}@Overridepublic synchronized int capacity() {return value.length;}...
}

扩容机制：
当字符长度超过当前容量时，自动扩容（通常为当前容量的 2 倍）。

private void expandCapacity(int minimumCapacity) {int newCapacity = value.length * 2 + 2;if (newCapacity < 0) {throw new OutOfMemoryError();}value = Arrays.copyOf(value, newCapacity);
}

2.3、操作方式

拼接操作：
直接修改内部 char[]，无需创建新对象。

StringBuffer sb = new StringBuffer("hello");
sb.append(" world"); // 修改内部 char[]，sb 对象内容被更新

2.4、优点

可变性：避免频繁创建新对象。
线程安全：适合多线程环境。

2.5、缺点

性能较低：同步操作带来额外开销，单线程下效率不如 StringBuilder。

2.3. StringBuilder

可变字符串，非线程安全。

1、核心特性

可变性：内容可修改。
非线程安全：不使用同步，性能更高。
适用场景：单线程环境下的字符串操作。

2、内部实现

底层结构：
与 StringBuffer 类似，使用 char[] 存储字符，但未使用 synchronized。

public final class StringBuilder {private char[] value;private int count;...
}

3、操作方式

拼接操作：
直接修改内部 char[]，无需同步。通过 append()、insert() 等方法直接修改内部字符数组，不生成新对象。

StringBuilder sb = new StringBuilder("hello");
sb.append(" world"); // 修改内部 char[]，sb 对象内容被更新

4、优点

高性能：无同步开销，适合单线程环境。
可变性：避免频繁创建新对象。

5、缺点

线程不安全：多线程下需手动同步。

3. final修饰的原因

为什么 String、StringBuffer 和 StringBuilder 是 final？

1、设计目的

通过禁止继承，确保这些类的实现细节和行为不会被子类修改，从而维护一致性、线程安全性和性能优化。

2、线程安全与性能：

StringBuffer 是线程安全的（方法同步），而 StringBuilder 是非线程安全的（效率更高）。将它们设计为 final 可以避免子类破坏其线程安全或性能特性。

关于更多final的介绍可参考：对于final、finally和finalize不一样的理解-CSDN博客

final 关键字在 Java 中用于限制类、方法和变量的可变性：

final class：该类 不能被继承。
final method：该方法 不能被子类重写。
final variable：该变量 不能被重新赋值。

小结

4. 扩展

4.1、final修饰

误解：final 类的实例一定是不可变的。
事实：final 只限制类的继承，实例的可变性取决于类内部设计。例如：

final class Mutable {private int value;public void setValue(int value) { this.value = value; }
}

上述 Mutable 类是 final 的，但其实例是可变的。
误解：String 是不可变的，所以 final 是原因。
事实：String 的不可变性源于其内部 final char[] 和设计哲学（如缓存、线程安全），与 final 关键字无关。

4.2、String 拼接性能问题

String s = "";
for (int i = 0; i < 10000; i++) {s += i; // 每次循环生成新 String 对象，性能极低
}

StringBuilder 优化如下：

StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10000; i++) {sb.append(i); // 直接修改内部 char[]，性能高
}
String result = sb.toString();

4.3、字符串常量池

JVM 优化：相同值的字符串会被共享，减少内存占用。

String s1 = "hello"; // 存入常量池
String s2 = "hello"; // 直接指向常量池中的 "hello"
System.out.println(s1 == s2); // true

举例：

// String 是不可变的
String s = "hello";
s = s + " world"; // 创建新对象，原 "hello" 未被修改// StringBuilder 是可变的
StringBuilder sb = new StringBuilder("hello");
sb.append(" world"); // 修改内部 char[]，对象内容被更新

结论