String类总结

String类是Java中很重要的一个类,在此总结一下这个类的特别之处。
下面的相关资料翻译自《java语言规范》(第三版)和《java虚拟机规范》(第二版),有的直接摘引了原文。下面的代码都是用SUN jdk1.6 javac来编译。
1.String literal,这里将它翻译为字面常量,它由双引号包围的0个或多个字符组成,比如"abc","Hello World"等等。
一个String字面常量总是引用相同的String实例,比如"abc","abc"两个常量引用的是同一个对象。
程序测试:
package testPackage;
class Test {
public static void main(String[] args) {
String hello = "Hello", lo = "lo";
System.out.print((hello == "Hello") + " ");
System.out.print((Other.hello == hello) + " ");
System.out.print((other.Other.hello == hello) + " ");
System.out.print((hello == ("Hel"+"lo")) + " ");
System.out.print((hello == ("Hel"+lo)) + " ");
System.out.println(hello == ("Hel"+lo).intern()); } }
class Other { static String hello = "Hello"; }
另一个包:

package other;

public class Other { static String hello = "Hello"; }
输出: true true true true false true
结论有六点:
1) 同一个包下,同一个类中的相同的String字面常量表示对同一个String对象的引用。
2) 同一个包下,不同的类中的相同的String字面常量表示对同一个String对象的引用。
3) 不同包下,不同类中的相同String字面常量同样表示对同一个String对象的引用。
4) 通过常量表达式计算的String,计算在编译时进行,并将它作为String字面常量对待。
5) 通过连接操作得到的String(非常量表达式),连接操作是运行时进行的,会新创建对象,所以它们是不同的。
6) 显式的对一个计算得到的String调用intern操作,得到的结果是已经存在的相同内容的String字面常量。
补充说明:
1)像这样的问题,String str = "a"+"b"+"c"+"d"; 运行这条语句会产生几个String对象?1个。
参考上面第5条,通过常量表达式得到的String 是编译时计算的,因此执行这句话时只有"abcd"着一个String对象存在。
常量表达是的定义可以参考java语言规范。
另例: final String str1 = "a"; String str2 = str1+"b";
执行第二句话会有几个String对象产生?1个。
因为str1是常量,所以str1+"b"也是常量表达式,在编译时计算。
遇到这种问题时,不要说它依赖于具体的编译器或者虚拟机实现,因为这就是规范里有的。
一般的说,java的编译器实现应该遵守《java语言规范》,而java虚拟机实现应该遵守《java虚拟机规范》。
2)不要这样使用字符串: String str = new String("abc");
参考文档中的说明: String public String(String original) 初始化一个新创建的 String 对象,使其表示一个与参数相同的字符序列;
换句话说,新创建的字符串是该参数字符串的副本。
由于 String 是不可变的,所以无需使用此构造方法,除非需要 original 的显式副本。
参数: original - 一个 String。 注意:无需使用此构造方法!!!
3)单独的说明第6点: String str = new String("abc"); str = str.intern();
当调用 intern 方法时,如果池已经包含一个等于此 String 对象的字符串(用 equals(Object) 方法确定),则返回池中的字符串引用。
否则,将此 String 对象添加到池中,并返回此 String 对象的引用。
很明显,在这个例子中"abc"引用的对象已经在字符串池中了,再调用intern返回的是已经存在池中内容为"abc"的字符换对象的引用。
在上面的例子中也说明了这个问题。

