SYSTEM
String
src/content/notes/system/SE-String.md String
基本介绍
String 被声明为 final,因此不可被继承 (Integer 等包装类也不能被继承)
public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
/** The value is used for character storage. */
private final char value[];
/** Cache the hash code for the string */
private int hash; // Default to 0
}
在 Java 9 之后,String 类的实现改用 byte 数组存储字符串,同时使用 coder 来标识使用了哪种编码
value 数组被声明为 final,这意味着 value 数组初始化之后就不能再引用其它数组,并且 String 内部没有改变 value 数组的方法,因此可以保证 String 不可变,也保证线程安全
注意:不能改变的意思是每次更改字符串都会产生新的对象,并不是对原始对象进行改变
String s = "abc";
s = s + "cd"; //s = abccd 新对象
常用方法
常用 API:
-
public boolean equals(String s):比较两个字符串内容是否相同、区分大小写 -
public boolean equalsIgnoreCase(String anotherString):比较字符串的内容,忽略大小写 -
public int length():返回此字符串的长度 -
public String trim():返回一个字符串,其值为此字符串,并删除任何前导和尾随空格 -
public String[] split(String regex):将字符串按给定的正则表达式分割成字符串数组 -
public char charAt(int index):取索引处的值 -
public char[] toCharArray():将字符串拆分为字符数组后返回 -
public boolean startsWith(String prefix):测试此字符串是否以指定的前缀开头 -
public int indexOf(String str):返回指定子字符串第一次出现的字符串内的索引,没有返回 -1 -
public int lastIndexOf(String str):返回字符串最后一次出现 str 的索引,没有返回 -1 -
public String substring(int beginIndex):返回子字符串,以原字符串指定索引处到结尾 -
public String substring(int i, int j):指定索引处扩展到 j - 1 的位置,字符串长度为 j - i -
public String toLowerCase():将此 String 所有字符转换为小写,使用默认语言环境的规则 -
public String toUpperCase():使用默认语言环境的规则将此 String 所有字符转换为大写 -
public String replace(CharSequence target, CharSequence replacement):使用新值,将字符串中的旧值替换,得到新的字符串
String s = 123-78;
s.replace("-","");//12378
构造方式
构造方法:
public String():创建一个空白字符串对象,不含有任何内容public String(char[] chs):根据字符数组的内容,来创建字符串对象public String(String original):根据传入的字符串内容,来创建字符串对象
直接赋值:String s = "abc" 直接赋值的方式创建字符串对象,内容就是 abc
- 通过构造方法创建:通过 new 创建的字符串对象,每一次 new 都会申请一个内存空间,虽然内容相同,但是地址值不同,返回堆内存中对象的引用
- 直接赋值方式创建:以
" "方式给出的字符串,只要字符序列相同(顺序和大小写),无论在程序代码中出现几次,JVM 都只会在 String Pool 中创建一个字符串对象,并在字符串池中维护
String str = new String("abc") 创建字符串对象:
- 创建一个对象:字符串池中已经存在 abc 对象,那么直接在创建一个对象放入堆中,返回堆内引用
- 创建两个对象:字符串池中未找到 abc 对象,那么分别在堆中和字符串池中创建一个对象,字符串池中的比较都是采用 equals()

new String("a") + new String("b") 创建字符串对象:
-
对象 1:new StringBuilder()
-
对象 2:new String(“a”)、对象 3:常量池中的 a
-
对象 4:new String(“b”)、对象 5:常量池中的 b

