JavaSE基础-String相关

提到存储，Java中有如下位置：寄存器；堆；栈；常量池；静态域；非RAM存储如硬盘。

我们谈论得比较多的还是关于堆栈。栈更像是程序执行对象，而堆是存储对象。堆由jvm管理。

栈中存放基本数据类型和对象引用。而堆中存储实际对象以及类似数组结构。

Java中的String是一个类，而并非基本数据类型。

Java程序要运行，首先需要编译器将源代码文件编译成字节码文件(也就是.class文件).源代码编译成class文件之后，JVM就要运行这个class文件。它首先会用类装载器加载进class文件。然后需要创建许多内存数据结构来存放class文件中的字节数据。比如class文件对应的类信息数据、常量池结构、方法中的二进制指令序列、类方法与字段的描述信息等等.

对于String而言，java源码中的字面值字符串（怎么区分是否）会在编译期间形成常量表。jvm加载文件的时候，会为常量池建立数据结构，jvm会在堆中创建字符串对象（拘留字符串对象），把在编译期间常量表中的入口地址传递给堆中。源码中很多有相同字面值得字符串常量可能建立唯一的拘留字符串对象。

String s=new String("Hello world")；

在运行这段代码之前，jvm就已经在堆中创建了一个拘留字符串，然后用拘留字符串的值来初始化堆中用new创建的新的String对象，局部变量s实际存储的是new出来的堆对象地址。此时在JVM管理的堆中，有两个相同字符串值的String对象：一个是拘留字符串对象，一个是new新建的字符串对象。如果还有一条创建语句String s1=new String("Hello world")；堆中有3个值为"Hello world"的字符串.

String s="Hello world“

局部变量s存储的是早已创建好的拘留字符串的堆地址。如果还有一条穿件语句String s1="Hello word"；此时堆中有几个值为"Hello world"的字符串呢?答案是1个。那么局部变量s与s1存储的地址是否相同呢？  呵呵, 这个你应该知道了吧。

String sa=newString("Hello world");

String sb=newString("Hello world");

System.out.println(sa==sb);// false

//代码2

String sc="Hello world";

String sd="Hello world";

System.out.println(sc==sd);// true

代码1中局部变量sa,sb中存储的是JVM在堆中new出来的两个String对象的内存地址。虽然这两个String对象的值(char[]存放的字符序列)都是"Hello world"。因此"=="比较的是两个不同的堆地址。代码2中局部变量sc,sd中存储的也是地址，但却都是常量池中"Hello world"指向的堆的唯一的那个拘留字符串对象的地址。自然相等了。

字符串“+”操作的内幕


Java代码

//代码1

String sa ="ab";

String sb ="cd";

String sab=sa+sb;

String s="abcd";

System.out.println(sab==s);// false

//代码2

String sc="ab"+"cd";

String sd="abcd";

System.out.println(sc==sd);//true

代码1中局部变量sa,sb存储的是堆中两个拘留字符串对象的地址。而当执行sa+sb时，JVM首先会在堆中创建一个StringBuilder类，同时用sa指向的拘留字符串对象完成初始化，然后调用append方法完成对sb所指向的拘留字符串的合并操作，接着调用StringBuilder的toString()方法在堆中创建一个String对象，最后将刚生成的String对象的堆地址存放在局部变量sab中。而局部变量s存储的是常量池中"abcd"所对应的拘留字符串对象的地址。sab与s地址当然不一样了。这里要注意了，代码1的堆中实际上有五个字符串对象：三个拘留字符串对象、一个String对象和一个StringBuilder对象。

代码2中"ab"+"cd"会直接在编译期就合并成常量"abcd"，因此相同字面值常量"abcd"所对应的是同一个拘留字符串对象，自然地址也就相同。

String(生于JDK1.0时代)          不可变字符序列

StringBuffer(生于JDK1.0时代)    线程安全的可变字符序列

StringBuilder(生于JDK1.5时代)   非线程安全的可变字符序列

StringBuffer与String的可变性问题

//String


publicfinalclassString

{

privatefinalcharvalue[];

publicString(String original) {

// 把原字符串original切分成字符数组并赋给value[];

}

}

//StringBuffer

publicfinalclassStringBufferextendsAbstractStringBuilder

{

charvalue[];//继承了父类AbstractStringBuilder中的value[]

publicStringBuffer(String str) {

super(str.length() +16);//继承父类的构造器，并创建一个大小为str.length()+16的value[]数组

append(str);//将str切分成字符序列并加入到value[]中

}

}

很显然，String和StringBuffer中的value[]都用于存储字符序列。但是,

(1) String中的是常量(final)数组，只能被赋值一次。

比如：new String("abc")使得value[]={'a','b','c'}，之后这个String对象中的value[]再也不能改变了。这也正是大家常说的，String是不可变的原因。

注意：这个对初学者来说有个误区，有人说String str1=new String("abc"); str1=new String("cba");不是改变了字符串str1吗？那么你有必要先搞懂对象引用和对象本身的区别。这里我简单的说明一下，对象本身指的是存放在堆空间中的该对象的实例数据(非静态非常量字段)。而对象引用指的是堆中对象本身所存放的地址，一般方法区和Java栈中存储的都是对象引用，而非对象本身的数据。

(2) StringBuffer中的value[]就是一个很普通的数组，而且可以通过append()方法将新字符串加入value[]末尾。这样也就改变了value[]的内容和大小了。

