[jse] String StringBuffler StringBuilder

String 字符串常量
StringBuffer 字符串变量（线程安全）
StringBuilder 字符串变量（非线程安全）
 简要的说， String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的对象, 因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，那速度是一定会相当慢的。
 而如果是使用 StringBuffer 类则结果就不一样了，每次结果都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，再改变对象引用。所以在一般情况下我们推荐使用 StringBuffer ，特别是字符串对象经常改变的情况下。而在某些特别情况下， String 对象的字符串拼接其实是被 JVM 解释成了 StringBuffer 对象的拼接，所以这些时候 String 对象的速度并不会比 StringBuffer 对象慢，而特别是以下的字符串对象生成中， String 效率是远要比 StringBuffer 快的：
 String S1 = “This is only a” + “ simple” + “ test”;
 StringBuffer Sb = new StringBuilder(“This is only a”).append(“ simple”).append(“ test”);
 你会很惊讶的发现，生成 String S1 对象的速度简直太快了，而这个时候 StringBuffer 居然速度上根本一点都不占优势。其实这是 JVM 的一个把戏，在 JVM 眼里，这个
 String S1 = “This is only a” + “ simple” + “test”; 其实就是：
 String S1 = “This is only a simple test”; 所以当然不需要太多的时间了。但大家这里要注意的是，如果你的字符串是来自另外的 String 对象的话，速度就没那么快了，譬如：
String S2 = “This is only a”;
String S3 = “ simple”;
String S4 = “ test”;
String S1 = S2 +S3 + S4;
这时候 JVM 会规规矩矩的按照原来的方式去做

在大部分情况下 StringBuffer > String
StringBuffer
Java.lang.StringBuffer线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。
可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步，因此任意特定实例上的所有操作就好像是以串行顺序发生的，该顺序与所涉及的每个线程进行的方法调用顺序一致。
StringBuffer 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中。append 方法始终将这些字符添加到缓冲区的末端；而 insert 方法则在指定的点添加字符。
例如，如果 z 引用一个当前内容是“start”的字符串缓冲区对象，则此方法调用 z.append("le") 会使字符串缓冲区包含“startle”，而 z.insert(4, "le") 将更改字符串缓冲区，使之包含“starlet”。
在大部分情况下 StringBuilder > StringBuffer

java.lang.StringBuilde
java.lang.StringBuilder一个可变的字符序列是5.0新增的。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。两者的方法基本相同。

通过非官方试验测试，StringBuilder和StringBuffer的测试总结如下：

1．  为了获得更好的性能，在构造 StirngBuffer 或 StirngBuilder 时应尽可能指定它的容量。当然，如果你操作的字符串长度不超过 16 个字符就不用了。

2．  相同情况下使用 StirngBuilder 相比使用 StringBuffer 仅能获得 10%~15% 左右的性能提升，但却要冒多线程不安全的风险。而在现实的模块化编程中，负责某一模块的程序员不一定能清晰地判断该模块是否会放入多线程的环境中运行，因此：除非你能确定你的系统的瓶颈是在 StringBuffer 上，并且确定你的模块不会运行在多线程模式下，否则还是用 StringBuffer 吧 J

3．  用好现有的类比引入新的类更重要。很多程序员在使用 StringBuffer 时是不指定其容量的（至少我见到的情况是这样），如果这样的习惯带入 StringBuilder 的使用中，你将只能获得 10 ％左右的性能提升（不要忘了，你可要冒多线程的风险噢）；但如果你使用指定容量的 StringBuffer ，你将马上获得 45% 左右的性能提升，甚至比不使用指定容量的 StirngBuilder 都快 30% 左右。

众所周知string对象在java里面是不可变(immutable)的，任何的连接，修改，其实都是在heap里面创建了一个新的string对象，而对原来的string对象是没有任何影响的，它们还是在那里，不曾改变，你只是用它们的字面值去创造了新的strings而已。

