Java String 详解 - String Literal

本文详细介绍了JVM如何处理String类型数据,包括String字面量池的作用、字符串字面量与对象的关系、编译时与运行时计算的区别、intern方法的使用以及垃圾回收机制对String的影响。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

为了性能和内存资源上的考虑,JVM对String类型的数据做了特殊的处理。也就是大家都知道的String是immutable的或者是constant。其实很多面试或者笔试里面都会考到。有时觉得没事找事,确实,对于一般的系统,不需要考虑到底创建了几个string,只管用就是,似乎JVM会处理,至少会GC他们的。其实不然。对于大型项目,或者运行很长时间的项目,或者使用到大量字符串的项目来说,String的开销就不得不考虑。
[size=medium]1. String Literal Constant Pool[/size]
[quote]By literal we mean any number, text, or other information that represents a value. This means what you type is what you get.[/quote]
literal,就是字符串,数字等值本身。当你在编码的时候写下一个值的时候,比如10,或者“abc”你就写了一个literal。
JVM 维护了一个String Literal Pool,用来存储String Literal。
[quote]A string literal consists of zero or more characters enclosed in double quotes.
A string literal is a reference to an instance of class String. Moreover, a string literal always refers to the same instance of class String.[/quote]
字符串字是一个由双引号括起来的字符序列。它是指向一个String实例的引用。
比如 String s = “abc”。对于“abc”,它首先是一个String literal,它在创建之后,立即利用String的intern方法,装入到了Literal Pool并返回这个String 实例的引用给s。当你再次写abc”的时候,intern方法会先查看是否已有这个literal了,就会直接返回这个literal对应的String实例的引用。也就是说你循环1000变,内存里面也只有这么一个String literal以及他对应的String的实例。String,本质上是一个Java 类,它的实例除了包含value,也就是这个字符序列外,还有其他的属性和方法。这样看来String Object和Literal本质上是不同的。
其实除了String Literal,还有其他类型的Literal:
[quote]
[list]
[*]IntegerLiteral
[*]FloatingPointLiteral
[*]BooleanLiteral
[*]CharacterLiteral
[*]StringLiteral
[*]NullLiteral
[/list]
[/quote]
只是,只有String Literal有这么一个pool,用来提高性能和节约内存。提高性能,是因为你可以重用已经有的String Object,这样也就节约了内存。
再来看看 new String("abc"), 只有用了双引号,就会涉及到string literal,它的逻辑就是先查看是否已有这个literal,有就返回它的string object 引用,没有就创建一个,并生成一个string的object,然后把这个object的引用返回。可见,没有string literal有且仅有一个string object与之对应。回到这句话,new String("abc"),只有用到new,就会新建一个object,这里是新建一个string object。这就都明白了吧。看一个例子:

package jdk.lang;
public class StringTest {
public static void main(String[] args) {
String s1 = "abc";
String s2 = "abc";
System.out.println(s1 == s2);
}
}

输出 true。也就是只生成了一个对象。
[size=medium]2. 编译时计算和运行时计算的区别[/size]
看下面:
package jdk.lang;
public class StringTest {
public static void main(String[] args) {
String s1 = "abc";
String s2 = "abc";
String s3 = s1 + s2;
String s4 = "abc" + "abc";
String s5 = "ab" + "cabc";
System.out.println(s3 == s4);
System.out.println(s4 == s5);
}
}

输出:false true。上面的程序,"abc" + "abc"是常量运算表达式constant expression。编译器就可以计算出值了,这就是编译时计算。同时这个表达式会被看做是string literal。但是:String s3 = s1+s2;那么s3的值就只能在运行的时候才能确定,这就是运行时计算。可见运行时会创建一个新的String,并且不会被当成string literal。
[size=medium]3. Intern[/size]
下面是String的intern方法的注释和签名,可见是一个native方法。
[quote]
A pool of strings, initially empty, is maintained privately by the class String.
When the intern method is invoked, if the pool already contains a string equal to this String object as determined by the equals(Object) method, then the string from the pool is returned. Otherwise, this String object is added to the pool and a reference to this String object is returned.
All literal strings and string-valued constant expressions are interned.
public native String intern();
[/quote]
String提供了方法Intern让我们把显示的调用来把String对象放入到literal pool里面并返回这个新的引用。
package jdk.lang;
public class StringTest {
public static void main(String[] args) {
String s1 = "abc";
String s2 = "abc";
String s3 = s1 + s2;
String s4 = s3.intern();
String s5 = "ab" + "cabc";
System.out.println(s4 == s5);
System.out.println(s3 == s5);
System.out.println(s3.intern() == s3);
System.out.println(s3.intern() == s4);
System.out.println(s5.intern() == s5);
}
}

输出: true false false true true。s4是一个新的引用,这个引用和s5一样,但是和s3不同。也就是说,intern的时候创建了一个新的对象。但是不是每次都新建一个,只要有了,就会返回存在的。最后两个结果就说明了这点。
[size=medium]4. 垃圾回收[/size]
GC是不会收集Literal Pool的。但是会收集没有intern的String 变量对象。对上面的例子,s3会被回收,s4就不会。
[size=medium]5. constant expression - 常量表达式[/size]
[quote]Compile-time constant expressions of type String are always "interned" so as to share unique instances, using the method String.intern.[/quote]
常量表达式,比如 "ab" + "cabc"会被当成literal,也就等同"abcabc"。


6. 关于其他的Literal呢?

[quote]
If the value p being boxed is true, false, a byte, or a char in the range \u0000
to \u007f, or an int or short number between -128 and 127 (inclusive), then let
r1 and r2 be the results of any two boxing conversions of p. It is always the case
that r1 == r2.
[/quote]

也就是说,他们是部分重用的。看一个例子:

private static void IntegerLiteral() {
Integer i1 = 6;
Integer i2 = 6;
Integer i3 = 3 + 3;
Integer i4 = 3 * 2;
System.out.println(i1 == i2);//true
System.out.println(i3 == i2);//true
System.out.println(i4 == i2);//true

Integer i5 = 128;
Integer i6 = 128;
System.out.println(i5 == i6);//false
}
private static void BoolearnLiteral() {
Boolean b1 = true;
Boolean b2 = true;
System.out.println(b1 == b2);//false
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值