【Java】【String类、StringBuilder类、StringBuffer类】简介、API、联系、区别（拼接）

String类

1. String类对象为不可变Unicode字符序列，不可变的原因在于源码中这样描述：

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];

源码中定义了一个final类型的字符数组来存储String类对象，也就是常量(即只能被赋值一次)， 这就是“不可变对象”的典型定义方式，所以不可变。

字符串的引用可以重新赋值 java字符串中任何一个字符（无论中文还是英文）对应16位（两个字节）的定长Unicode编码。

2. 字符串的拼接：

在遇到字符串常量之间的拼接时，编译器会做出优化，即在编译期间就会完成字符串的拼接。这是因为有String常量池的存在。

java为了提高性能，静态字符串（字面量、常量、常量连接的结果）在常量池中创建，并尽量使用同一个对象，重用静态字符串。

对于重复出现的字符串直接量，JVM会首先在常量池中查找，如果存在即返回该对象。

例子：如果用debug工具会发现s1,s2,s3的地址都是一样的，说明他们指向的是同一个对象，而ss是变量连接，会新建一个字符串对象，跟前三个不同。

使用new关键字也会新建一个对象。

因此，在使用==进行String对象之间的比较时，我们需要特别注意

String str = new String("abc");
String str1 = "def";
String str2 = "abc" + "def";	//abcdef
String str3 = "18" + 19;	//1819

String str20 = "a";
String str21 = "b";
String str22 = "ab";
String str23 = "a" + "b";
System.out.println(str22 == str23);//true
String str24 = new String("ab");
System.out.println(str22 == str24);//false

3. 字符串拼接的陷阱

String str8 = "";
for(int i = 0; i < 5000; i++) {
	str8 = str8 + i; //相当于产生了10000个对象
	//经常造成程序崩溃
}

取而代之的做法是：

/**
 1. 使用StringBuilder的append（）进行拼接，效率非常高
 */
StringBuilder sb1 = new StringBuilder("");
for(int i = 0; i < 5000; i++) {
	sb1.append(i);//不需要频繁产生额外的对象
}

4. 常见API
   String类的下述方法能创建并返回一个新的String对象: concat()、 replace()、substring()、 toLowerCase()、 toUpperCase()、trim()。

   提供查找功能的有关方法: endsWith()、 startsWith()、 indexOf()、lastIndexOf()。

   提供比较功能的方法: equals()、equalsIgnoreCase()、compareTo()。

   其它方法: charAt() 、length()。

   其他的基本类型类型向string类型转化:
   String 类别中已经提供了将基本数据型态转换成 String 的 static 方法
   也就是 String.valueOf() 这个参数多载的方法
   有下列几种

String.valueOf(boolean b);// 将 boolean 变量 b 转换成字符串 
String.valueOf(char c);//将 char 变量 c 转换成字符串 
String.valueOf(char[] data);//将 char 数组 data 转换成字符串 
String.valueOf(char[] data, int offset, int count);//将 char 数组 data 中 由 data[offset] 开始取 count 个元素 转换成字符串 
String.valueOf(double d);//将 double 变量 d 转换成字符串 
String.valueOf(float f);//将 float 变量 f 转换成字符串 
String.valueOf(int i);//将 int 变量 i 转换成字符串 
String.valueOf(long l);//将 long 变量 l 转换成字符串 
String.valueOf(Object obj);//将 obj 对象转换成 字符串, 等于 obj.toString() 

由 String 转换成基本数据类型
使用包装类的成员方法

Byte.parseByte(String s);//将 s 转换成 byte 
Byte.parseByte(String s, int radix);//以 radix 为基底 将 s 转换为 byte，比如说 
Byte.parseByte("11", 16) 会得到 17 
Double.parseDouble(String s);//将 s 转换成 double 
Double.parseFloat(String s);//将 s 转换成 float 
Integer.parseInt(String s);//将 s 转换成 int 
Long.parseLong(String s);

StringBuilder、StringBuffer类

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

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

显然，内部也是一个字符数组，但这个字符数组没有用final修饰，随时可以修改。因此，StringBuilder和StringBuffer称之为“可变字符序列”。那两者有什么区别呢?

  1. StringBuffer JDK1.0版本提供的类，线程安全，做线程同步检查， 效率较低。

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

2. API

构造方法
public StringBuilder()构造一个不带任何字符的字符串生成器，初始容量是16个字符

StringBuilder sb = new StringBuilder();

public StringBuilder(String str)  构造一个字符串生成器，并初始化为指定的字符串内容。该字符串生成器的初始容量为 16 加上字符串参数的长度。

StringBuilder sb = new StringBuilder("HelloWorld");

成员方法
重载的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)

public class TestStringBufferAndBuilder 1{
    public static void main(String[] args) {
        /**StringBuilder*/
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 7; i++) {
            sb.append((char) ('a' + i));//追加单个字符
        }
        System.out.println(sb.toString());//转换成String输出
        sb.append(", I can sing my abc!");//追加字符串
        System.out.println(sb.toString());
        /**StringBuffer*/
        StringBuffer sb2 = new StringBuffer("中华人民共和国");
        sb2.insert(0, "爱").insert(0, "我");//插入字符串
        System.out.println(sb2);
        sb2.delete(0, 2);//删除子字符串
        System.out.println(sb2);
        sb2.deleteCharAt(0).deleteCharAt(0);//删除某个字符
        System.out.println(sb2.charAt(0));//获取某个字符
        System.out.println(sb2.reverse());//字符串逆序
    }
}