Java字符串

1.字符串的概念

字符串：java中的字符串就是存在常量池（方法区中）并以Unicode编码的字符串集合。

1.1 java中的字符串使用Unicode编码

C中的字符串使用ASCII码，用一个字节表示一个字符。但一个字节无法表示全世界那么多种字符，例如表示汉字就需要用2个字符。

java使用Unicode编码，使用两个字节表示一个字符，无论是字母还是汉字，用java处理就更加方便，跨平台性好，比C的缺点就是消耗更多的内存。

1.2 java中字符串存改在常量池中。

java的内存分为堆，栈，方法区（包括常量池）。 java中字符串存改在常量池中。

方法区中主要存在类结构，静态变量。方法区又包含常量池，常量池保存字符串常量。

变量：内存地址不变，内存值可以修改

常量：内存值不能改变，只能通过更改引用值来指向另一块内存。java的String类没有set方法。(事实上可以通过反射修改内存)

2.String类的概念

String类是用于字符串相关操作的一个类。

类包括成员变量和方法。

(1)String类有一个特殊的成员变量，保存着常量池中某个字符串的内存地址，也可以理解为一个指针。

(2)String类有一些方法，如indexOf(),charAt()。String类没有对字符串进行修改的方法。

虽然String类没有修改字符串的方法，但保留字符串地址的成员变量是可以修改的，也就是说String类的对象可以指向另外的字符串。

3.String类实例化对象的方法

String类实例化对象有两个方法

3.1 String str= “abc” 创建方式

创建对象的过程

1 首先在常量池中查找是否存在内容为”abc”字符串对象

2 如果不存在则在常量池中创建”abc”，并让str引用该对象

3 如果存在则直接让str引用该对象

至于”abc”是怎么保存，保存在哪？常量池属于类信息的一部分，而类信息反映到JVM内存模型中是对应存在于JVM内存模型的方法区，也就是说这个类信息中的常量池概念是存在于在方法区中，而方法区是在JVM内存模型中的堆中由JVM来分配的，所以”abc”可以说存在于堆中（而有些资料，为了把方法区的 堆区别于JVM的堆，把方法区称为非堆）。一般这种情况下，”abc”在编译时就被写入字节码中，所以class被加载时，JVM就为”abc”在常量池中分配内存，所以和静态区差不多。

3.2 String str= new String(“abc”)创建方式

创建对象的过程

1 首先在堆中（不是常量池）创建一个指定的对象，并让str引用指向该对象。

2 在字符串常量池中查看，是否存在内容为”abc”字符串对象

3 若存在，则将new出来的字符串对象与字符串常量池中的对象联系起来（即让那个特殊的成员变量value的指针指向它）

4 若不存在，则在字符串常量池中创建一个内容为”abc”的字符串对象，并将堆中的对象与之联系起来。（有可能此时常量池中的”abc”已经被回收，所以要先创建一个内容

为”abc”的字符串对象）

3.3 示例

(1)

String str1 = new String(“abc”);
String str2 = new String(“abc”);
String str3 = “abc”;
String str4 = “abc”;
String str5 = “ab” + “c”;

System.out.println(str1 == str2);//false.在堆中创建了两个不同的实例。虽然实例都指向常量池中的同一字符串（成员变量value的地址相同），但实例的地址并不相同。
System.out.println(str3 == str4);//true. JVM创建了两个引用str3和str4，但只创建了一个对象，而且两个引用都指向了这个对象。

System.out.println(str1.intern() == str4.intern());//true
System.out.println(str1.intern() == str3);//true
//一个初始为空的字符串池，它由类 String 私有地维护。
//当调用 intern 方法时，如果池已经包含一个等于此 String 对象的字符串（用 equals(Object) 方法确定），则返回池中的字符串。否则，将此 String 对象添加到池中，并返回此

//String 对象的引用。
//它遵循以下规则：对于任意两个字符串 s 和 t ，当且仅当 s.equals(t) 为 true 时，s.intern() == t.intern() 才为 true 。

System.out.println(str3 == str5);//true
//是因为String str2 = “ab” + “c”会查找常量池中时候存在内容为”abc”字符串对象，如果存在则直接让str2引用该对象。
//显然String str1 = “abc”的时候，上面说了，会在常量池中创建”abc”对象，所以str1引用该对象，str2也引用该对象，所以str1==str2

(2)

String str1 = “abc”;

