前言：他山之石，可以攻玉
(1) String最重要的属性，用来存放字符串，很多String的方法就是通过此操作此字符数组实现的
/** 用来存放字符(s)的值 */ private final char value[];
(2) String类的构造器比较多 列举以下两个
1. public String(char value[], int offset, int count) { //通过char[]创建String对象 offset:开端 count:个数 if (offset < 0) { //offset不能小于0 throw new StringIndexOutOfBoundsException(offset); } if (count <= 0) { if (count < 0) { throw new StringIndexOutOfBoundsException(count); } if (offset <= value.length) { //count=0 若(0<=)offset<=value.length,则string="" this.value = "".value; return; } } // Note: offset or count might be near -1>>>1.
//-1>>>1即Integer.MAX_VALUE -1<<31即Integer.MIN_VALUE if (offset > value.length - count) { //maxIndex = value.length - count throw new StringIndexOutOfBoundsException(offset + count); } this.value = Arrays.copyOfRange(value, offset, offset+count); } 2. public String(int[] codePoints, int offset, int count) { //通过int[]创建String对象 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; } } if (offset > codePoints.length - count) { throw new StringIndexOutOfBoundsException(offset + count); }
final int end = offset + count; //endIndex // 第一遍：计算char[](即value)的精确大小 int n = count; for (int i = offset; i < end; i++) { int c = codePoints[i]; if (Character.isBmpCodePoint(c)) // c >>> 16 == 0 即 c < 2^16 可直接用一个char存储 continue; else if (Character.isValidCodePoint(c)) //c < 1114112 即 c是ASCII码 n++; // count + 1 } // 第二遍：分配/填充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)) //若c是BMP码点，即字符c可直接用一个char来表示 v[j] = (char)c; else Character.toSurrogates(c, v, j++); //在j与j+1索引处写入代理对 } this.value = v; }
第二个构造器示例：
int[] a = {65,97,65536,1114110}; String str = new String(a,0,a.length); System.out.println("str的length值：" + str.length()); System.out.println("str字符串：" + str); System.out.println("str在索引2处的字符：" + str.charAt(2)); System.out.println("str在索引3处的字符：" + str.charAt(3)); 结果： //65536是临界值 str的length值：6 str字符串：Aa???????? str在索引2处的字符：? str在索引3处的字符：?
(4) offsetByCodePoints(int index, int codePointOffset)，从给定的index处偏移codePointOffset个代码点(字符)的索引(结果最大值为length)
public int offsetByCodePoints(int index, int codePointOffset) { if (index < 0 || index > value.length) { //index可为value.length 若codePointOffset>0，则抛出异常 throw new IndexOutOfBoundsException(); } return Character.offsetByCodePointsImpl(value, 0, value.length, index, codePointOffset); }
//Character的类方法: static int offsetByCodePointsImpl(char[]a, int start, int count, int index, int codePointOffset) { int x = index; if (codePointOffset >= 0) { int limit = start + count; int i; for (i = 0; x < limit && i < codePointOffset; i++) { if (isHighSurrogate(a[x++]) && x < limit && isLowSurrogate(a[x])) { //若是代理对的高位，则x+2 x++; } } if (i < codePointOffset) { //若为true,则说明当index<limit，index后字符个数不够(offsetByCodePoints-1)个 throw new IndexOutOfBoundsException(); } } else { int i; for (i = codePointOffset; x > start && i < 0; i++) { //不区别index是否为代理对低位 if (isLowSurrogate(a[--x]) && x > start && isHighSurrogate(a[x-1])) { x--; } } if (i < 0) { //若为true,则说明当start-index中间的字符个数不够offsetByCodePoints个; 若index-1处为代理对高位，则计为一个“字符” throw new IndexOutOfBoundsException(); } } return x; }
(5) getChars(char dst[], int dstBegin) default方法，将this.value复制到dst[]中
void getChars(char dst[], int dstBegin) { System.arraycopy(value, 0, dst, dstBegin, value.length); }
(6) getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) 将string的srcBegin~srcEnd(不含)的字符复制到dst[]以dstBegin索引开始的位置
public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) { if (srcBegin < 0) { //参数检查 throw new StringIndexOutOfBoundsException(srcBegin); } if (srcEnd > value.length) { throw new StringIndexOutOfBoundsException(srcEnd); } if (srcBegin > srcEnd) { throw new StringIndexOutOfBoundsException(srcEnd - srcBegin); } System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin); //String类中大量使用了此方法 }
(7) equals(Object obj) 与指定的对象比较。当且仅当该参数不为 null，且value相同时为true
public boolean equals(Object anObject) { if (this == anObject) { //若地址相同，返回true return true; } if (anObject instanceof String) { //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]) //比较value值 return false; i++; } return true; } } return false; }
(8) contentEquals(CharSequence cs) 与CharSequence接口实现类进行内容比较
public boolean contentEquals(CharSequence cs) { // 参数是 StringBuffer 或 StringBuilder if (cs instanceof AbstractStringBuilder) { if (cs instanceof StringBuffer) { synchronized(cs) { //同步比较 return nonSyncContentEquals((AbstractStringBuilder)cs); } } else { return nonSyncContentEquals((AbstractStringBuilder)cs); } } // 参数类型是String if (cs instanceof String) { return equals(cs); } // 参数是通常的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; }
(9) compareTo(String str) 比较两个字符串
public int compareTo(String anotherString) { int len1 = value.length; int len2 = anotherString.value.length; int lim = Math.min(len1, len2); char v1[] = value; //定义局部变量减少getField操作 char v2[] = anotherString.value; int k = 0; while (k < lim) { char c1 = v1[k]; char c2 = v2[k]; if (c1 != c2) { return c1 - c2; //依次比较，若不同，则返回Unicode值之差 } k++; } return len1 - len2; //若可比较的字符相同，则返回长度差 }
(10) compareToIgnoreCase(String str) 忽略大小写进行比较，通过调用String私有静态final类完成
public int compareToIgnoreCase(String str) { return CASE_INSENSITIVE_ORDER.compare(this, str); } 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) { // 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.
c1 = Character.toLowerCase(c1); c2 = Character.toLowerCase(c2); if (c1 != c2) { // No overflow because of numeric promotion return c1 - c2; } } } } return n1 - n2; } /** Replaces the de-serialized object. */ private Object readResolve() { return CASE_INSENSITIVE_ORDER; } }
(11) indexOf(String str, int f) 从f处开始查找str，通过调用内部静态默认方法实现
public int indexOf(String str, int fromIndex) { return indexOf(value, 0, value.length, str.value, 0, str.value.length, fromIndex); }
static int indexOf(char[] source, int sourceOffset, int sourceCount, //sourceOffset:source(源字符串)开端(索引) char[] target, int targetOffset, int targetCount, int fromIndex) { //fromIndex是相对sourceOffset而言的 if (fromIndex >= sourceCount) { return (targetCount == 0 ? sourceCount : -1); } if (fromIndex < 0) { fromIndex = 0; } if (targetCount == 0) { //若目标字符串为""，则直接返回fromIndex (>=0) return fromIndex; } char first = target[targetOffset]; //target(目标字符串)的开端字符 int max = sourceOffset + (sourceCount - targetCount); //target在source中最大的索引 for (int i = sourceOffset + fromIndex; i <= max; i++) { //从sourceOffset+fromIndex开始遍历，最大至max处 /* 寻找第一个匹配字符的索引 */ if (source[i] != first) { while (++i <= max && source[i] != first); } /* 找到了第一个字符，现在匹配剩下的字符(s) */ 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) { //上面的循环正常结束 /* 找到整个字符串 */ return i - sourceOffset; //返回相对于sourceOffset的索引值 } } } return -1; }
(12) lastIndexOf(String str, int f) 返回f~length中str的最大索引值 通过调用内部静态默认方法实现
public int lastIndexOf(String str, int fromIndex) { return lastIndexOf(value, 0, value.length, str.value, 0, str.value.length, fromIndex); }
static int lastIndexOf(char[] source, int sourceOffset, int sourceCount, char[] target, int targetOffset, int targetCount, int fromIndex) { /* Check arguments; return immediately where possible. For consistency, don't check for null str. */ int rightIndex = sourceCount - targetCount; //最大索引的可能值 若r < 0，则在①处return -1 if (fromIndex < 0) { return -1; } if (fromIndex > rightIndex) { //若f >= rightIndex， 则f = rightIndex fromIndex = rightIndex; } /* 空字符串总是匹配的 */ if (targetCount == 0) { //若targetCount=0，则返回 Math.min(fromIndex,sourceCount) return fromIndex; } int strLastIndex = targetOffset + targetCount - 1; // target(目标字符串)的最后一个字符的索引(记为lastChar) char strLastChar = target[strLastIndex]; // lastChar int min = sourceOffset + targetCount - 1; // lastChar在source(源字符串)中的最小索引 int i = min + fromIndex; // lastChar在source中的最大索引 startSearchForLastChar: //循环标签 while (true) { while (i >= min && source[i] != strLastChar) { //找寻lastChar i--; } if (i < min) { //① return -1; } int j = i - 1; // i为找到的lastChar的索引 int start = j - (targetCount - 1); // 即 start = i - targetCount int k = strLastIndex - 1; while (j > start) { if (source[j--] != target[k--]) { i--; //注意此处是i-- 用j与target遍历比较是比较明智的，不改变i continue startSearchForLastChar; } } return start - sourceOffset + 1; //上面循环正常结束，则找到target 结果表示为start + 1 - sourceOffset更容易理解 } }
(13) subString(int beginIndex) 截取字符串 返回新的String对象
public String substring(int beginIndex) { if (beginIndex < 0) { throw new StringIndexOutOfBoundsException(beginIndex); } int subLen = value.length - beginIndex; //截取长度 if (subLen < 0) { throw new StringIndexOutOfBoundsException(subLen); } return (beginIndex == 0) ? this : new String(value, beginIndex, subLen); //返回新字符串 }
(14) concat(String str) 连接字符串 返回新的String对象
public String concat(String str) { int otherLen = str.length(); if (otherLen == 0) { return this; } int len = value.length; char buf[] = Arrays.copyOf(value, len + otherLen); //将value复制到buf[]中，从0索引处开始 str.getChars(buf, len); //将str复制到buf[]中，从len索引处开始 return new String(buf, true); //返回新字符串 }
(15) join(CharSequence delimiter, Iterable<? extends CharSequence> elements) 类方法，通过遍历拼接CharSequence
public static String join(CharSequence delimiter, // delimiter: 分隔符 Iterable<? extends CharSequence> elements) { Objects.requireNonNull(delimiter); // 要求不为空 Objects.requireNonNull(elements); StringJoiner joiner = new StringJoiner(delimiter); // elements是Iterable的实例，所以可以用forEach()方法
for (CharSequence cs: elements) { // 实际是调用其Iterator()方法的返回值(iterator实例)的hasNext()和next()方法 joiner.add(cs); } return joiner.toString(); }
示例：
System.out.println(String.join(",", new IterTest())); // ","为分隔符 class IterTest implements Iterable<CharSequence>{
@Override
public Iterator<CharSequence> iterator() {
class It implements Iterator<CharSequence>{
CharSequence[] s = {"today", "is", "Tuesday"};
int next = 0;
@Override
public boolean hasNext() {
return next!=s.length;
}
@Override
public CharSequence next() {
return s[next++];
}
}
return new It();
}
}
结果：
today,is,Tuesday
(16) trim() 字符串两端去空格 依旧返回新String对象
public String trim() { int len = value.length; int st = 0; char[] val = value; /* avoid getfield opcode */ while ((st < len) && (val[st] <= ' ')) { // 去掉左边的空格 st++; } while ((st < len) && (val[len - 1] <= ' ')) { // 若满足st < len表示至少有一个非空字符 len--; } return ((st > 0) || (len < value.length)) ? substring(st, len) : this; //只要有一端有空字符，则返回截取的字符串 }
以上是常用方法...