比如：new StringBuffer("abc")使得value[]={'a','b','c','',''...}(注意构造的长度是str.length()+16)。如果再将这个对象append("abc")，那么这个对象中的value[]={'a','b','c','a','b','c',''....}。这也就是为什么大家说StringBuffer是可变字符串的涵义了。从这一点也可以看出，StringBuffer中的value[]完全可以作为字符串的缓冲区功能。其累加性能是很不错的，在后面我们会进行比较。

总结，讨论String和StringBuffer可不可变。本质上是指对象中的value[]字符数组可不可变，而不是对象引用可不可变。

★StringBuffer与StringBuilder的线程安全性问题

StringBuffer和StringBuilder可以算是双胞胎了，这两者的方法没有很大区别。但在线程安全性方面，StringBuffer允许多线程进行字符操作。这是因为在源代码中StringBuffer的很多方法都被关键字synchronized修饰了，而StringBuilder没有。

有多线程编程经验的程序员应该知道synchronized。这个关键字是为线程同步机制设定的。我简要阐述一下synchronized的含义：

每一个类对象都对应一把锁，当某个线程A调用类对象O中的synchronized方法M时，必须获得对象O的锁才能够执行M方法，否则线程A阻塞。一旦线程A开始执行M方法，将独占对象O的锁。使得其它需要调用O对象的M方法的线程阻塞。只有线程A执行完毕，释放锁后。那些阻塞线程才有机会重新调用M方法。这就是解决线程同步问题的锁机制。

了解了synchronized的含义以后，大家可能都会有这个感觉。多线程编程中StringBuffer比StringBuilder要安全多了，事实确实如此。如果有多个线程需要对同一个字符串缓冲区进行操作的时候，StringBuffer应该是不二选择。

注意：是不是String也不安全呢？事实上不存在这个问题，String是不可变的。线程对于堆中指定的一个String对象只能读取，无法修改。试问：还有什么不安全的呢？

★String和StringBuffer的效率问题

首先说明一点：StringBuffer和StringBuilder可谓双胞胎，StringBuilder是1.5新引入的，其前身就是StringBuffer。StringBuilder的效率比StringBuffer稍高，如果不考虑线程安全，StringBuilder应该是首选。另外，JVM运行程序主要的时间耗费是在创建对象和回收对象上。



(1) String常量与String变量的"+"操作比较

▲测试①代码：     (测试代码位置1)  String str="";

(测试代码位置2)  str="Heart"+"Raid";

[耗时：  0ms]

▲测试②代码        (测试代码位置1)  String s1="Heart";

String s2="Raid";

String str="";

(测试代码位置2)  str=s1+s2;

[耗时：  15—16ms]

结论：String常量的“+连接”  稍优于  String变量的“+连接”。

原因：测试①的"Heart"+"Raid"在编译阶段就已经连接起来，形成了一个字符串常量"HeartRaid"，并指向堆中的拘留字符串对象。运行时只需要将"HeartRaid"指向的拘留字符串对象地址取出1W次，存放在局部变量str中。这确实不需要什么时间。

测试②中局部变量s1和s2存放的是两个不同的拘留字符串对象的地址。然后会通过下面三个步骤完成“+连接”：

1、StringBuilder temp=new StringBuilder(s1)，

2、temp.append(s2);

3、str=temp.toString();

我们发现，虽然在中间的时候也用到了append()方法，但是在开始和结束的时候分别创建了StringBuilder和String对象。可想而知：调用1W次，是不是就创建了1W次这两种对象呢？不划算。

但是，String变量的"+连接"操作比String常量的"+连接"操作使用的更加广泛。 这一点是不言而喻的。

(2)String对象的"累+"连接操作与StringBuffer对象的append()累和连接操作比较。

▲测试①代码：     (代码位置1)  String s1="Heart";

String s="";

(代码位置2)  s=s+s1;

[耗时：  4200—4500ms]

▲测试②代码        (代码位置1)  String s1="Heart";

StringBuffer sb=new StringBuffer();

(代码位置2) sb.append(s1);

[耗时：  0ms(当循环100000次的时候，耗时大概16—31ms)]

结论：大量字符串累加时，StringBuffer的append()效率远好于String对象的"累+"连接

原因：测试①中的s=s+s1，JVM会利用首先创建一个StringBuilder，并利用append方法完成s和s1所指向的字符串对象值的合并操作，接着调用StringBuilder的 toString()方法在堆中创建一个新的String对象，其值为刚才字符串的合并结果。而局部变量s指向了新创建的String对象。

因为String对象中的value[]是不能改变的，每一次合并后字符串值都需要创建一个新的String对象来存放。循环1W次自然需要创建1W个String对象和1W个StringBuilder对象，效率低就可想而知了。

测试②中sb.append(s1);只需要将自己的value[]数组不停的扩大来存放s1即可。循环过程中无需在堆中创建任何新的对象。效率高就不足为奇了。

★镜头总结：

(1) 在编译阶段就能够确定的字符串常量，完全没有必要创建String或StringBuffer对象。直接使用字符串常量的"+"连接操作效率最高。

(2) StringBuffer对象的append效率要高于String对象的"+"连接操作。

(3) 不停的创建对象是程序低效的一个重要原因。那么相同的字符串值能否在堆中只创建一个String对象那。显然拘留字符串能够做到这一点，除了程序中的字符串常量会被JVM自动创建拘留字符串之外，调用String的intern()方法也能做到这一点。当调用intern()时，如果常量池中已经有了当前String的值，那么返回这个常量指向拘留对象的地址。如果没有，则将String值加入常量池中，并创建一个新的拘留字符串对象。

参考网址：
http://blog.csdn.net/jason0539/article/details/22914041