String str2 = “abc”;

str1 = “bcd”;

System.out.println(str1 + “,” + str2); //bcd, abc

System.out.println(str1==str2); //false

这就是说，赋值的变化导致了类对象引用的变化，str1指向了另外一个新对象！而str2仍旧指向原来的对象。上例中，当我们将str1的值改为”bcd”时，JVM发现在 常量池中没有存放该值的地址，便开辟了这个地址，并创建了一个新的对象，其字符串的值指向这个地址。 事 实上，String类被设计成为不可改变(immutable)的类。如果你要改变其值，可以，但JVM在运行时根据新值悄悄创建了一个新对象，然后将这 个对象的地址返回给原来类的引用。这个创建过程虽说是完全自动进行的，但它毕竟占用了更多的时间。在对时间要求比较敏感的环境中，会带有一定的不良影响。

(3)

String str1 = “abc”;

String str2 = “abc”;

str1 = “bcd”;

String str3 = str1;

System.out.println(str3); //bcd

String str4 = “bcd”;

System.out.println(str1 == str4); //true str3 这个对象的引用直接指向str1所指向的对象(注意，str3并没有创建新对象)。当str1改完其值后，再创建一个String的引用str4，并指向 因str1修改值而创建的新的对象。可以发现，这回str4也没有创建新的对象，从而再次实现栈中数据的共享。

(4)

我们再接着看以下的代码。

String str1 = new String(“abc”);

String str2 = “abc”;

System.out.println(str1==str2); //false 创建了两个引用。创建了两个对象。两个引用分别指向不同的两个对象。

String str1 = “abc”; String str2 = new String(“abc”); System.out.println(str1==str2); //false 创建了两个引用。创建了两个对象。两个引用分别指向不同的两个对象。 以上两段代码说明，只要是用new()来新建对象的，都会在堆中创建，而且其字符串是单独存值的，即使与栈中的数据相同，也不会与栈中的数据共享。

(5)

String str1 = “a”;
String str2 = “b”;
String str3 = “ab”;
String str6 = “a” + “b”;
String str4 = str1 + str2;

String str5 = new String(“ab”);

System.out.println(str5.equals(str3));
System.out.println(str5 == str3);
System.out.println(str5.intern() == str3);
System.out.println(str5.intern() == str4);// false
结果解释:
代码中的字符串拼接符号 + ，会被编译器重载为StringBuilder的append()方法以提高性能，对于String str4 = str1 + str2; 具体实现大致是这样
StringBuilder temp = new StringBuilder(); temp.append(str1); temp.append(str2); String str4 = temp.toString();
字面量的字符串会在编译器优化，”a” + “b” 编译期会直接优化成”ab”, 前面已经str3 = “ab”;所以引用str6的值在编译期就已经确定了指向”ab”;
str1 + str1的结果无法在编译期确定(如果你把str1、str1定义为final类型，结果都是true了)

intern的用法：

返回字符串对象的规范化表示形式。

一个初始时为空的字符串池，它由类 String 私有地维护。

当调用 intern 方法时，如果池已经包含一个等于此 String 对象的字符串（该对象由 equals(Object) 方法确定），则返回池中的字符串。否则，将此 String 对象添加到池中，并且返回此 String 对象的引用。

它遵循对于任何两个字符串 s 和 t，当且仅当 s.equals(t) 为 true 时，s.intern() == t.intern() 才为 true。

所有字面值字符串和字符串赋值常量表达式都是内部的。

返回：

一个字符串，内容与此字符串相同，但它保证来自字符串池中。

4. 数据类型包装类的值不可修改。

不仅仅是String类的值不可修改，所有的数据类型包装类都不能更改其内部的值。

5. 结论与建议：

(1) 我们在使用诸如String str = “abc”；的格式定义类时，总是想当然地认为，我们创建了String类的对象str。担心陷阱！对象可能并没有被创建！唯一可以肯定的是，指向 String类的引用被创建了。至于这个引用到底是否指向了一个新的对象，必须根据上下文来考虑，除非你通过new()方法来显要地创建一个新的对象。因 此，更为准确的说法是，我们创建了一个指向String类的对象的引用变量str，这个对象引用变量指向了某个值为”abc”的String类。清醒地认 识到这一点对排除程序中难以发现的bug是很有帮助的。

