JDK源码-String

1，字符串，String类。

    -1，字符串是常量，他们的值在创建后不能更改。字符串缓冲区支持可变的字符串。

    -2，String重载了Java中的+操作。

    -3，String对象是不可变的，你可以给一个String对象加任意多的别名。因为String对象具有只读特性，所以指向他的任何引用都不能改变它的值。

2，String类的成员变量

    -1，value 存储字符串的char数组。

 private final char value[];

    -2，offset：存储使用的首元素index。

   /** The offset is the first index of the storage that is used. */
    private final int offset;

    -3，count：String中存储的char数量。

  /** The count is the number of characters in the String. */
    private final int count;

    -4，hash：字符串的hash值。

/** Cache the hash code for the string */
    private int hash; // Default to 0

    -5，

/**
     * Class String is special cased within the Serialization Stream Protocol.
     *
     * A String instance is written initially into an ObjectOutputStream in the
     * following format:
     * <pre>
     *      <code>TC_STRING</code> (utf String)
     * </pre>
     * The String is written by method <code>DataOutput.writeUTF</code>.
     * A new handle is generated to  refer to all future references to the
     * string instance within the stream.
     */
    private static final ObjectStreamField[] serialPersistentFields =
        new ObjectStreamField[0];

3，构造方法。

    -1，String()：构造空的字符串对象。默认内部数组长度为0

 public String() {
	this.offset = 0;
	this.count = 0;
	this.value = new char[0];
    }

    -2，String(String)：使用指定字符串构造String，创建对应字符串的副本，因为字符串是不可变的，所以没必要使用此构造方法。

  public String(String original) {
	int size = original.count;
	char[] originalValue = original.value;
	char[] v;
  	if (originalValue.length > size) {
 	    // The array representing the String is bigger than the new
 	    // String itself.  Perhaps this constructor is being called
 	    // in order to trim the baggage, so make a copy of the array.
            int off = original.offset;
            v = Arrays.copyOfRange(originalValue, off, off+size);
 	} else {
 	    // The array representing the String is the same
 	    // size as the String, so no point in making a copy.
	    v = originalValue;
 	}
	this.offset = 0;
	this.count = size;
	this.value = v;
    }

    -3，String(char[] )：使用char数组构建String

    public String(char value[]) {
	int size = value.length;
	this.offset = 0;
	this.count = size;
	this.value = Arrays.copyOf(value, size);
    }

4，方法：

    -1，length()：返回字符串中字符数。

   public int length() {
        return count;
    }

    -2，isEmpty()：判断字符串是否为空。

  public boolean isEmpty() {
	return count == 0;
    }

    -3，charAt(int)：获取对应索引的字符。

   public char charAt(int index) {
        if ((index < 0) || (index >= count)) {
            throw new StringIndexOutOfBoundsException(index);
        }
        return value[index + offset];
    }

    -4，equalsIgnoreCase(String)：忽略大小写比较两字符串差异。

   public boolean equalsIgnoreCase(String anotherString) {
        return (this == anotherString) ? true :
               (anotherString != null) && (anotherString.count == count) &&
	       regionMatches(true, 0, anotherString, 0, count);//调用此方法
    }

    判断；两字符串中从开始位置到固定长度的字符是否相等。

public boolean regionMatches(boolean ignoreCase, int toffset,
                           String other, int ooffset, int len) {
        char ta[] = value;
        int to = offset + toffset;
        char pa[] = other.value;
        int po = other.offset + ooffset;
        // Note: toffset, ooffset, or len might be near -1>>>1.
        if ((ooffset < 0) || (toffset < 0) || (toffset > (long)count - len) ||
                (ooffset > (long)other.count - len)) {
            return false;
        }
        while (len-- > 0) {
            char c1 = ta[to++];
            char c2 = pa[po++];
            if (c1 == c2) {
                continue;
            }
            if (ignoreCase) {
                // If characters don't match but case may be ignored,
                // try converting both characters to uppercase.
                // If the results match, then the comparison scan should
                // continue.
                char u1 = Character.toUpperCase(c1);
                char u2 = Character.toUpperCase(c2);
                if (u1 == u2) {
                    continue;
                }
                // Unfortunately, conversion to uppercase does not work properly
                // for the Georgian alphabet, which has strange rules about case
                // conversion.  So we need to make one last check before
                // exiting.
                if (Character.toLowerCase(u1) == Character.toLowerCase(u2)) {
                    continue;
                }
            }
            return false;
        }
        return true;
    }

-5，startWith(String, int)：判断字符串是不是从某索引位置以某字符串开始。

    public boolean startsWith(String prefix, int toffset) {
	char ta[] = value;
	int to = offset + toffset;//索引开始位置
	char pa[] = prefix.value;
	int po = prefix.offset;//开始位置
	int pc = prefix.count;//总长度
	// Note: toffset might be near -1>>>1.
	if ((toffset < 0) || (toffset > count - pc)) {
	    return false;
	}
	while (--pc >= 0) {
	    if (ta[to++] != pa[po++]) {
	        return false;
	    }
	}
	return true;
    }

-6，endWith(String)：以某字符串结束。

  public boolean endsWith(String suffix) {
	return startsWith(suffix, count - suffix.count);//获取开始比较位置，然后调用开始比较的方法，开始比较。
    }

-7，startWith(String)：判断字符串是否以某字符串开始。

  public boolean startsWith(String prefix) {
	return startsWith(prefix, 0);
    }