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

目录

1、字符串常量池

1.1、具体位置

1.2、位置变化

2、字符串分类

[2.1. String](#2.1. String)

[2.2. StringBuffer](#2.2. StringBuffer)

[2.3. StringBuilder](#2.3. StringBuilder)

[3. final修饰的原因](#3. final修饰的原因)

[4. 扩展](#4. 扩展)

4.1、final修饰

[4.2、String 拼接性能问题](#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;

    @Override
    public synchronized int length() {
        return count;
    }

    @Override
    public 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[]，对象内容被更新

结论

• final 的作用是 禁止继承，与类的可变性无关。
• String 的不可变性源于其内部设计（final char[] 和无修改方法）。
• StringBuffer 和 StringBuilder 的可变性源于其内部可变的 char[] 和提供修改方法。
• 设计 final 类的目的是为了 线程安全、性能优化和一致性保证，而非限制实例的可变性。

---

总结：