Java基础类库中String类常用的方法

        首先String有16个构造函数，这里先不一一介绍每个构造函数的使用方式，以后用到的时候再补充。

        然后是一个length()方法：这个方法是用来返回该字符串的长度的，别的不说，先上源码：

public int length() {
        return count;
    }

相信看了源码之后就不需要再多说什么了吧，其实count成员变量记录的是该字符串中所包含的字符的个数。查看源码我们会发现，每个String的底层实现都是一个char类型的数组，这样的话就很好理解count了。

        然后是isEmpty()方法：这个方法不多说，直接上源码：

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

        接着而是charAt(int index)方法：先上源码：

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

该方法会返回字符串中指定位置的字符。注意：在每次返回指定位置字符的时候，源码的设计者都会先判断一个给出的数值是否超出字符串的长度范围，如果经常看Java源码你会发现只要是这类问题，都会首先判断边界问题，这点非常重要。

        接着是equals(Object anObject)方法：这个Java中一个非常典型且普遍的方法，也是非常重要的一个方法，源码如下：

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;
    }

该方法会首先用“==”判断两个引用变量是否会指向同一个对象。如果不是则逐一判断两个字符串对象相同位置的字符是否相同，如果每个相同位置上的字符都相同则返回true，否则返回false。看了源码就会发现，底层就是字符数组的判断。

        然后是跟equals方法配对使用hashCode()方法：该方法不做过多解释，直接贴源码：

public int hashCode() {
	int h = hash;
	if (h == 0) {
	    int off = offset;
	    char val[] = value;
	    int len = count;

            for (int i = 0; i < len; i++) {
                h = 31*h + val[off++];
            }
            hash = h;
        }
        return h;
    }

        然后一个很重要的方法是compareTo(String)：我们知道，String对象是可以直接用在集合排序中的，因为它实现了该方法，源码如下：

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 c2 = v2[k];
		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;
    }

看了源码我们发现，底层其实还是字符数组的比较，该方法返回的是一个int型的值。

        接着是split(String,int)方法：源码如下，

 public String[] split(String regex, int limit) {
	return Pattern.compile(regex).split(this, limit);
    }

        再接着是trim()方法：该方法会返回一个去掉该字符串首位的空格的字符串，源码如下，

public String trim() {
	int len = count;
	int st = 0;
	int off = offset;      /* avoid getfield opcode */
	char[] val = value;    /* avoid getfield opcode */

	while ((st < len) && (val[off + st] <= ' ')) {
	    st++;
	}
	while ((st < len) && (val[off + len - 1] <= ' ')) {
	    len--;
	}
	return ((st > 0) || (len < count)) ? substring(st, len) : this;
    }

        然后是一些关于字符在字符串中相对位置，字符存在与否判断、替换的方法，因为都是跟底层的字符数组相关的操作，所以这里就不一一贴出来讲了，用兴趣的可以直接看源码。还有一些对字符串进行格式化的方法，由于还没看明白所以这里先不说。

        写这些的原因其实很简单，因为我是做开发的，但是目前有没有这么多的开发任务分配下来，所以就想趁着这段时间学习一下Java的底层代码。是自己保持一个编程的热度。