String和StringBuilder和StringBuffer

字符串广泛应用 在Java 编程中，在 Java 中字符串属于对象，Java 提供了 String 类来创建和操作字符串。

String使用final关键字修饰可以知道String是不可变的类，String中字符数组的长度你定义多少，就是多少，不存在字符数组扩容一说。

内部是final修饰的char[] value，表示String类不可被继承，且value只能被初始化一次。这里的value变量其实就是存储了String字符串中的所有字符。

//String
public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
        /** The value is used for character storage. */
    private final char value[];
    public String substring(int beginIndex) {
        if (beginIndex < 0) {
            throw new StringIndexOutOfBoundsException(beginIndex);
        }
        int subLen = value.length - beginIndex;
        if (subLen < 0) {
            throw new StringIndexOutOfBoundsException(subLen);
        }
        return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);
    }
}
//StringBuilder
public final class StringBuilder
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence{
    @Override
    public StringBuilder append(String str) {
        super.append(str);
        return this;
    }
}

查看类

　　java.lang.String ：此类不需要导入。

查看构造方法

　　String() 创建一个空的字符串对象 　　String(String original) 根据字符串来创建一个字符串对象 　　String(char[] value) 通过字符数组来创建字符串对象 　　String(byte[] bytes) 通过字节数组来构造新的字符串对象 　　String(byte[] bytes, int offset, int length) 通过字节数组一部分来构造新的字符串对象

通过构造方法创建

　　通过 new 创建的字符串对象，每一次 new 都会申请一个内存空间，虽然内容相同，但是地址值不同
直接赋值方式创建

　　以“”方式给出的字符串，只要字符序列相同(顺序和大小写)，无论在程序代码中出现几次，JVM 都只会建立一个 String 对象，并在字符串池中维护

public boolean equals (Object anObject) ：将此字符串与指定对象进行比较。
public boolean equalsIgnoreCase (String anotherString) ：将此字符串与指定对象进行比较，忽略大小写。
public boolean contains (CharSequence s) ：判断参数字符串在当前字符串中是否存在(区分大小写)。存在，返回true，否则，返回false。
public boolean endsWith(String suffix) ：测试此字符串是否以指定的后缀结尾(区分大小写)。
public boolean startsWith(String prefix) ：测试此字符串是否以指定的前缀开始(区分大小写)

public int length () ：返回此字符串的长度。
public String concat (String str) ：将指定的字符串连接到该字符串的末尾。
public char charAt (int index) ：返回指定索引处的 char值。
public int indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引。
public int lastIndexOf(String str) ：返回指定子字符串最后一次出现的字符串中的索引。 如果不包含，则返回-1。public String substring (int beginIndex) ：返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。
public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex。

public char[] toCharArray () ：将此字符串转换为新的字符数组。
public byte[] getBytes () ：使用平台的默认字符集将该 String编码转换为新的字节数组。
public String toLowerCase() ：使用默认语言环境的规则将此 String所有字符转换为小写。public String toUpperCase() ：将此 String所有字符转换为大写，使用默认语言环境的规则。
public String replace (CharSequence target, CharSequence replacement) ：将与target匹配的字符串使用replacement字符串替换

public String[] split(String regex) ：将此字符串按照给定的regex（规则）拆分为字符串数组。
public String trim() ：去掉当前字符串的前后空格，并返回一个新字符串，原字符串不变

StringBuffer和StringBuilder二者的源码以及append方法，二者都是AbstractStringBuilder的子类，
也都实现了Serializable（可序列化）和CharSequence（char类型的可读序列）接口，AbstractStringBuilder 
实现了Appendable（长度可增加）和CharSequence接口。

StringBuffer上使用了synchronized 关键字加了同步锁证明它是线程安全的，而StringBuilder没有使用说明是线程不安全的

//StringBuilder
public final class StringBuilder
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence{
    @Override
    public StringBuilder append(String str) {
        super.append(str);
        return this;
    }
}
    
//StringBuffer
 public final class StringBuffer
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence{
    @Override
    private transient char[] toStringCache;
    public synchronized StringBuffer append(String str) {
        toStringCache = null;
        super.append(str);
        return this;
    }
}

//AbstractStringBuilder 
abstract class AbstractStringBuilder implements Appendable, CharSequence{
    char[] value;
    int count;
    AbstractStringBuilder(int capacity) {
        value = new char[capacity];
    }
}
  

    public StringBuilder(int capacity) {
        super(capacity);
    }
        public StringBuilder(String str) {
        super(str.length() + 16);
        append(str);
    }
     public StringBuilder(CharSequence seq) {
        this(seq.length() + 16);
        append(seq);
    }
        @Override
    public StringBuilder append(Object obj) {
        return append(String.valueOf(obj));
    }

    @Override
    public StringBuilder append(String str) {
        super.append(str);
        return this;
    }
      @Override
    public String toString() {
        // Create a copy, don‘t share the array
        return new String(value, 0, count);
    }