1. 总观

String 类作为JAVA中最经常使用的一个类，放在了第一位来学习。
String类位于java.lang.String，继承关系为

    public final class String implements java.io.Serializable, Comparable<String>, CharSequence

其中继承了三个接口

• Serializable：代表序列化
• Comparable： 实现了Comparable接口，用于比较大小
• CharSequence： 这个接口是一个只读的字符序列。包括length(), charAt(int index), subSequence(int start, int end)这几个API接口

2. 属性

    private final char value[];
    private int hash;
    public static final Comparator<String> CASE_INSENSITIVE_ORDER
        = new CaseInsensitiveComparator();

• 可以看出String类型本身是由char数组来存储的，其中获取长度以及一些charAt操作本质上就是数组的一些操作
• CASE_INSENSITIVE_ORDER这是内部类CaseInsensitiveComparator的实例对象，用于进行忽略大小写的比较
• 内部类CaseInsensitiveComparator其实现为：

       public int compare(String s1, String s2) {
           int n1 = s1.length();
           int n2 = s2.length();
           int min = Math.min(n1, n2);
           for (int i = 0; i < min; i++) {
               char c1 = s1.charAt(i);
               char c2 = s2.charAt(i);
               if (c1 != c2) {
                   c1 = Character.toUpperCase(c1);
                   c2 = Character.toUpperCase(c2);
                   if (c1 != c2) {
                       c1 = Character.toLowerCase(c1);
                       c2 = Character.toLowerCase(c2);
                       if (c1 != c2) {
                           // No overflow because of numeric promotion
                           return c1 - c2;
                       }
                   }
               }
           }
           return n1 - n2;
       }
  

可以看出在compare方法中进行了大小写的转换来比较

3. 构造方法

String的构造方法还是比较多的

 public String() {
     this.value = "".value;
 }
 public String(String original) {
     this.value = original.value;
     this.hash = original.hash;
 }
 public String(char value[]) {
     this.value = Arrays.copyOf(value, value.length);
 }
 public String(char value[], int offset, int count) {
     if (offset < 0) {
         throw new StringIndexOutOfBoundsException(offset);
     }
     if (count <= 0) {
         if (count < 0) {
             throw new StringIndexOutOfBoundsException(count);
         }
         if (offset <= value.length) {
             this.value = "".value;
             return;
         }
     }
     // Note: offset or count might be near -1>>>1.
     if (offset > value.length - count) {
         throw new StringIndexOutOfBoundsException(offset + count);
     }
     this.value = Arrays.copyOfRange(value, offset, offset+count);
 }
 public String(StringBuffer buffer) {
     synchronized(buffer) {
         this.value = Arrays.copyOf(buffer.getValue(), buffer.length());
     }
 }
 public String(StringBuilder builder) {
     this.value = Arrays.copyOf(builder.getValue(), builder.length());
 }

• 可以看到String支持多种参数（String，char[]，byte[]）的构造方法，其中参数为char[]数组时，通过参数offest和count来选择偏移量以及初始化位数。
• 其中参数为char[]时，通过验证最后通过Arrays.copyOfRange(value, offset, offset+count)进行赋值，这里涉及到了关于Arrays类的操作，以后会学到其源码，值得注意的时他的参数，第三个参数为offset+count这里就代表着传递参数为终止位置。
• 另外支持StringBuffer和stringBuilder类型进行赋值，方法为this.value = Arrays.copyOf(buffer.getValue(), buffer.length())，第二个参数代表全部的意思。
• 在StringBuffer的构造方法中，会有synchronized关键字，因为StringBuffer不是线程安全的，所以在进行赋值时，需要给对象加上同步锁，以保证同步。

4. 基本方法

• 一些经常用到的方法

   public int length() {
       return value.length;
   }
   public boolean isEmpty() {
       return value.length == 0;
   }
   public char charAt(int index) {
       if ((index < 0) || (index >= value.length)) {
           throw new StringIndexOutOfBoundsException(index);
       }
       return value[index];
   }
  

  • 这些本质上就是一些数组的取长度，判空，取值