反转一个字符串的算法

abstract class AbstractStringBuilder implements Appendable, CharSequence {
/**
* The value is used for character storage.
*/
char[] value;
/**
* The count is the number of characters used.
*/
int count;
/**
* Causes this character sequence to be replaced by the reverse of
* the sequence. If there are any surrogate pairs included in the
* sequence, these are treated as single characters for the
* reverse operation. Thus, the order of the high-low surrogates
* is never reversed.
* (省略部分注释)....
* @return  a reference to this object.
*/
public AbstractStringBuilder reverse() {
boolean hasSurrogates = false;
//n为字符串长度
int n = count - 1;
//循环交换
//(n-1) >> 1 位移算法的结果是取到了对数
for (int j = (n-1) >> 1; j >= 0; j--) {
//j是最后一个，n-j是第一个
int k = n - j;
//进行交换，从中间向两端交换，如果n为奇数，则第一次交换j和k相等。
char cj = value[j];
char ck = value[k];
value[j] = ck;
value[k] = cj;
//判断cj和ck是否是合法的字符
if (Character.isSurrogate(cj) ||
Character.isSurrogate(ck)) {
hasSurrogates = true;
}
}
//存在Surrogate，如果存在，循环一次将所有Surrogate位置交换回来，否则无法正常显示了。
if (hasSurrogates) {
reverseAllValidSurrogatePairs();
}
return this;
}
/** Outlined helper method for reverse() */
private void reverseAllValidSurrogatePairs() {
for (int i = 0; i < count - 1; i++) {
char c2 = value[i];
if (Character.isLowSurrogate(c2)) {
char c1 = value[i + 1];
if (Character.isHighSurrogate(c1)) {
value[i++] = c1;
value[i] = c2;
}
}
}
}
}

/**
* 省略了部分代码
*/
public final class Character implements java.io.Serializable, Comparable<Character> {
public static boolean isSurrogate(char ch) {
return ch >= MIN_SURROGATE && ch < (MAX_SURROGATE + 1);
}
//判断字符是否是Surrogate的高位字符
public static boolean isHighSurrogate(char ch) {
// Help VM constant-fold; MAX_HIGH_SURROGATE + 1 == MIN_LOW_SURROGATE
return ch >= MIN_HIGH_SURROGATE && ch < (MAX_HIGH_SURROGATE + 1);
}
}