上一节我们主要讲了String类的一些不是很常用的方法，其中需要掌握的如下，我就不再赘述了
public int length()
public boolean isEmpty()
public byte[] getBytes()
public byte[] getBytes(String charsetName)
public char charAt(int index)
public boolean equals(Object anObject)
public boolean equalsIgnoreCase(String anotherString)
继续今天的内容
/*
* String实现接口Comparable中的compareTo方法，通过源码我们可以看出s1.compareTo(s2)依次拿出s1和s2的第k个字符进行比较
* 如果某两个不相等，则返回这两个字符的差：c1-c2（ps：这里你需要知道java中byte、short、char在参与运算的时候将自动转换为int类型，所以最后返回的是int类型）
* 最后我们得出结论：
* 返回值是0，则两个字符串相等
*/
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;
} /*
* Comparator是一个比较器，String采用成员内部类的形式定义了一个比较器，comparator和comparable一时半会也讲不清楚
* 这里你只需要知道二者都是用于比较的，comparable比较的是自然排序(其实所谓的自然排序也是程序猿规定好的)，比较简单，大部分是内置的，比如说String和Integer等类都有
* 而comparator是比较一些 比较复杂的，用户自己定义的，比如说下面的不区分大小写的比较就是用comparator实现的。仔细看源代码很简单的。
*/
public static final Comparator<String> CASE_INSENSITIVE_ORDER = new CaseInsensitiveComparator(); private static class CaseInsensitiveComparator implements Comparator<String>, java.io.Serializable {
// use serialVersionUID from JDK 1.2.2 for interoperability
private static final long serialVersionUID = 8575799808933029326L; 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;
} //替换反序列化的对象
private Object readResolve() {
return CASE_INSENSITIVE_ORDER;
}
} /*
* String的另一个比较，也就是不区分大小写的比较，内部封装着comparator的实现类的对象
*
* 总结：String有两种比较方式
* 1.compareTo 按照自然顺序比较，区分大小写
* 2.compareToIgnoreCase 不区分大小写的比较
* 虽然二者方法名很像，但是实现原理完全不一样！！！！
*/
public int compareToIgnoreCase(String str) {
return CASE_INSENSITIVE_ORDER.compare(this, str);
} /*
* 测试两个字符串区域是否相等，还记得吗？equalsIgnoreCase方法的内部其实使用的就是regionMatches
*/
public boolean regionMatches(int toffset, String other, int ooffset, int len) {
char ta[] = value;
int to = toffset;
char pa[] = other.value;
int po = ooffset;
// Note: toffset, ooffset, or len might be near -1>>>1.
if ((ooffset < 0) || (toffset < 0) || (toffset > (long) value.length - len)
|| (ooffset > (long) other.value.length - len)) {
return false;
}
while (len-- > 0) {
if (ta[to++] != pa[po++]) {
return false;
}
}
return true;
} /*
*
*/
public boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len) {
char ta[] = value;
int to = toffset;
char pa[] = other.value;
int po = ooffset;
// Note: toffset, ooffset, or len might be near -1>>>1.
if ((ooffset < 0) || (toffset < 0) || (toffset > (long) value.length - len)
|| (ooffset > (long) other.value.length - len)) {
return false;
}
while (len-- > 0) {
char c1 = ta[to++];
char c2 = pa[po++];
if (c1 == c2) {
continue;
}
if (ignoreCase) { char u1 = Character.toUpperCase(c1);
char u2 = Character.toUpperCase(c2);
if (u1 == u2) {
continue;
} if (Character.toLowerCase(u1) == Character.toLowerCase(u2)) {
continue;
}
}
return false;
}
return true;
} /*
* 从字符串开始位置toffset去匹配目标字符串prefix，很常用的方法，代码原理很简单
* startsWith(String prefix, int toffset)
* startsWith(String prefix)
* endsWith(String prefix)
*/
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 startsWith(String prefix) {
return startsWith(prefix, 0);
} public boolean endsWith(String suffix) {
return startsWith(suffix, value.length - suffix.value.length);
} /*
* String重写了equals,也重写了hashCode,这里我解释一下Object中的hashCode返回的是什么，因为是原生方法，所以源代码当中并没有
* 但是自己去试试就知道是什么了，创建一个类（不重写hashCode）并实例化，输出的是一个int类型的，然后重写再输出得到的还是相同长度的int类型，
*
*/
public int hashCode() {
int h = hash;
if (h == 0 && value.length > 0) {
char val[] = value; for (int i = 0; i < value.length; i++) {
h = 31 * h + val[i];
}
hash = h;
}
return h;
}