字符串相关类、StringBuffer和StringBuilder、不可变和可变字符序列使用陷阱

字符串相关类

String类、StringBuilder类、StringBuffer类是三个字符串相关类。
String类代表不可变序列
StringBuffer类和StringBuilder类代表可变字符序列

String类

String类代表不可变的Unicode字符序列
不可变对象指的是：对象的内部成员变量无法再改变

String类源码：

字符串内容全部存储到value[]数组中，而变量value时final类型的，也就是常量（即只能被赋值一次）

String类的简单实用：

ackage com.wu.test;

/**
 *String类简单使用

 */
import javax.xml.soap.SOAPPart;

public class StringMethod {
    public static void main(String[]args){
        String s1 = new String("abcdef");
        String s2 = s1.substring(2,4);
        //打印；ab199863
        System.out.println(Integer.toHexString(s1.hashCode()));
        //打印；c61,显然s1和s2不是同一个对象
        System.out.println(Integer.toHexString(s2.hashCode()));

    }

}

在遇见字符串常量之间的拼接时。编译器会做出优化，即在编译期间就会完成字符串的拼接。因此，子使用==进行String对象之间的比较时，我们需要特别注意：

package com.wu.test;

import com.sun.org.apache.xpath.internal.objects.XString;

/**
 * 字符串常量拼接时的优化
 */
public class TestString02 {
    public static void main(String[] args) {
//编译器做了优化，直接在编译的时候将字符串进行拼接
        String str1 = "hello" + "java";//相当于str1 = “hello java”
        String str2 = "hellojava";
        System.out.println(str1 == str2);//true
        String str3 = "hello";
        String str4 = "java" ;
//        编译器不知道变量中存储的是什么所以没办法在编译时优化
        String str5 = str3 + str4;
        System.out.println(str2 == str5);//false

    }
}

Stirng字符串常用方法：

/**
 * String类常用方法
 */
public class StringTest03 {
    public static void main(String[] args) {
        int[] a = {1,2,3};
        int[] b = {4,5,6};
        String str1 = "core java";
        String str2 = "Core Java";
       /*创建并返回一个新的String对象：concat（）、repalce()、substring()、
       toLowerCase()、toUpperCase()、trim();*/
        String str3 = str1.concat(str2);
        System.out.println(str1.concat(str2));//concat()方法讲几个字符串连接在一起
        System.out.println(str1.replace("core","king"));//用一个新字符替换原字符串中的旧的字符
        System.out.println(str1.substring(2,3));
//        提供查找功能的有关方法：endsWith()、startsWith()、indexOf()、lastIndexOf():
//        提供比较功能的方法：equals()、equalsIgnore()、startWith()、compareTO():
//        其它方法：charAt()、length()

    }
}

StringBuffer和StringBuilder

StringBuffer和StringBuilder非常类似，均可以待变可变的字符序列。这两个都是抽象类AbstractStringBuilder的子类，方法几乎一模一样。
AbstractStringBuilder源码：

abstract class AbstractStringBuilder implements Appendable, CharSequence {
/**
* The value is used for character storage.
*/
char value[ ];
//以下代码省略
}

显然内部也是一个字符数组，但是这个数组没有final修饰，随时可以更改，因此，StringBuilder和StringBuffer称之为“可变字符序列”

二者区别：
StringBuffer：JDK1,0版本提供的的类***线程安全，做线程同步检查，效率较低***
StringBuilder：JDK1.5版本提供的类，线程不安全，不做线程同步检查，效率较高（一般使用这个）

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

StringBuffer和StringBuilder基本用法：

/**
 * StringBuffer/StringBuilder基本用法
 * @author WY
 *
 */
public class TestString {
	public static void main(String[] args) {
		String str = "aabbcc"; //不可变序列
		StringBuffer sb1 = null;//可变序列，线程安全，但是效率低
		StringBuilder sb2 = null;//可变序列，线程不安全，但是效率高（多数情况下用它）
		
		
		sb2 = new StringBuilder("wu");
		sb2.append(123);
		sb2.append(456);
		System.out.println(sb2);
		sb2.append("aa").append("bbb").append("cccc");
		System.out.println(sb2);
		
		for(int i=0; i<7;i++){
			sb2.append((char)('a' + i));//追加单个字符
		

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

String使用陷阱：

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

mport sun.util.resources.ga.LocaleNames_ga;

/**
 * String和StringBuilder在字符串频繁修改室的效率比较测试
 */
public class Test04 {
    public static void main(String[] args) {

        /*使用String进行字符拼接*/

        String str8 = "";
        long num1 = Runtime.getRuntime().freeMemory();//获取当前时间系统内存空间
        long time1 =    System.currentTimeMillis();//获取系统当前时间
        for(int i=0;i<5000;i++){
            str8 = str8+i; //相当于产生10000个对象（由于String是不可变字符序列）
        }
        long num2 = Runtime.getRuntime().freeMemory();
        long time2 = System.currentTimeMillis();
        System.out.println("String占用内存："+(num1-num2));
        System.out.println("String占用时间："+(time2-time1));

        /*使用StringBuilder进行字符拼接*/

        StringBuilder sb1 = new StringBuilder("");
        long num3 = Runtime.getRuntime().freeMemory();
        long time3 = System.currentTimeMillis();
        for(int i=0;i<5000;i++){
            sb1.append(i); //相当于sb1 = sb1+i;(StringBuilder属于可变序列所以只有产生一个对象)
        }
        long num4 = Runtime.getRuntime().freeMemory();
        long time4 = System.currentTimeMillis();
        System.out.println("StringBuilder占用内存："+(num3-num4));
        System.out.println("StringBuilder占用时间"+(time4-time3));
    }
}

要点：
string：不可变序列
StringBuilder：可变序列，线程不安全，但是效率高（一般用他）。
StringBuffer：可变序列，线程安全，但是效率低。