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

怎么申请一个免费域名宁波网络推广优化方案

news 2025/7/1 2:42:53

怎么申请一个免费域名,宁波网络推广优化方案,WordPress非首页输出文章,建设银行签证预约网站目录 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…

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

结论