string的不可变特性是非常有用的，至少这使得string是绝对的多线程安全的，那么java是怎么对待string对象的呢？是怎么利用string的这个不可变特性去优化内存的使用的呢？

我们从string的两种构造方式说起
String s1 = new String("tubie");
String s2 = "tubie";

有什么两样？两者最后都返回了一个指向字面值为tubie的一个引用，从这个结果来看是一样的，但其实过程和内存的变化都是大大的不同的

前者因为使用了new关键字，这迫使JVM在heap上创建了一个新的string对象，然后把该对象的引用返回，任务结束；
后者因为是"常量"赋值，所以其任务其实多了很多。JVM会首先到一个内部的string pool中找是否有存在相同值的string对象，这个string pool是java.lang.String内部维护的。如果有，就返回池里那个对象的引用，没有就在堆上分配个新的，然后把引用返回给用户的同时把这个新的string，以前没有的string加到池里。

注意第一种方法虽然创建了一个string对象但是并没有放到池里，哪个对内存的利用率高清晰可辨，哪个在调用时的消耗大，做的事情多也清晰可见(哈希做的string pool搜索？)。空间和时间的trade off啊。

所以咯，如果之前string pool中没有"tubie"这个string，那么毫无疑问之前的s1 != s2,当然，equls的值比较是相等的，而这时如果有String s3 = "tubie";那么 S2 == S3是成立的了，因为池里已经加入了s2,并且在创建s3时搜到了。

前面说到用new关键字创建的string对象不会自己加入到string pool里面(在池里的string，有种叫法叫intern strings)，那就要显示的由用户来加入

String sa = new String("Cao Dui");
sa = sa.intern();

这时候Cao Dui就加入到字符串池里面了。
这个intern到底做了哪些事？
首先查看了string pool，有没有一个"Cao Dui"已经加入过了，加入的那个直接返回给sa
不存在就在堆上另外分配一个"Cao Dui"的string对象，把sa指向这个，再把sa放入到池里。
无论是哪种情况，可以肯定的是，第一句的sa和第二句结束时的sa肯定是两个引用了。在这里第一个Cao Dui因为唯一的sa已经不指向它了，所以会很快被GC给回收掉。

我们另外从刚才的过程，intern函数的调用里可以得到一个结论，就是如果s1.equls(s2);则必定有s1.intern() == s2.intern();这时候s1和s2其实已经在这句比较结束后指向同一个已经在string池里面的对象了。

JVM这么做就是因为string的不可变特性。intern函数是一个native函数。

值得一说的是string的连接是创造了一个新的对象的。所以把sa和s1连接下，创建的就是一个完全新的string对象：
Cao Dui tubie

String的设计是一个典型的单一模式

String str1="AAAA"；
String str2="AAAA"；

这生成两个对象吗？
不是。在内存中，这是同一个对象
所以 
if(str1==str2){} 的结果应该是 true


如果要生成不同的对象，就必须
String str1=new String("AAAA")；
String str2=new String("AAAA")；
if(str1==str2){} 的结果应该是 false

用第一种做法虽然变量名变来变去，但内存中对象仍只有一个，这种方法可以有效地节省内存空间和提高运行效率。

由于String具有不变的性质。所以对一长串String中的每一个字符进行操作是比较浪费时间的，对String进行加减删除替换等工作比较耗时，所以后来Sun又推出来StringBuffer方法来做这些事情。
StringBuffer类似于一个char[],
所以对数组无素做遍历，删除，增加，修改，查找等工作是比较快速的，完成后再把StringBuffer可以转化成String

例： 
String a="请输入帐号:";
String b="NNNN";
String c="请输入密码:";
String d="XXXX";
............

一般的做法 String result=a+b+c+d;
结果是正确的，但不是高效的代码！


改良的做法:
StringBuffer buffer=new StringBuffer();
buffer.append(a);
buffer.append(b);
buffer.append(c);
buffer.append(d);
String result=buffer.toString();