Java JDK1.8源码学习之路 2 String
写在最前
String 作为我们最常使用的一个Java类，注意，它是一个引用类型，不是基本类型，并且是一个不可变对象，一旦定义 不再改变
经常会定义一段代码：
String temp = "Hello";
这里具体的含义是：定义了一个类型为String的引用类型变量 temp 指向 “Hello” 这个存在内存当中的对象。
这里列举一些面试中常见的问题，简单但也很容易绕进去
String a = "hello"; String b = "hello"; System.out.println(a.hashCode());//99162322 System.out.println(b.hashCode());//99162322 System.out.println(a==b);//true
这里用 == 比较两个相同的字符串时候，会返回true,原因是 JAVA会把两个内容相同的字符串看作是同一个对象，具有相同的哈希值；
new 一定会产生新对象，分配新的内存地址
String a = "hello"; String b = new String("hello"); System.out.println(a.hashCode());//99162322 System.out.println(b.hashCode());//99162322 System.out.println(a==b);//false
得出： == 双目运算符比较的是内存地址，new 产生了一个新的对象，有不同的内存地址
equals 方法与 == 运算符的比较 以及 + 运算符
String a = "hello";
String b = "word";
String c = "helloword";
String d = "hello"+"word";
System.out.println(c == a+b);//false
System.out.println(c == "hello"+"word");//true
System.out.println(c == d);//true
字符串如果是变量相加，先开空间，在拼接
如果是常量相加，是先加，然后在常量池找，如果有就直接返回，否则，就创建。
a+b 先进行开辟内存，在进行拼接，所以他们的内存地址肯定不相同
"hello"+"word" 常量相加，拼接后发现在常量池存在，则直接返回的就是c的内存地址，所以返回true
结论：引用类型使用 == 比较时候，比较的是内存地址，而equals 方法比较的是对象的值，在String 对象里面，会对两个字符串的每个字符进行一一比较，而平时我们创建的对象默认实现的是
Object 类的equals 方法，Object 类的equals方法默认使用的是 ==比较，所以比较的是内存地址。所以我们在比较自己创建的对象时候，要重写equals方法。
开始分析常用源码
构造器部分
public final class String implements java.io.Serializable, Comparable<String>, CharSequence { //定义了一个存放字符串字符的数组 private final char value[]; //字符串本身的哈希值 private int hash; // Default to 0 //理解为 是一个序列化的ID private static final long serialVersionUID = -6849794470754667710L; //io包下面 实例化出一个长度为1的串行化字段的类 private static final ObjectStreamField[] serialPersistentFields = new ObjectStreamField[0]; //构造一个空的字符串 这个空说的是"" public String() { this.value = "".value; } //传入一个字符串进行构造， public String(String original) { this.value = original.value; this.hash = original.hash; } //将传入一个字符数组，通过数组复制的方式，将字符数组的值复制到value字符数组 public String(char value[]) { this.value = Arrays.copyOf(value, value.length); } }
传入一个StringBuffer进行构造一个字符串对象，通过复制字符序列进行构造，并且在构造的过程中加入同步锁
public String(StringBuffer buffer) {
synchronized(buffer) { this.value = Arrays.copyOf(buffer.getValue(), buffer.length()); } }
常用方法分析
length() 字符串长度方法
public int length() { return value.length; }
isEmpty() 判断是否为空
public boolean isEmpty() { return value.length == 0; }
CharAt(int index) 取出指定位置的字符，若下标小于零或者超出长度，则会抛出异常
public char charAt(int index) { if ((index < 0) || (index >= value.length)) { throw new StringIndexOutOfBoundsException(index); } return value[index]; }
codePointAt 取出指定下标位置字符的Unicode值 Unicode详见文章后部
public int codePointAt(int index) { if ((index < 0) || (index >= value.length)) { throw new StringIndexOutOfBoundsException(index); } return Character.codePointAtImpl(value, index, value.length); }
getChars 复制字符串的字符数组到一个新的字符数组dst, 复制到dst数组dstBegin位置
void getChars(char dst[], int dstBegin) { System.arraycopy(value, 0, dst, dstBegin, value.length); }
getBytes 将这个字符串通过指定的编码名称编码后，返回字节数组
public byte[] getBytes(String charsetName) throws UnsupportedEncodingException { if (charsetName == null) throw new NullPointerException(); return StringCoding.encode(charsetName, value, 0, value.length); }
equals 方法，最常用的方法之一 判断两个字符串是否相等
public boolean equals(Object anObject) {
// == 判断内存地址是否相等，相等则返回true if (this == anObject) { return true; }
//传入的对象是否是String类型的子类 if (anObject instanceof String) { String anotherString = (String)anObject; int n = value.length;
//长度相等在开始判断相等，不相等的长度直接返回false if (n == anotherString.value.length) { char v1[] = value; char v2[] = anotherString.value; int i = 0;
//循环判断每一个字符，只要一个不相等则false while (n-- != 0) { if (v1[i] != v2[i]) return false; i++; } return true; } } return false; }
compareTo(String another) 字典顺序比较两个字符串，相等则返回0
a.compareTo(b) a>b 返回负整数 反之则是正整数
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; }
regionMatches(int toffset, String other, int ooffset,int len)
other字符串是否是源字符串的子串，比较位置从源字符串的toffset位置开始，other字符串的ooffset位置开始，比较的长度是len
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; }
startsWith(String prefix, int toffset) 源字符串的toffset位置是否包含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; }
indexOf(int ch,int index) 方法 从字符串的formIndex开始索引，找出首次出现ch(Unicode 值)的位置，
public int indexOf(int ch, int fromIndex) { final int max = value.length; if (fromIndex < 0) { fromIndex = 0; } else if (fromIndex >= max) { // Note: fromIndex might be near -1>>>1. return -1; } if (ch < Character.MIN_SUPPLEMENTARY_CODE_POINT) { // handle most cases here (ch is a BMP code point or a // negative value (invalid code point)) final char[] value = this.value; for (int i = fromIndex; i < max; i++) { if (value[i] == ch) { return i; } } return -1; } else { return indexOfSupplementary(ch, fromIndex); } }
indexOf：被搜索的字符序列target， 源字符序列source ,从源字符序列的sourceOffset开始，源字符序列的长度sourceCount
formIndex表示从源字符序列的那个位置开始搜索
static int indexOf(char[] source, int sourceOffset, int sourceCount, char[] target, int targetOffset, int targetCount, int fromIndex) {
//搜索开始的位置大于等于源字符串的长度 if (fromIndex >= sourceCount) {
//如果被搜索字符的长度==0 就是空字符串 就返回源字符串的长度，否则就直接返回-1搜索不到 return (targetCount == 0 ? sourceCount : -1); }
//对开始位置若小于零则归零 if (fromIndex < 0) { fromIndex = 0; }
//被搜索字符序列长度为0，直接返回搜索开始的位置 if (targetCount == 0) { return fromIndex; }
//首个比较的字符，从target偏移位置开始 char first = target[targetOffset];
// 搜索的最后一个位置 int max = sourceOffset + (sourceCount - targetCount);
//从偏移位置+开始搜索的位置开始搜索 搜索次数 max 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; }
substring 返回一个子字符串，从beginIndex下标开始，到结束
这里如果下标取0则返回的是字符串本身，否则就新new一个
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); }
concat 拼接两个字符串
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);
//将新的str填充 str.getChars(buf, len);
//产生一个新的String对象 return new String(buf, true); }
replace 将源字符串中的指定字符替换为新的字符
public String replace(char oldChar, char newChar) {
//内存地址相等则直接返回 if (oldChar != newChar) { int len = value.length; int i = -1; char[] val = value; /* avoid getfield opcode */
//找出具体旧的字符所在的第一个位置 while (++i < len) { if (val[i] == oldChar) { break; } }
//找到旧的字符则继续 因为i<len if (i < len) { char buf[] = new char[len];
//复制数组到 buf里面 for (int j = 0; j < i; j++) { buf[j] = val[j]; }
//开始替换 while (i < len) { char c = val[i]; buf[i] = (c == oldChar) ? newChar : c; i++; } return new String(buf, true); } } return this; }
UniCode 万国码简介
Unicode 万国码，又叫做统一码，是计算机的一项业界标准，他为每种语言中的字符设定了统一的
并且是唯一的二进制码，满足文本的转换，处理。
UTF-8
计算机里面最常见的一种编码格式，它的基本单位是字节，UTF-8最大长度是4个字节。我们使用的汉字，每一个汉字占用三个字节来表示
UTF-8的特点是对不同范围的字符使用不同长度的编码。对于0x00-0x7F之间的字符，UTF-8编码与ASCII编码完全相同。
意思就是说平时使用到的英文字母以及常用半角符号。来自于键盘上的符号都是由ASCII 在Unicode里面使用一个字节去表示。
举个例子
这里打印出小写h所对应的万国码 用整数表示出就是104
String a = "hello";
System.out.println(a.codePointAt(0));//104
我们查阅ASCII表
果然一个字节表示的字符与ASCII码表是对应的
但行好事，相信技术，转载请注明出处
