String

1.类声明：

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

2.变量：

private final char value[];//存储字符串public static final Comparator<String> CASE_INSENSITIVE_ORDER                                         = new CaseInsensitiveComparator();//静态内部类，比较器

3.方法：

  public String(char value[]) {        this.value = Arrays.copyOf(value, value.length);    }    //通过String构造String     public String(String original) {        this.value = original.value;        this.hash = original.hash;    }    //通过int数组构造，考虑每个int是不是一个char，是不是一个Unicode，如果都不是则抛出异常     public String(int[] codePoints, int offset, int count) {        if (offset < 0) {            throw new StringIndexOutOfBoundsException(offset);        }        if (count <= 0) {            if (count < 0) {                throw new StringIndexOutOfBoundsException(count);            }            if (offset <= codePoints.length) {                this.value = "".value;                return;            }        }        // Note: offset or count might be near -1>>>1.        if (offset > codePoints.length - count) {            throw new StringIndexOutOfBoundsException(offset + count);        }        final int end = offset + count;        // Pass 1: Compute precise size of char[]        int n = count;        for (int i = offset; i < end; i++) {            int c = codePoints[i];            if (Character.isBmpCodePoint(c))                continue;            else if (Character.isValidCodePoint(c))                n++;//如果不是char,但是是unicode字符，则添加一个字符存储            else throw new IllegalArgumentException(Integer.toString(c));        }        // Pass 2: Allocate and fill in char[]        final char[] v = new char[n];        for (int i = offset, j = 0; i < end; i++, j++) {            int c = codePoints[i];            if (Character.isBmpCodePoint(c))                v[j] = (char)c;            else                Character.toSurrogates(c, v, j++);//将一个int存储为2个字符        }        this.value = v;    }    //通过字节数组进行构造，调用SringCoding将其解码为字符      public String(byte bytes[], int offset, int length, Charset charset) {        if (charset == null)            throw new NullPointerException("charset");        checkBounds(bytes, offset, length);        this.value =  StringCoding.decode(charset, bytes, offset, length);    }    //通过StringBuffer构造，加入同步，多线程可以同时使用同一个buffer进行构造    public String(StringBuffer buffer) {        synchronized(buffer) {            this.value = Arrays.copyOf(buffer.getValue(), buffer.length());        }    }    //通过StringBuilder进行构造    public String(StringBuilder builder) {        this.value = Arrays.copyOf(builder.getValue(), builder.length());    }    //charAt方法直接返会下标位置的字符       public char charAt(int index) {        if ((index < 0) || (index >= value.length)) {            throw new StringIndexOutOfBoundsException(index);        }        return value[index];    }    //复制字符串到字符数组指定位置    void getChars(char dst[], int dstBegin) {        System.arraycopy(value, 0, dst, dstBegin, value.length);    }    //将字符串编码为指定字符集的字节数组       public byte[] getBytes(String charsetName)            throws UnsupportedEncodingException {        if (charsetName == null) throw new NullPointerException();        return StringCoding.encode(charsetName, value, 0, value.length);    }    //覆写equals方法，同一个对象，或者每个字符都相等，才返回true        public boolean equals(Object anObject) {        if (this == anObject) {            return true;        }        if (anObject instanceof String) {            String anotherString = (String)anObject;            int n = value.length;            if (n == anotherString.value.length) {                char v1[] = value;                char v2[] = anotherString.value;                int i = 0;                while (n-- != 0) {                    if (v1[i] != v2[i])                        return false;                    i++;                }                return true;            }        }        return false;    }    //将字符串与CharSequence比较，若是StringBuffer，还需要加锁比较，对StringBuffer对象加锁    public boolean contentEquals(CharSequence cs) {        // Argument is a StringBuffer, StringBuilder        if (cs instanceof AbstractStringBuilder) {            if (cs instanceof StringBuffer) {                synchronized(cs) {                   return nonSyncContentEquals((AbstractStringBuilder)cs);                }            } else {                return nonSyncContentEquals((AbstractStringBuilder)cs);            }        }        // Argument is a String        if (cs instanceof String) {            return equals(cs);        }        // Argument is a generic CharSequence        char v1[] = value;        int n = v1.length;        if (n != cs.length()) {            return false;        }        for (int i = 0; i < n; i++) {            if (v1[i] != cs.charAt(i)) {                return false;            }        }        return true;    }    //跟另一个String比较       public boolean equalsIgnoreCase(String anotherString) {        return (this == anotherString) ? true                : (anotherString != null)                && (anotherString.value.length == value.length)                && regionMatches(true, 0, anotherString, 0, value.length);    }    //覆盖Comparable接口方法cmpareTo,按字典顺序比较        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;    }    //通过比较器比较（忽视大小写）    public int compareToIgnoreCase(String str) {        return CASE_INSENSITIVE_ORDER.compare(this, str);    }    //在某个下标是否以某个字符串开始       public boolean startsWith(String prefix, int toffset) {        char ta[] = value;        int to = toffset;        char pa[] = prefix.value;        int po = 0;        int pc = prefix.value.length;        // Note: toffset might be near -1>>>1.        if ((toffset < 0) || (toffset > value.length - pc)) {            return false;        }        while (--pc >= 0) {            if (ta[to++] != pa[po++]) {                return false;            }        }        return true;    }    //转换为在某个位置以什么字符串开始     public boolean endsWith(String suffix) {        return startsWith(suffix, value.length - suffix.value.length);    }    //从fromIndex往前找，找到第一个ch则返回下标    public int lastIndexOf(int ch, int fromIndex) {        if (ch < Character.MIN_SUPPLEMENTARY_CODE_POINT) {            // handle most cases here (ch is a BMP code point or a            // negative value (invalid code point))            final char[] value = this.value;            int i = Math.min(fromIndex, value.length - 1);            for (; i >= 0; i--) {                if (value[i] == ch) {                    return i;                }            }            return -1;        } else {            return lastIndexOfSupplementary(ch, fromIndex);        }    }    //如果常量池中已经有了这个字符串，返回它的引用，否则将这个字符串加入常量池同时返回引用       public native String intern();       //正则匹配       public boolean matches(String regex) {        return Pattern.matches(regex, this);    }