-
StringBuilder 的 toString():
@Override
public String toString() {
return new String(value, 0, count);
}
- 对象 6:new String(“ab”)
- StringBuilder 的 toString() 调用,在字符串常量池中没有生成 ab,new String(“ab”) 会创建两个对象因为传参数的时候使用字面量创建了对象 ab,当使用数组构造 String 对象时,没有加入常量池的操作
String Pool
基本介绍
字符串常量池(String Pool / StringTable / 串池)保存着所有字符串字面量(literal strings),这些字面量在编译时期就确定,常量池类似于 Java 系统级别提供的缓存,存放对象和引用
- StringTable,类似 HashTable 结构,通过
-XX:StringTableSize设置大小,JDK 1.8 中默认 60013 - 常量池中的字符串仅是符号,第一次使用时才变为对象,可以避免重复创建字符串对象
- 字符串变量的拼接的原理是 StringBuilder#append,append 方法比字符串拼接效率高(JDK 1.8)
- 字符串常量拼接的原理是编译期优化,拼接结果放入常量池
- 可以使用 String 的 intern() 方法在运行过程将字符串添加到 String Pool 中
intern()
JDK 1.8:当一个字符串调用 intern() 方法时,如果 String Pool 中:
- 存在一个字符串和该字符串值相等,就会返回 String Pool 中字符串的引用(需要变量接收)
- 不存在,会把对象的引用地址复制一份放入串池,并返回串池中的引用地址,前提是堆内存有该对象,因为 Pool 在堆中,为了节省内存不再创建新对象
JDK 1.6:将这个字符串对象尝试放入串池,如果有就不放入,返回已有的串池中的对象的引用;如果没有会把此对象复制一份,放入串池,把串池中的对象返回
public class Demo {
// 常量池中的信息都加载到运行时常量池,这时a b ab是常量池中的符号,还不是java字符串对象,是懒惰的
// ldc #2 会把 a 符号变为 "a" 字符串对象 ldc:反编译后的指令
// ldc #3 会把 b 符号变为 "b" 字符串对象
// ldc #4 会把 ab 符号变为 "ab" 字符串对象
public static void main(String[] args) {
String s1 = "a"; // 懒惰的
String s2 = "b";
String s3 = "ab"; // 串池
String s4 = s1 + s2; // 返回的是堆内地址
// 原理:new StringBuilder().append("a").append("b").toString() new String("ab")
String s5 = "a" + "b"; // javac 在编译期间的优化,结果已经在编译期确定为ab
System.out.println(s3 == s4); // false
System.out.println(s3 == s5); // true
String x2 = new String("c") + new String("d"); // new String("cd")
// 虽然 new,但是在字符串常量池没有 cd 对象,因为 toString() 方法
x2.intern();
String x1 = "cd";
System.out.println(x1 == x2); //true
}
}
- == 比较基本数据类型:比较的是具体的值
- == 比较引用数据类型:比较的是对象地址值
结论:
String s1 = "ab"; // 仅放入串池
String s2 = new String("a") + new String("b"); // 仅放入堆
// 上面两条指令的结果和下面的 效果 相同
String s = new String("ab");
常见问题
问题一:
public static void main(String[] args) {
String s = new String("a") + new String("b");//new String("ab")
//在上一行代码执行完以后,字符串常量池中并没有"ab"
String s2 = s.intern();
//jdk6:串池中创建一个字符串"ab"
//jdk8:串池中没有创建字符串"ab",而是创建一个引用指向 new String("ab"),将此引用返回
System.out.println(s2 == "ab");//jdk6:true jdk8:true
System.out.println(s == "ab");//jdk6:false jdk8:true
}
问题二:
public static void main(String[] args) {
String str1 = new StringBuilder("58").append("tongcheng").toString();
System.out.println(str1 == str1.intern());//true,字符串池中不存在,把堆中的引用复制一份放入串池
String str2 = new StringBuilder("ja").append("va").toString();
System.out.println(str2 == str2.intern());//false,字符串池中存在,直接返回已经存在的引用
}
原因:
-
System 类当调用 Version 的静态方法,导致 Version 初始化:
private static void initializeSystemClass() { sun.misc.Version.init(); } -
Version 类初始化时需要对静态常量字段初始化,被 launcher_name 静态常量字段所引用的
"java"字符串字面量就被放入的字符串常量池:package sun.misc; public class Version { private static final String launcher_name = "java"; private static final String java_version = "1.8.0_221"; private static final String java_runtime_name = "Java(TM) SE Runtime Environment"; private static final String java_profile_name = ""; private static final String java_runtime_version = "1.8.0_221-b11"; //... }
内存位置
Java 7 之前,String Pool 被放在运行时常量池中,属于永久代;Java 7 以后,String Pool 被移到堆中,这是因为永久代的空间有限,在大量使用字符串的场景下会导致 OutOfMemoryError 错误
演示 StringTable 位置:
-
-Xmx10m设置堆内存 10m -
在 JDK8 下设置:
-Xmx10m -XX:-UseGCOverheadLimit(运行参数在 Run Configurations VM options) -
在 JDK6 下设置:
-XX:MaxPermSize=10mpublic static void main(String[] args) throws InterruptedException { List<String> list = new ArrayList<String>(); int i = 0; try { for (int j = 0; j < 260000; j++) { list.add(String.valueOf(j).intern()); i++; } } catch (Throwable e) { e.printStackTrace(); } finally { System.out.println(i); } }

优化常量池
两种方式:
-
调整 -XX:StringTableSize=桶个数,数量越少,性能越差
-
intern 将字符串对象放入常量池,通过复用字符串的引用,减少内存占用
/**
* 演示 intern 减少内存占用
* -XX:StringTableSize=200000 -XX:+PrintStringTableStatistics
* -Xsx500m -Xmx500m -XX:+PrintStringTableStatistics -XX:StringTableSize=200000
*/
public class Demo1_25 {
public static void main(String[] args) throws IOException {
List<String> address = new ArrayList<>();
System.in.read();
for (int i = 0; i < 10; i++) {
//很多数据
try (BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("linux.words"), "utf-8"))) {
String line = null;
long start = System.nanoTime();
while (true) {
line = reader.readLine();
if(line == null) {
break;
}
address.add(line.intern());
}
System.out.println("cost:" +(System.nanoTime()-start)/1000000);
}
}
System.in.read();
}
}
不可变好处
- 可以缓存 hash 值,例如 String 用做 HashMap 的 key,不可变的特性可以使得 hash 值也不可变,只要进行一次计算
- String Pool 的需要,如果一个 String 对象已经被创建过了,就会从 String Pool 中取得引用,只有 String 是不可变的,才可能使用 String Pool
- 安全性,String 经常作为参数,String 不可变性可以保证参数不可变。例如在作为网络连接参数的情况下如果 String 是可变的,那么在网络连接过程中,String 被改变,改变 String 的那一方以为现在连接的是其它主机,而实际情况却不一定是
- String 不可变性天生具备线程安全,可以在多个线程中安全地使用
- 防止子类继承,破坏 String 的 API 的使用