(2)使用String str = “abc”；的方式，可以在一定程度上提高程序的运行速度，因为JVM会自动根据栈中数据的实际情况来决定是否有必要创建新对象。而对于String str = new String(“abc”)；的代码，则一概在堆中创建新对象，而不管其字符串值是否相等，是否有必要创建新对象，从而加重了程序的负担。这个思想应该是 享元模式的思想，但JDK的内部在这里实现是否应用了这个模式，不得而知。

(3)当比较包装类里面的数值是否相等时，用equals()方法；当测试两个包装类的引用是否指向同一个对象时，用==。

(4)由于String类的immutable性质，当String变量需要经常变换其值时，应该考虑使用StringBuffer类，以提高程序效率

6.这里有几个问题（进阶版）：

(1) String a1 = new String(“abc”) 在运行时涉及几个String实例？

两个，一个是字符串字面量”xyz”所对应的、驻留（intern）在一个全局共享的字符串常量池中的实例，另一个是通过new String(String)创建并初始化的、内容与”xyz”相同的实例

(2) String a1 = new String(“abc”) 涉及用户声明的几个String类型的变量？

一个，就是String s。
(3)String s = null 涉及用户声明的几个String类型的变量？
一个。Java里变量就是变量，引用类型的变量只是对某个对象实例或者null的引用，不是实例本身。声明变量的个数跟创建实例的个数没有必然关系

(4)

1. String s1 = ”a”;
2. String s2 = s1.concat(”“);
3. String s3 = null;
4. new String(s1);

这段代码会涉及3个String类型的变量，
1、s1，指向下面String实例的1
2、s2，指向与s1相同
3、s3，值为null，不指向任何实例

以及3个String实例，
1、”a”字面量对应的驻留的字符串常量的String实例
2、”“字面量对应的驻留的字符串常量的String实例
（String.concat()是个有趣的方法，当发现传入的参数是空字符串时会返回this，所以这里不会额外创建新的String实例）
3、通过new String(String)创建的新String实例；没有任何变量指向它。

（5）如下每执行一次创建了几个实例：

1. String s1 = new String(“xyz”);
2. String s2 = new String(“xyz”);

每执行一次只会新创建2个String实例。

符合规范的JVM实现应该在类加载的过程中创建并驻留一个String实例作为常量来对应”xyz”字面量；具体是在类加载的resolve阶段进行的。这个常量是全局共享的，只在先前尚未有内容相同的字符串驻留过的前提下才需要创建新的String实例。
等到真正执行原问题中的代码片段时，JVM需要执行的字节码类似这样：

Java bytecode代码

1. 0: new #2; //class java/lang/String
2. 3: dup
3. 4: ldc #3; //String xyz
4. 6: invokespecial #4; //Method java/lang/String.“”:(Ljava/lang/String;)V
5. 9: astore_1

这之中出现过多少次new java/lang/String就是创建了多少个String对象。

这里，ldc指令只是把先前在类加载过程中已经创建好的一个String对象（”xyz”）的一个引用压到操作数栈顶而已，并不新创建String对象。

在Java语言里，“new”表达式是负责创建实例的，其中会调用构造器去对实例做初始化；构造器自身的返回值类型是void，并不是“构造器返回了新创建的对象的引用”，而是new表达式的值是新创建的对象的引用。
对应的，在JVM里，“new”字节码指令只负责把实例创建出来（包括分配空间、设定类型、所有字段设置默认值等工作），并且把指向新创建对象的引用压到操作数栈顶。此时该引用还不能直接使用，处于未初始化状态（uninitialized）；如果某方法a含有代码试图通过未初始化状态的引用来调用任何实例方法，那么方法a会通不过JVM的字节码校验，从而被JVM拒绝执行。
能对未初始化状态的引用做的唯一一种事情就是通过它调用实例构造器，在Class文件层面表现为特殊初始化方法“”。实际调用的指令是invokespecial，而在实际调用前要把需要的参数按顺序压到操作数栈上。在上面的字节码例子中，压参数的指令包括dup和ldc两条，分别把隐藏参数（新创建的实例的引用，对于实例构造器来说就是“this”）与显式声明的第一个实际参数（”xyz”常量的引用）压到操作数栈上。
在构造器返回之后，新创建的实例的引用就可以正常使用了。

8.引用

http://blog.csdn.net/niluchen/article/details/8048710

http://www.cnblogs.com/xiohao/p/4296088.html

http://www.360doc.com/content/14/1107/23/17130779_423471141.shtml