2. String类的实例表示表示Unicode字符序列。
String字面常量是指向String实例的引用。(字面常量是“引用”!)
3.String转换 对于基本类型先转换为引用类型;引用类型调用toString()方法得到String,如果该引用类型为null,转换得到的字符串为"null"。
4. String链接操作“+” 如果“+”操作的结果不是编译期常量,将会隐式创建一个新的对象。
为了提高性能,具体的实现可以采用StringBuffer,StringBuilder类对多个部分进行连接,最后再转换为String,从而避免生成再丢弃中间的String对象。
为了达到共享实例的目的,编译期常量总是“interned”的。
例子: String a = "hello "; String b = a+1+2+"world!";
反汇编结果: 0: ldc #2; //String hello 2: astore_1 3: new #3; //class java/lang/StringBuilder 6: dup 7: invokespecial #4; //Method java/lang/StringBuilder." <init>":()V 10: aload_1 11: invokevirtual #5; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder; 14: iconst_1 15: invokevirtual #6; //Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder; 18: iconst_2 19: invokevirtual #6; //Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder; 22: ldc #7; //String world! 24: invokevirtual #5; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder; 27: invokevirtual #8; //Method java/lang/StringBuilder.toString:()Ljava/lang/String; 30: astore_2

实际就是 String b = new StringBuilder().append(a).append(1).append(2).append("world").toString();
这里就使用StringBuilder来避免中间临时String对象的产生而导致性能下降。
补充例子,下面的两个例子主要是对编译时常量做一个说明:
1) String c = "c"; String str = "a"+"b"+c; 和
2) String c = "c"; String str = c+"a"+"b";
1)中,str="a"+"b"+c;编译器分析是会把"a"+"b"作为编译时常量,生成字面常量"ab",所以实际执行这句话时,链接的是"ab"和c。
实际相当于执行了 String str = new StringBuilder().append("ab").append(c).toString();
2)中,String str = c+"a"+"b"; 编译器分析到c为变量,后面的"a"+"b"就不会作为编译时常量来运算了。
实际运行时相当于执行 String str = new StringBuilder().append(c).append("a").append("b").toString();
5.String对象的创建:
1) 包含String字面常量的类或者接口在加载时创建表示该字面常量的String对象。
以下两种情况下不会创建新String对象。
a) 一个相同的字面常量已经出现过。
b) 一个相同内容的字符串已经调用了intern操作(比如经过运算产生的字符串调用intern的情形)。
2) 非常量表达式的字符串连接操作有时会产生表示结果的String对象。
3) String字面常量来自类或接口的二进制表示中(也就是class文件中)的CONSTANT_String_info 结构。
CONSTANT_String_info结构给出了构成字符串字面常量的Unicode字符序列。
4) 为了生成字符串字面常量,java虚拟机检查 CONSTANT_String_info结构给出的字符序列:
a) 如果与CONSTANT_String_info结构中给出的字符换内容相同的串实例已经调用过String.intern,得到的字符串字面常量就来自该串的同一实例。
b) 否则,根据CONSTANT_String_info 中的字符序列创建一个新的字符串实例,然后调用intern方法。
例子:一个SCJP题目

11. public String makinStrings() {

12. String s = “Fred”;

13. s = s + “47”;

14. s = s.substring(2, 5);

15. s = s.toUpperCase();

16. return s.toString();

17. }

How many String objects will be created when this method is invoked? 答案是3个。
上面已经说明,"Fred","47"是字符串字面常量,它们在在类加载时创建的。这里题目问,方法调用时()有多少个String对象被创建,两个字面常量自然不包括在内。
3个是:"Fred47","ed4","ED4"。
6.String与基本类型的包装类比较 相同点,它们都是不变类,使用"=="判断时可能会有类似的性质。 在java 5之后,java增加了自动装箱和拆箱功能。

因此,就有了这样的性质: Integer i = 5; Integer j = 5; System.out.println(i == j); 结果:true.

这表面上看来是和String相同点,但其实现是极为不同的。这里作为一个不同点来介绍。
众所周知,自动装箱是这样实现的: Integer i = 5;

相当于 Integer i = Integer.valueOf(5);//注意不是new Integer(5),

这就无法满足java语言规范中的约定了,约定见本文最后

而在Integer中,静态的创建了表示从-128~+127之间数据的Integer对象,这个范围之内的数进行装箱操作,只要返回相应的对象即可。因此 Integer i = 5; Integer j = 5; 我们得到的是同一个对象。这是通过类库的设计来实现的。

而String的共享是通过java虚拟机的直接支持来实现的,这是它们本质的不同。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值