昨天面试碰见一个笔试题。题目要求：利用String自身的方法，将一个由正整数组成的字符串，转变为int数组后倒序输出（例如“123”输出321）。
public static void reverse(String str){
char[] chs = str.toCharArray();
for (int i = chs.length-1; i >0; i--) {
System.out.println((int) (chs[i])- (int) ('0'));
}
}
这是我现在认为最标准的答案，不知道大家有没有什么别的想法。
public final class String implements java.io.Serializable,Comparable<String>,CharSequence {
上面可以看出，String类实现了三个接口，用于序列化Serializable接口，用于比较的泛型接口Comparable<String>和CharSequence接口，对于前两个接口可能都比较熟悉，那么第三个接呢。
CharSequence接口有四个方法：
int length();返回字符数组的长度。
char charAt（int index）：返回制定索引处的字符。
CharSequence subSequence(int start, int end);返回有start开始到end之前的字符所组成的字符数组。
String toString()：返回该字符数组对应的String。
private final char value[]; private final int offset; private final int count; private int hash; private static final long serialVersionUID = -6849794470754667710L; private static final ObjectStreamField[] serialPersistentFields = new ObjectStreamField[0];
这是String类里定义私有变量，value[]就是String对应的字符数组，offset一直没搞懂，求指教啊，count就是String对应字符序列中的字符数，hash是String对应的hash码。其中value[]和coun应该是我们一般需要知道的，别的就不用了。
再来看看String中主要的方法：
String的构造方法有很多，可以分为以下几类：
1、不传任何参数，也就是构造一个空字符串；
2、传入String对象，StringBuffer对象或者StringBuilder对象。
3、传入byte数组，并且带别的参数，用于表示截取长度的int，截取开始位置的int和用于表示字符集的String；
4、传入char数组，其余参数包括截取开始位置的int，截取长度的int
5、传入int数组，所带参数与char类似。
length()，实现自CharSequence 接口，返回count也就是字符串长度。
isEmpty()，返回count==0。
charAt(int index)，返回指定索引处的字符。
void getChars(char dst[], int dstBegin) ：将字符串中的字符从begin位置开始copy到dst[]数组中。
public byte[] getBytes(String charsetName)：获得byte数组。
public byte[] getBytes(Charset charset)：返回制定charset的byte数组。
public byte[] getBytes()：返回byte数组。
public boolean equals(Object anObject)：覆盖object中的equals方法。
实现代码如下：比较简单
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;
}
用于和StringBuffer进行内容比较的一个方法：
public boolean contentEquals(StringBuffer sb) {
synchronized (sb) {
return contentEquals((CharSequence) sb);
}
}
上面的方法实际调用了和CharSequence进行内容比较的方法，也就是针对每一位的字符进行对比，当然前面还有几个短路比较。
public boolean contentEquals(CharSequence cs) {
if (count != cs.length())
return false;
// Argument is a StringBuffer, StringBuilder
if (cs instanceof AbstractStringBuilder) {
char v1[] = value;
char v2[] = ((AbstractStringBuilder) cs).getValue();
int i = offset;
int j = 0;
int n = count;
while (n-- != 0) {
if (v1[i++] != v2[j++])
return false;
}
}
// Argument is a String
if (cs.equals(this))
return true;
// Argument is a generic CharSequence
char v1[] = value;
int i = offset;
int j = 0;
int n = count;
while (n-- != 0) {
if (v1[i++] != cs.charAt(j++))
return false;
}
return true;
}
public boolean equalsIgnoreCase(String anotherString)：忽略大小写的同类比较。
public boolean equalsIgnoreCase(String anotherString) {
return (this == anotherString) ? true : (anotherString != null)
&& (anotherString.count == count)
&& regionMatches(true, 0, anotherString, 0, count);
}
comparable接口的compareTo方法：
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;
}
String还给我们提供了一个比较工具类：
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(), n2 = s2.length();
for (int i1 = 0, i2 = 0; i1 < n1 && i2 < n2; i1++, i2++) {
char c1 = s1.charAt(i1);
char c2 = s2.charAt(i2);
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) {
return c1 - c2;
}
}
}
}
return n1 - n2;
}
}
忽略大小写的同类比较：
public int compareToIgnoreCase(String str) {
return CASE_INSENSITIVE_ORDER.compare(this, str);
}
计算hashcode的方法（至于每位为什么乘以31而不是32，同求解）：
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;
}
提供的公共方法用于查找目标字符串中的字符串：
static int indexOf(char[] source, int sourceOffset, int sourceCount,
char[] target, int targetOffset, int targetCount, int fromIndex) {
if (fromIndex >= sourceCount) {
return (targetCount == 0 ? sourceCount : -1);
}
if (fromIndex < 0) {
fromIndex = 0;
}
if (targetCount == 0) {
return fromIndex;
}
char first = target[targetOffset];
int max = sourceOffset + (sourceCount - targetCount);
for (int i = sourceOffset + fromIndex; i <= max; i++) {
/* Look for first character. */
if (source[i] != first) {
while (++i <= max && source[i] != first)
;
}
/* Found first character, now look at the rest of v2 */
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) {
/* Found whole string. */
return i - sourceOffset;
}
}
}
return -1;
}
看看我们最常用的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;
}
笔试要用到的方法：
public char[] toCharArray() {
char result[] = new char[count];
getChars(0, count, result, 0);
return result;
}
将其他对象转换为String：
public static String valueOf(Object obj) {
return (obj == null) ? "null" : obj.toString();
}
public native String intern():当调用 intern 方法时，如果池已经包含一个等于此 String 对象的字符串（用 equals(Object) 方法确定），则返回池中的字符串。否则，将此 String 对象添加到池中，并返回此 String 对象的引用。
public boolean startsWith(String prefix, int toffset);
public boolean startsWith(String prefix) ;
public boolean endsWith(String suffix);
public int indexOf(int ch);
public int indexOf(int ch, int fromIndex);//该查找是从fromindex处往前找
public int lastIndexOf(int ch);
public int lastIndexOf(int ch, int fromIndex);
public int indexOf(String str);
public int indexOf(String str, int fromIndex);
public int lastIndexOf(String str);
public String substring(int beginIndex);
public String substring(int beginIndex, int endIndex);
public CharSequence subSequence(int beginIndex, int endIndex);
public String concat(String str);
public String replace(char oldChar, char newChar);
public boolean matches(String regex);
public boolean contains(CharSequence s);
public String replaceFirst(String regex, String replacement);
public String replaceAll(String regex, String replacement);
public String replace(CharSequence target, CharSequence replacement);
public String[] split(String regex, int limit);
public String[] split(String regex);
public static String valueOf(char data[]);
public static String copyValueOf(char data[], int offset, int count);
public static String valueOf(boolean b);
有误之处，敬请拍砖！