Java/String、StringBuffer和StringBuilder类

String类

String 类对象代表不可变的Unicode字符序列，打开String类的源码会发现字符串内容全部存储到value[]数组中，而变量value是final类型的，也就是常量(即只能被赋值一次)。 这就是“不可变对象”的典型定义方式。
1.substring()方法
substring()方法是对字符串的截取操作，但本质是读取原字符串内容生成了新的字符串。

	String s1 = "abcdef";
	String s2 = s1.substring(2,4);//2——4含头不含尾
	System.out.println(Integer.toHexString(s1.hashCode()));
	//ab199863
	System.out.println(Integer.toHexString(s2.hashCode()));
	//c61

hashcode是jdk根据对象的地址或者字符串或者数字算出来的int类型的数值。

2.字符串常量拼接时的优化
在遇到字符串常量之间的拼接时，编译器会做出优化，即在编译期间就会完成字符串的拼接，编译的时候不知道变量中存储的是什么时，没办法在编译的时候优化。在使用==进行String对象之间的比较时，需要特别注意。

	String a = "hello";
	String b = "world";
	String c1 = a+b;
	String c2 = "hello"+"world";
	String d = "helloworld";
	 //编译器做了优化,直接在编译的时候将字符串进行拼接
	System.out.println(c2 == d);//true
	System.out.println(c2.equals(d));///true
	编译的时候不知道变量中存储的是什么,所以没办法在编译的时候优化
	System.out.println(c1 == d);//false
	System.out.println(c1.equals(d));//true

StringBuffer和StringBuilder

StringBuffer和StringBuilder非常类似，均代表可变的字符序列。 这两个类都是抽象类AbstractStringBuilder的子类，内部也是一个字符数组，但这个字符数组没有用final修饰，随时可以修改。因此，StringBuilder和StringBuffer称之为“可变字符序列”。
区别：

1. StringBuffer JDK1.0版本提供的类，线程安全，做线程同步检查， 效率较低。
2. StringBuilder JDK1.5版本提供的类，线程不安全，不做线程同步检查，因此效率较高。 建议采用该类。

常用方法列表：

1. 重载的public StringBuilder append(…)方法
   可以为该StringBuilder 对象添加字符序列，仍然返回自身对象。
2. 方法 public StringBuilder delete(int start,int end)
   可以删除从start开始到end-1为止的一段字符序列，仍然返回自身对象。
3. 方法 public StringBuilder deleteCharAt(int index)
   移除此序列指定位置上的 char，仍然返回自身对象。
4. 重载的public StringBuilder insert(…)方法
   可以为该StringBuilder 对象在指定位置插入字符序列，仍然返回自身对象。
5. 方法 public StringBuilder reverse()
   用于将字符序列逆序，仍然返回自身对象。
6. 方法 public String toString() 返回此序列中数据的字符串表示形式。
7. 和 String 类含义类似的方法。

基本用法示例：

	//StringBuilder
	StringBuilder ss1 = new StringBuilder();
	for(int i = 0;i<7;i++){
		ss1.append((char)('a'+i));
	}
	System.out.println(ss1.toString());//abcdefg
	ss1.append(",I can sing my abc");
	System.out.println(ss1.toString());//abcdefg,I can sing my abc
	//StringBuffer
	StringBuffer ss2 = new StringBuffer("ice cream");
	ss2.insert(0, "love").insert(0, "I");//插入字符串
	System.out.println(ss2.toString());//Iloveice cream
	ss2.delete(0, 2);//删除字符串
	System.out.println(ss2.toString());//oveice cream
	ss2.deleteCharAt(0).deleteCharAt(0);//删除某个字符
	System.out.println(ss2.toString());//eice cream
    System.out.println(ss2.charAt(0));//获取某个字符,e
    System.out.println(ss2.reverse());//字符串逆序,maerc ecie

不可变和可变字符序列使用陷阱

一句话总结：循环莫用String

String一经初始化后，就不会再改变其内容了。对String字符串的操作实际上是对其副本(原始拷贝)的操作，原来的字符串一点都没有改变。比如：
String s =“a”; 创建了一个字符串
s = s+“b”; 实际上原来的"a"字符串对象已经丢弃了，现在又产生了另一个字符串s+“b”(也就是"ab")。 如果多次执行这些改变串内容的操作，会导致大量副本字符串对象存留在内存中，降低效率。如果这样的操作放到循环中，会极大影响程序的时间和空间性能，甚至会造成服务器的崩溃。
相反，StringBuilder和StringBuffer类是对原字符串本身操作的，可以对字符串进行修改而不产生副本拷贝或者产生少量的副本。因此可以在循环中使用。

    /**使用String进行字符串的拼接*/
    String str8 = "";
    //本质上使用StringBuilder拼接, 但是每次循环都会生成一个StringBuilder对象
    long num1 = Runtime.getRuntime().freeMemory();//获取系统剩余内存空间
    long time1 = System.currentTimeMillis();//获取系统的当前时间
    for (int i = 0; i < 5000; i++) {
        str8 = str8 + i;//相当于产生了10000个对象
    }
    long num2 = Runtime.getRuntime().freeMemory();
    long time2 = System.currentTimeMillis();
    System.out.println("String占用内存 : " + (num1 - num2));//5869264
    System.out.println("String占用时间 : " + (time2 - time1));//65
    /**使用StringBuilder进行字符串的拼接*/
    StringBuilder sb1 = new StringBuilder("");
    long num3 = Runtime.getRuntime().freeMemory();
    long time3 = System.currentTimeMillis();
    for (int i = 0; i < 5000; i++) {
        sb1.append(i);
    }
    long num4 = Runtime.getRuntime().freeMemory();
    long time4 = System.currentTimeMillis();
    System.out.println("StringBuilder占用内存 : " + (num3 - num4));//0
    System.out.println("StringBuilder占用时间 : " + (time4 - time3));//1