String jdk源码查看 博客分类： java JDKJ#

String: 
  String共有15个构造函数 可以有string ,byte,char,stringbuffer,int
  String类使用了final修饰符：final类不能被继承，因此final类的成员方法没有机会被覆盖，默认都是final的。在设计类时候，如果这个类不需要有子类，类的实现细节不允许改变，并且确信这个类不会载被扩展，那么就设计为final类 如果一个类不允许其子类覆盖某个方法，则可以把这个方法声明为final方法。
使用final方法的原因有二：
第一、把方法锁定，防止任何继承类修改它的意义和实现。
第二、高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。

  实现了Serializable, Comparable<String>, CharSequence接口
    Comparable<T>: compareTo()
    在string的compareTo实现中:
      //anotherString 比较的字符串
       public int compareTo(String anotherString) {
int len1 = count; //原对象的长度
int len2 = anotherString.count; //比较对象的长度
int n = Math.min(len1, len2); //判断谁的长度小一点
char v1[] = value; //原对象的值
char v2[] = anotherString.value; //比较对象的值
int i = offset;  //原始对象初始值
int j = anotherString.offset; //比较对象的初始值

if (i == j) {
    int k = i;
    int lim = n + i;
    while (k < lim) {
char c1 = v1[k]; //获得原对象char
char c2 = v2[k]; //获得比较对象的char
if (c1 != c2) {  //原始对象和比较对象是否相等
    return c1 - c2; //不相等直接返回比较的结果
}
k++;
    }
} else {  //当俩个初始位移量不相等时
    while (n-- != 0) {
char c1 = v1[i++];
char c2 = v2[j++];
if (c1 != c2) {
    return c1 - c2;
}
    }
}
return len1 - len2; //原始对象和比较对象的长度之差 如果为0就表示相等
    }   
   CharSequence:
      length() 在string中的实现
        public int length() {  //返回字符串的长度
        return count;
      }
     charAt()在string中的实现 
     public char charAt(int index) { //返回改索引的字符
        if ((index < 0) || (index >= count)) {
            throw new StringIndexOutOfBoundsException(index); //抛出字符串索引超出异常
          
        }
        return value[index + offset];
    }
   subSequence():在string中的实现
    public CharSequence subSequence(int beginIndex, int endIndex) {
        return this.substring(beginIndex, endIndex);
    }


  
string中的substring方法实现:
    public String substring(int beginIndex, int endIndex) {
if (beginIndex < 0) {
    throw new StringIndexOutOfBoundsException(beginIndex);
}
if (endIndex > count) {
    throw new StringIndexOutOfBoundsException(endIndex);
}
if (beginIndex > endIndex) {
    throw new StringIndexOutOfBoundsException(endIndex - beginIndex);
}
return ((beginIndex == 0) && (endIndex == count)) ? this :
    new String(offset + beginIndex, endIndex - beginIndex, value); //从中可以看出 当我们使用的substring方法时还是重新new 对象所有效率不是太高.
    }

  toString()在string类中的实现
    public String toString() { //返回当前的对象
return this;
    }

   indexOf()在string类中的实现:
   static int indexOf(char[] source, int sourceOffset, int sourceCount,
                       char[] target, int targetOffset, int targetCount,
                       int fromIndex) {
if (fromIndex >= sourceCount) {
            return (targetCount == 0 ? sourceCount : -1);
}
    if (fromIndex < 0) {
        fromIndex = 0;
    }
if (targetCount == 0) {
    return fromIndex;
}

        char first  = target[targetOffset];
        int max = sourceOffset + (sourceCount - targetCount);

        for (int i = sourceOffset + fromIndex; i <= max; i++) {
            /* Look for first character. */
            if (source[i] != first) {
                while (++i <= max && source[i] != first);
            }

            /* Found first character, now look at the rest of v2 */
            if (i <= max) {
                int j = i + 1;
                int end = j + targetCount - 1;
                for (int k = targetOffset + 1; j < end && source[j] ==
                         target[k]; j++, k++);

                if (j == end) {
                    /* Found whole string. */
                    return i - sourceOffset;
                }
            }
        }
        return -1;
    }

  String类中的equlas()
   public boolean equals(Object anObject) {
if (this == anObject) { //如果是对象 直接判断两个对象引用是否相等
    return true;
}
if (anObject instanceof String) { //是字符串
    String anotherString = (String)anObject;
    int n = count;
    if (n == anotherString.count) {
char v1[] = value;
char v2[] = anotherString.value;
int i = offset;
int j = anotherString.offset;
while (n-- != 0) {
    if (v1[i++] != v2[j++])
return false;
}
return true;
    }
}
return false;
    }

讲讲Object类中的equlas()
  public boolean equals(Object obj) { //直接比较的是两个对象的引用是否相等
return (this == obj);
  }
  Object类中的toString()
   public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }


---------------
自定义异常:
StringIndexOutOfBoundsException查看源码可知
public class StringIndexOutOfBoundsException extends IndexOutOfBoundsException {

      public StringIndexOutOfBoundsException() {
super();
    }
      public StringIndexOutOfBoundsException(String s) {
super(s);
    }
     public StringIndexOutOfBoundsException(int index) {
super("String index out of range: " + index);
    }
}

假设现在有一个我们自己的异常可以从Exception继承