1. Char

1. String 底层实现为 char[]----->private final char value[]//char[] 数组
2. String类为final类，也就是无法通过子类去继承。（final修饰的方法无法复写)

2. String

2.1 String 实现了接口列表

    1.1 java.io.Serialliable 序列化
    1.2 Comparable<String>---->public int compareTo(String)  此接口用来设置排序的规则
    1.3 CharSequence

2.2 String 内部实现

    2.1  private final char value[];//使用字符数组进行存储
    2.2  private int hash;//缓存字符串的哈希值

2.3 String 方法

    3.1 String的构造方法中，涉及charset，使用到了StringCode类以及使用Arrays.copyof() 通过对char数组进行拷贝
    

3. StringBuilder

3.1. StringBuilder

A mutable sequence of characters.（可变序列序列），but with no guarantee of synchronization(但是无法保证同步)，used by a single thread,it will be faster under most implementation.

3.2 StringBuilder 同样为final类，无法通过子类继承去修改实现,继承AbstractStringBuilder,

实现的接口列表
    3.2.1 java.io.Serializable 序列化
    3.2.2 CharSequence 
继承AbstartcStringBuilder抽象类
    3.2.3 数据使用char[] value,默认实现大小16
    3.2.4 StringBuilder 方法中大部分实现均通过super关键字，使用父类AbstractStringBuilder父类实现

4. StringBuffer

4.1 StringBuffer

A thread -safe,mutalble sequence of characrters,A String Buffer is like a String ,but can be modified,线程安全的可变字符序列

4.2 final类，继承AbstarctStringBuilder,实现Serializablel以及CharSequence接口

4.2.1 线程安全体现的所有的public方法均使用 synchronized 同步关键字来进行保证
4.2.2 toStringCache 使用 trasition 关键字修饰，禁止序列化，同时每次方法调用时都会将其置为空，同时toString()方法调用时，会通过Arrays.copyOfRange来进行copy

5 参照

源码

6.延申知识

### 1. java.lang.Comparable的使用

    o:specified object
    return:
    a negative integer  less than 
    zero                equal to
    a positive integer  greater than 

    public int compareTo(T o);

    查看String的源码发现实现此接口，String的比大小规则:两个字符串均从第一个字符起，比较字符的Unicode Value的大小
    
public int compareTo(String anotherString) {
    int len1 = value.length;
    int len2 = anotherString.value.length;
    int lim = Math.min(len1, len2);
    char v1[] = value;
    char v2[] = anotherString.value;

    int k = 0;
    while (k < lim) {
        char c1 = v1[k];
        char c2 = v2[k];
        if (c1 != c2) {
            return c1 - c2;
        }
        k++;
    }
    return len1 - len2;
}

### 2. 其他地方的使用
    Lists (and arrays) of objects that implement this interface can be sorted automatically by Collection#sort(list) Collections.sort And Arrays.srot(Object[]) Arrays.sort.
    这里提供集合对象的排序可以自动使用2个实现。

    Collections.class
    
public static <T extends Comparable<? super T>> void sort(List<T> list) {
    list.sort(null);
}

    List.class
    
@SuppressWarnings({"unchecked", "rawtypes"})
default void sort(Comparator<? super E> c) {
    Object[] a = this.toArray();
    Arrays.sort(a, (Comparator) c);
    ListIterator<E> i = this.listIterator();
    for (Object e : a) {
        i.next();
        i.set((E) e);
    }
}
    Arrays.class
    ```

        public static <T> void sort(T[] a, Comparator<? super T> c) {
            if (c == null) {
                sort(a);
            } else {
            if (LegacyMergeSort.userRequested)
                legacyMergeSort(a, c);
            else
                TimSort.sort(a, 0, a.length, c, null, 0, 0);
            }
        }

    ```     
### 3.CharSequence
    3.1简介
    <tt>CharSequence</tt> is a readable sequence of <code>char</code> values. This interface provides uniform, read-only access to many different kinds of <code>char</code> sequences. 
    此接口提供对于char的可读序列，可以用来提供统一，仅读 对于各种各样的char序列(String,StringBuilder,StringBuffer)