0x01:String属于java.lang包里的类
0x02:String是一个final类，实现了Serializable,Comparable,CharSequence接口
public final class String implements java.io.Serializable, Comparable<String>, CharSequence
- Serializable 该接口没有任何方法和成员，用于标识序列化。
- Comparable 该接口只有一个compareTo(T 0)方法，用于比较两个对象大小。
- CharSequence 该接口是一个只读的字符序列。包括length(), charAt(int index), subSequence(int start, int end)这几个接口方法。
0x03:主要成员变量
private final char value[];//用于存储string的所有字符
private int hash; // hash值
public static final Comparator<String> CASE_INSENSITIVE_ORDER= new CaseInsensitiveComparator();//忽略大小写得比较两个字符串
- String 变量的值在内存中的根本形式就是一个char数组
- 由于String常常用来做比较，所以便把hash存储下来
- CASE_INSENSITIVE_ORDER用于比较两个忽略大小写的字符串
0x04:内部类
private static class CaseInsensitiveComparator implements Comparator<String>, java.io.Serializable {
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) {
return c1 - c2;// No overflow because of numeric promotion
}
}
}
}
return n1 - n2;
}
/** Replaces the de-serialized object. */
private Object readResolve() { return CASE_INSENSITIVE_ORDER; }
}
public static final Comparator<String> CASE_INSENSITIVE_ORDER= new CaseInsensitiveComparator();
- 和String.compareTo()方法相比，此方法在比较时是忽略大小写的。使用了{静态内部类}单例模式，可以很容易的用它来比较两个String。
- 可以看到String类中提供的compareToIgnoreCase方法其实就是调用这个内部类里面的方法实现的。从而实现代码复用。
0x05:众多的构造函数
无参数的构造函数{直接引用""的地址}
public String() {
this.value = "".value;
}
String类型参数的构造函数{直接引用原String的地址}
public String(String original) {
this.value = original.value;
this.hash = original.hash;
}
char数组的拷贝的构造函数
public String(char value[]) {
this.value = Arrays.copyOf(value, value.length);
}
public String(char value[], int offset, int count) {
//安全性考虑
if (offset < 0) {throw new StringIndexOutOfBoundsException(offset);}
if (count <= 0) {
if (count < 0) {
throw new StringIndexOutOfBoundsException(count);
}
if (offset <= value.length) {
this.value = "".value;
return;
}
}
if (offset > value.length - count) {
throw new StringIndexOutOfBoundsException(offset + count);
}
this.value = Arrays.copyOfRange(value, offset, offset+count);
}
由int数组转化的构造方法
public String(int[] codePoints, int offset, int count) {
//安全性考虑的代码部分
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;
// Pass 1: Compute precise size of char[]
int n = count;
for (int i = offset; i < end; i++) {
int c = codePoints[i];
if (Character.isBmpCodePoint(c))
continue;
else if (Character.isValidCodePoint(c))
n++;
else throw new IllegalArgumentException(Integer.toString(c));
}
// Pass 2: Allocate and fill in 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))
v[j] = (char)c;
else
Character.toSurrogates(c, v, j++);
}
this.value = v;
}
- 这是一个把unicode编码的int类型的数组转换为String的构造函数
- unicode的合理取值范围现在扩展到了0x0000-0x10ffff,一共21位，二进制 0000 0000 0000 0001 0000 1111 1111 1111 1111
- java中的char是两个字节的，也就是16位。最大值就是0xffff,就是二进制 1111 1111 1111 1111
- unicode中 0x0000-0xffff 被称作BMP(Basic Multilingual Plane)，char只能表示BMP
- 值大于0xffff的字符称为增补字符
- char只能表示BMP，而int的范围甚至超出了unicode的合理取值范围
判断codePoint是否BMP
public static boolean isBmpCodePoint(int codePoint) {
return codePoint >>> 16 == 0;//无符号右移
}
- 判断是不是BMP，如果是的话，一个char就能放下，就不需要增加空间。如果不是的话，先验证是否在unicode的合理取值范围内。如果是的话，说明一个char的空间存不下，再申请一个，如果超出了合理取值范围就抛异常。
- 判断方法同BMP
public static final int MAX_CODE_POINT = 0X10FFFF;
public static boolean isValidCodePoint(int codePoint) {
int plane = codePoint >>> 16;//无符号右移
return plane < ((MAX_CODE_POINT + 1) >>> 16);
//0x10FFFF === 0001 0000 1111 1111 1111 1111
//0x110000 === 0001 0001 0000 0000 0000 0000 {MAX_CODE_POINT + 1}
//0x11 0001 0001 (MAX_CODE_POINT + 1) >>> 16
}
toSurrogates(c, v, j++)方法将大于BMP范围但是是unicode合理范围的codePoint，处理成两个char，分别为高位代理和低位代理，Charater类中有对应的方法，判断是否为代理，是否为高位代理，是否为低位代理，是否为代理对，将一对代理转换为一个codePoint
static void toSurrogates(int codePoint, char[] dst, int index) {
dst[index+1] = lowSurrogate(codePoint);
dst[index] = highSurrogate(codePoint);
}
public static final char MIN_LOW_SURROGATE = '\uDC00';
public static char lowSurrogate(int codePoint) {
return (char) ((codePoint & 0x3ff) + MIN_LOW_SURROGATE);
}
public static final char MIN_HIGH_SURROGATE = '\uD800'；
public static final int MIN_SUPPLEMENTARY_CODE_POINT = 0x010000;
public static char highSurrogate(int codePoint) {
return (char) ((codePoint >>> 10)+
(MIN_HIGH_SURROGATE - (MIN_SUPPLEMENTARY_CODE_POINT >>> 10)));
}
ascii数组的构造方法
//hibyte(高8位)
@Deprecated
public String(byte ascii[], int hibyte, int offset, int count) {
checkBounds(ascii, offset, count);
char value[] = new char[count];
if (hibyte == 0) {
for (int i = count; i-- > 0;) {
value[i] = (char)(ascii[i + offset] & 0xff);
}
} else {
hibyte <<= 8;
for (int i = count; i-- > 0;) {
value[i] = (char)(hibyte | (ascii[i + offset] & 0xff));
}
}
this.value = value;
}
bytes数组构造String
public String(byte bytes[], int offset, int length, String charsetName)
throws UnsupportedEncodingException {
if (charsetName == null)
throw new NullPointerException("charsetName");
checkBounds(bytes, offset, length);
this.value = StringCoding.decode(charsetName, bytes, offset, length);
}
StringBuffer构造String(线程安全)
public String(StringBuffer buffer) {
synchronized(buffer) {
this.value = Arrays.copyOf(buffer.getValue(), buffer.length());
}
}
StringBuilder构造String
public String(StringBuilder builder) {
this.value = Arrays.copyOf(builder.getValue(), builder.length());
}
0x06:常用的方法
java.lang.String对象中封装方法非常多，仅针对常用方法源代码进行分析。如：equals()，replace(), indexOf()，startsWith()，compareTo()，regionMathes()，hashCode()。
public boolean equals(Object anObject)
比较两对象存储内容是否相同。采用排除法比较，算法更优：
（1）是不是同一个对象，如果是同一个对象，则两个字符串肯定相等。
（2）如果都不是String,也没法比较，直接不相等
（3）如果长度都不相等,肯定也就不相等了
（4）从第一个字符开始比较，如果有字符不相等，则直接就不相等了，就没必要继续比较下去了。
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof 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])
return false;
i++;
}
return true;
}
}
return false;
}
public String replace(CharSequence target, CharSequence replacement)
该方法是我们通常意义所用到的 public String replace(String target, String replacement) ，String实现了CharSequence接口。方法内部调用正则表达式匹配替换来实现。
public String replace(CharSequence target, CharSequence replacement) {
return Pattern.compile(target.toString(), Pattern.LITERAL).matcher( this)
.replaceAll(Matcher.quoteReplacement(replacement.toString());
}
public int indexOf(str)
该方法是找出目标字符串是第一次出现指定子字符串的位置，若不存在，则返回-1，若存在，则返回位置坐标。具体实现是调用 static int indexOf(char[] source, int sourceOffset, int sourceCount, char[] target, int targetOffset, int targetCount, int fromIndex) 方法。先对目标字符串中出现子字符串的位置可能范围，然后在此范围中遍历找出与子字符串第一个字符相同的位置，并对后面字符进行比较分析。
public int indexOf(String str) {
return indexOf(str, 0);
}
public int indexOf(String str, int fromIndex) {
return indexOf(value, 0, value.length,
str.value, 0, str.value.length, fromIndex);
}
/**
* Code shared by String and StringBuffer to do searches. The
* source is the character array being searched, and the target
* is the string being searched for.
*
* @param source the characters being searched.
* @param sourceOffset offset of the source string.
* @param sourceCount count of the source string.
* @param target the characters being searched for.
* @param targetOffset offset of the target string.
* @param targetCount count of the target string.
* @param fromIndex the index to begin searching from.
*/
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;
}
public int compareTo(String anotherString)
该方法是对字符串集合进行排序的基础，通过此方法可比较两字符串大小
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;
}
public boolean startsWith(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 int hashCode()
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;
}
hash常常用来判断两个字符串相等或者回文。一个String的hash值=s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
关于为什么取31为权，可以参考StackOverflow上的这个问题
主要是因为31是一个奇质数，所以31*i=32*i-i=(i<<5)-i，这种位移与减法结合的计算相比一般的运算快很多。
...to be continue.
网友评论