JDK8源码阅读（1）
源码阅读顺序参考了https://blog.csdn.net/qq_21033663/article/details/79571506 大佬提供的顺序，按照大佬的顺序自己总结一遍。
这一章主要讲了lang.Object类和lang.String类即一（1）和（2）。
java.lang
一.Object类
java所有类的祖先。
类图：
依次分析下这几个方法：
1.void registerNatives()
先定义了registerNatives()方法，然后当该类被加载的时候，调用该方法完成对该类中本地方法的注册。
2.Class<?> getClass()
返回当前对象所属的类对象。
3.int hashCode()
返回当前对象的哈希值，经常作为对象的唯一标识。
4.boolean equals(Object obj)
判等，默认情况下只是比较下两个对象的引用。
public boolean equals(Object obj) {
return (this == obj);
}
5.Object clone()
浅拷贝，使用时往往需要重写为public形式。
要求被克隆的对象所属的类实现Cloneable接口
6. String toString()
字符串化，输出类的名字+十六进制的哈希值
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
7.void notify()
随机唤醒某个具有相同锁的对象从wait状态进入争锁状态
8.void notifyAll()
唤醒所有具有相同锁的对象从wait状态进入争锁状态
9.void wait(long timeout)
超时等待一段时间，单位是毫秒，如果没有通知就超时返回
10.void wait(long timeout, int nanos)
多了个纳秒级别的调节，实际上只是把纳秒四舍五入了。
public final void wait(long timeout, int nanos) throws InterruptedException {
if (timeout < 0) {
throw new IllegalArgumentException("timeout value is negative");
}
if (nanos < 0 || nanos > 999999) {
throw new IllegalArgumentException(
"nanosecond timeout value out of range");
}
if (nanos >= 500000 || (nanos != 0 && timeout == 0)) {
timeout++;
}
wait(timeout);
}
11.void wait()
线程将进入等待状态，只有等待其他线程唤醒或者被中断才能返回，其中wait（）方法时会释放对象的锁。
public final void wait() throws InterruptedException {
wait(0);
}
12.void finalize()
对象在被GC回收后执行的清理操作。
二.String类
类图：
插播三个接口说明：
1.Comparable接口
只有一个方法public int compareTo(T o);
可以重写该方法来比较此对象与指定对象的顺序，如果该对象小于、等于或者大于指定对象分别返回负整数、零或者正整数。
2.Serializable接口
Serializable主要作用将类的实例持久化保存，序列化就是保存，反序列化就是读取。保存也不一定保存在本地，也可以保存到远方。类一定要实现Serializable才可以。
什么是序列化：将对象的状态信息转换为可以存储或传输的形式的过程，在序列化期间，对象将其当前状态写入到临时存储区或持久性存储区，之后，便可以通过从存储区中读取或反序列化对象的状态信息，来重新创建该对象。
3.charSequence接口
字符序列接口，封装了对字符序号的一些操作。
方法1️⃣：int length()
返回字符序列的长度
方法2️⃣：char charAt(int index)
返回索引index处的字符
方法3️⃣：CharSequence subSequence(int start, int end)
返回该序列的子序列
方法4️⃣：String toString()
返回这个字符序列所组成的字符串
方法5️⃣：default IntStream chars()（default是为了接口也可以有具体的方法实现，JDK1.8中新加的）
将当前char序列转化成流序列，序列中的每个元素都是char
public default IntStream chars() {
//定义了一个内部类CharInterator，字符迭代器
class CharIterator implements PrimitiveIterator.OfInt {
int cur = 0;
//如果当前的索引小于总长度，就说明还有下一个
public boolean hasNext() {
return cur < length();
}
把下一个char值取出来
public int nextInt() {
if (hasNext()) {
return charAt(cur++);
} else {
throw new NoSuchElementException();
}
}
//intConsumer接收每一个取出的char
@Override
public void forEachRemaining(IntConsumer block) {
for (; cur < length(); cur++) {
block.accept(charAt(cur));
}
}
}
return StreamSupport.intStream(() ->
Spliterators.spliterator(
new CharIterator(),
length(),
Spliterator.ORDERED),
Spliterator.SUBSIZED | Spliterator.SIZED | Spliterator.ORDERED,
false);
}
方法6️⃣：default IntStream codePoints()
// 将当前Unicode符号序列转为流序列，序列中每个元素是Unicode符号
方法7：int compare(CharSequence cs1, CharSequence cs2)
按照字典顺序比较两个字符序列
public static int compare(CharSequence cs1, CharSequence cs2) {
//首先判别参数1和参数2非空
if (Objects.requireNonNull(cs1) == Objects.requireNonNull(cs2)) {
return 0;
}
//判别参数1和参数2的类型是相同的，并且都继承了comparable接口
if (cs1.getClass() == cs2.getClass() && cs1 instanceof Comparable) {
return ((Comparable<Object>) cs1).compareTo(cs2);
}
总长度为参数1和参数2的较小值，遍历总长度中的元素
for (int i = 0, len = Math.min(cs1.length(), cs2.length()); i < len; i++) {
char a = cs1.charAt(i);
char b = cs2.charAt(i);
//如果存在相同索引号的元素不相同就返回比较结果
if (a != b) {
return a - b;
}
}
如果总长度中所有相同元素都相同，那么就长度长的大。
return cs1.length() - cs2.length();
}
接下来讲回String类：
成员变量：
1.final char value[]
jdk9之前是用char[]来保存String的，JDK9之后就用byte[]来保存String，这里是jdk8，因此还是用char[]来保存字符串。
注意是用final修饰的，因此字符串一创建就是不可变的。
2.static final long serialVersionUID = -6849794470754667710L；
序列化需要的变量
3.int hash；
缓存字符串的哈希码，默认为0。
4.static final ObjectStreamField[] serialPersistentFields =new ObjectStreamField[0]；
类字符串在序列化流协议中是特殊情况。根据对象序列化规范第6.2节“流元素”，将字符串实例写入ObjectOutputStream;
方法：
1.String()
构造函数，构造空串，但是String是不可变的，因此一般不这样构造字符串。
public String() {
this.value = new char[0];
}
2.String(String original)
拷贝原来字符串的副本
public String(String original) {
this.value = original.value;
this.hash = original.hash;
}
3.String(char value[])
将参数char数组赋值到新创建的String中。
public String(char value[]) {
this.value = Arrays.copyOf(value, value.length);
}
4.String(char value[], int offset, int count)
将参数char数组中指定的几个char值创建String。
public String(char value[], int offset, int count) {
if (offset < 0) {
throw new StringIndexOutOfBoundsException(offset);
}
if (count < 0) {
throw new StringIndexOutOfBoundsException(count);
}
// Note: offset or count might be near -1>>>1.
if (offset > value.length - count) {
throw new StringIndexOutOfBoundsException(offset + count);
}
this.value = Arrays.copyOfRange(value, offset, offset+count);
}
5.String(int[] codePoints, int offset, int count)
将参数int数组中指定的几个int值来生成字符串。分析发现，可能存在count=3但是最后生成字符串由4位长，这是因为一个int可能大于2个字节就自动转换成了2个char。
public String(int[] codePoints, int offset, int count) {
if (offset < 0) {
throw new StringIndexOutOfBoundsException(offset);
}
if (count < 0) {
throw new StringIndexOutOfBoundsException(count);
}
// Note: offset or count might be near -1>>>1.
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];
//如果c只有2个字节，那么就跳到下个循环
if (Character.isBmpCodePoint(c))
continue;
//如果c大于2个字节，那么就将总数加1，因为大于两个字节就将这个int分成了两个char
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];
//如果小于两个字节就直接转换成char
if (Character.isBmpCodePoint(c))
v[j] = (char)c;
//如果大于两个字节就分成高位低位分别转换成char
else
Character.toSurrogates(c, v, j++);
}
this.value = v;
}
6.@Deprecated
String(byte ascii[], int hibyte, int offset, int count)该方法已经不推荐使用
7.@Deprecated
public String(byte ascii[], int hibyte)同样不推荐使用
8.static void checkBounds(byte[] bytes, int offset, int length)
越界检查，参数在不在数组中
private static void checkBounds(byte[] bytes, int offset, int length) {
if (length < 0)
throw new StringIndexOutOfBoundsException(length);
if (offset < 0)
throw new StringIndexOutOfBoundsException(offset);
if (offset > bytes.length - length)
throw new StringIndexOutOfBoundsException(offset + length);
}
9.String(byte bytes[], int offset, int length, String charsetName)
根据指定的字符集进行解码
public String(byte bytes[], int offset, int length, String charsetName)
throws UnsupportedEncodingException {
//如果参数是空的就抛出异常
if (charsetName == null)
throw new NullPointerException("charsetName");
//检查是否越界
checkBounds(bytes, offset, length);
用指定的字符集对字节数组进行解码后生成string
this.value = StringCoding.decode(charsetName, bytes, offset, length);
}
10.String(byte bytes[], int offset, int length, Charset charset)
跟上个方法一样，只是这个方法直接输入的是字符集
public String(byte bytes[], int offset, int length, Charset charset) {
if (charset == null)
throw new NullPointerException("charset");
checkBounds(bytes, offset, length);
this.value = StringCoding.decode(charset, bytes, offset, length);
}
11.String(byte bytes[], String charsetName)
对字节数组中的所有字节通过字符集进行解码
public String(byte bytes[], String charsetName)
throws UnsupportedEncodingException {
this(bytes, 0, bytes.length, charsetName);
}
12.String(byte bytes[], Charset charset)
与上同理。
public String(byte bytes[], Charset charset) {
this(bytes, 0, bytes.length, charset);
}
13.String(byte bytes[], int offset, int length)
用默认的字符集进行解码
public String(byte bytes[], int offset, int length) {
checkBounds(bytes, offset, length);
this.value = StringCoding.decode(bytes, offset, length);
}
14.String(byte bytes[])
用默认的字符集对于字节数组中的所有解码
public String(byte bytes[]) {
this(bytes, 0, bytes.length);
}
15.String(StringBuffer buffer)
将字符串缓冲区中的字符串取出生成新的字符串，注意本方法会对缓冲区加锁
public String(StringBuffer buffer) {
synchronized(buffer) {
this.value = Arrays.copyOf(buffer.getValue(), buffer.length());
}
}
16.String(StringBuilder builder)
将字符串生成器中的字符串生成新的字符串
public String(StringBuilder builder) {
this.value = Arrays.copyOf(builder.getValue(), builder.length());
}
17.String(char[] value, boolean share)
包私有的函数protected，必须共享，不共享不支持。
String(char[] value, boolean share) {
// assert share : "unshared not supported";
this.value = value;
}
18.public int length()
返回字符串的长度
19.public boolean isEmpty()
判断字符串是否为空
20.public char charAt(int index)
找到字符串中对应索引的字符
public char charAt(int index) {
if ((index < 0) || (index >= value.length)) {
throw new StringIndexOutOfBoundsException(index);
}
return value[index];
}
21.public int codePointAt(int index)
返回的是索引处的unicode值
public int codePointAt(int index) {
if ((index < 0) || (index >= value.length)) {
throw new StringIndexOutOfBoundsException(index);
}
return Character.codePointAtImpl(value, index, value.length);
}
22.public int codePointBefore(int index)
返回的是索引处-1的unicode值
public int codePointBefore(int index) {
int i = index - 1;
if ((i < 0) || (i >= value.length)) {
throw new StringIndexOutOfBoundsException(index);
}
return Character.codePointBeforeImpl(value, index, 0);
}
23.public int codePointCount(int beginIndex, int endIndex)
返回所指定区域内合法的char个数
public int codePointCount(int beginIndex, int endIndex) {
if (beginIndex < 0 || endIndex > value.length || beginIndex > endIndex) {
throw new IndexOutOfBoundsException();
}
return Character.codePointCountImpl(value, beginIndex, endIndex - beginIndex);
}
24.int offsetByCodePoints(int index, int codePointOffset)
返回此字符串中的索引，该索引与给定索引之间的偏移量为codepointoffset代码点。在索引和代码点偏移量计数给出的文本范围内，未成对的代理项各作为一个代码点。
public int offsetByCodePoints(int index, int codePointOffset) {
if (index < 0 || index > value.length) {
throw new IndexOutOfBoundsException();
}
return Character.offsetByCodePointsImpl(value, 0, value.length,
index, codePointOffset);
}
25.void getChars(char dst[], int dstBegin)
将此字符串中的字符从dstbegin开始复制到dst。此方法不执行任何范围检查
void getChars(char dst[], int dstBegin) {
System.arraycopy(value, 0, dst, dstBegin, value.length);
}
26.public void getChars(int srcBegin, int srcEnd, char dst[], int 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);
}
27.@Deprecated
getBytes(int srcBegin, int srcEnd, byte dst[], int dstBegin)
将字符串中指定位置的字符转换成字节后复制到参数中的字节数组的指定位置。
28.public byte[] getBytes(String charsetName)
根据输入的字符集名称将字符串转换成字节数组输出。
public byte[] getBytes(String charsetName)
throws UnsupportedEncodingException {
if (charsetName == null) throw new NullPointerException();
return StringCoding.encode(charsetName, value, 0, value.length);
}
29.public byte[] getBytes(Charset charset)
同上，参数是字符集
30.public byte[] getBytes()
同上，默认的文件编码模式
31.public boolean equals(Object anObject)
比较两个对象的值
public boolean equals(Object anObject) {
//如果两者的引用相同，那么就返回true
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;
}
32.public boolean contentEquals(StringBuffer sb)
比较String和StringBuffer的内容是否相等
public boolean contentEquals(StringBuffer sb) {
return contentEquals((CharSequence)sb);
}
33.private boolean nonSyncContentEquals(AbstractStringBuilder sb)
一个类的私有方法，判等
private boolean nonSyncContentEquals(AbstractStringBuilder sb) {
char v1[] = value;
char v2[] = sb.getValue();
//首先必须长度相同
int n = v1.length;
if (n != sb.length()) {
return false;
}
//其次每一位也应该相同
for (int i = 0; i < n; i++) {
if (v1[i] != v2[i]) {
return false;
}
}
return true;
}
34.public boolean contentEquals(CharSequence cs)
public boolean contentEquals(CharSequence cs) {
// Argument is a StringBuffer, StringBuilder
//首先需要判断charsequence的实现类
if (cs instanceof AbstractStringBuilder) {
if (cs instanceof StringBuffer) {
synchronized(cs) {
return nonSyncContentEquals((AbstractStringBuilder)cs);
}
} else {
return nonSyncContentEquals((AbstractStringBuilder)cs);
}
}
// Argument is a String
if (cs instanceof String) {
return equals(cs);
}
// Argument is a generic 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;
}
35.public boolean equalsIgnoreCase(String anotherString)
判等，忽略大小写判断两个字符串是否相同
public boolean equalsIgnoreCase(String anotherString) {
return (this == anotherString) ? true
: (anotherString != null)
&& (anotherString.value.length == value.length)
&& regionMatches(true, 0, anotherString, 0, value.length);
}
36.public int compareTo(String anotherString)
判断两个字符串大小，从0位往后比较，只要不相同就输出结果，如果都相同，就比较长短。
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;
}
37.private static class CaseInsensitiveComparator：内部类，忽略大小写的比较器
Comparator和Comparable的区别：comparable可以看作是内比较器，主要用于自身队列排序的是实现；而comparator可以看作是外比较器，一个对象想要和自己比较但是却没有实现comparable就可以自定义一个类来继承comparator，或者认为复写的comparable接口不合理就可以通过comparator重新定义。
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) {
c1 = Character.toLowerCase(c1);
c2 = Character.toLowerCase(c2);
if (c1 != c2) {
// No overflow because of numeric promotion
return c1 - c2;
}
}
}
}
return n1 - n2;
}
//调用比较器的实例
private Object readResolve() { return CASE_INSENSITIVE_ORDER; }
}
38.public int compareToIgnoreCase(String str)
调用比较器对于两个字符串进行比较
public int compareToIgnoreCase(String str) {
return CASE_INSENSITIVE_ORDER.compare(this, str);
}
39.public boolean regionMatches(int toffset, String other, int ooffset,int len)
比较两个String指定的区域，区分大小写
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;
}
40.public boolean regionMatches(boolean ignoreCase, int toffset,String other, int ooffset, int len)
同上，唯一区别多了个是否忽略大小的boolean值
41. public boolean startsWith(String prefix, int toffset)
比较原来String从第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;
}
42.public boolean startsWith(String prefix)
同上，默认从0开始
42. public boolean endsWith(String suffix)
比较原来String的尾巴是否和suffix相同
public boolean endsWith(String suffix) {
return startsWith(suffix, value.length - suffix.value.length);
}
43.public int hashCode()
生成hash值，计算公式为：s[0]*31^(n-1) + s[1]*31^(n-2) + … + s[n-1]。空串的哈希值为0。
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;
}
44.public int indexOf(int ch, int fromIndex)
从fromIndex索引开始寻找ch所在的索引
public int indexOf(int ch, int fromIndex) {
final int max = value.length;
if (fromIndex < 0) {
fromIndex = 0;
} else if (fromIndex >= max) {
return -1;
}
if (ch < Character.MIN_SUPPLEMENTARY_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);
}
}
45.public int indexOf(int ch)
直接从0开始找
46.private int indexOfSupplementary(int ch, int fromIndex)
私有方法，寻找ch数值超过编码值的索引
private int indexOfSupplementary(int ch, int fromIndex) {
if (Character.isValidCodePoint(ch)) {
final char[] value = this.value;
final char hi = Character.highSurrogate(ch);
final char lo = Character.lowSurrogate(ch);
final int max = value.length - 1;
for (int i = fromIndex; i < max; i++) {
if (value[i] == hi && value[i + 1] == lo) {
return i;
}
}
}
return -1;
}
47.public int lastIndexOf(int ch, int fromIndex)
从fromIndex开始往前找跟ch一样的字符，找到就输出索引
public int lastIndexOf(int ch, int fromIndex) {
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;
int i = Math.min(fromIndex, value.length - 1);
for (; i >= 0; i--) {
if (value[i] == ch) {
return i;
}
}
return -1;
} else {
return lastIndexOfSupplementary(ch, fromIndex);
}
}
48.public int lastIndexOf(int ch)
直接从最后一位开始往前找
49.private int lastIndexOfSupplementary(int ch, int fromIndex)
私有方法，处理过大的ch。
50.static int indexOf(char[] source, int sourceOffset, int sourceCount,char[] target, int targetOffset, int targetCount,int fromIndex)
包中才可以使用的方法，返回子串target在主串source中第一次出现的下标（从主串fromIndex处向后搜索）
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;
}
51.static int indexOf(char[] source, int sourceOffset, int sourceCount,String target, int fromIndex)
匹配的是整个target
52.public int indexOf(String str, int fromIndex)
整个str匹配原字符串从fromindex开始的字符
53.public int indexOf(String str)
整个str匹配原来的字符串
54.public int lastIndexOf(String str)
整个str匹配原来的字符串，返回的是最后匹配的索引
55.public int lastIndexOf(String str, int fromIndex)
整个str匹配原来的字符串从索引fromIndex往前，返回的是最后匹配的索引
56.static int lastIndexOf(char[] source, int sourceOffset, int sourceCount,String target, int fromIndex)
整个str匹配原来的字符串（一定的范围）从索引fromIndex往前，返回的是最后匹配的索引
57.static int lastIndexOf(char[] source, int sourceOffset, int sourceCount,char[] target, int targetOffset, int targetCount,int fromIndex)
str（一定的范围）匹配原来的字符串（一定的范围）从索引fromIndex往前，返回的是最后匹配的索引
58.public String substring(int beginIndex)
生成子字符串，从beginIndex开始
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);
}
59.public String substring(int beginIndex, int endIndex)
生成子字符串，指定开始和结束索引
60.public CharSequence subSequence(int beginIndex, int endIndex)
返回的是接口
61.public String concat(String str)
合并字符串
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.getChars(buf, len);
return new String(buf, true);
}
62.public String replace(char oldChar, char newChar)
找到原来字符串中oldChar所在的位置，将其用newChar生成新的字符串
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;
}
}
if (i < len) {
char buf[] = new char[len];
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;
}
63.public boolean matches(String regex)
判断字符串是否与给定的正则表达式相同
64.public boolean contains(CharSequence s)
字符串中是否包含子序列
65.public String replaceFirst(String regex, String replacement)
用replacement取代被regex匹配的首个字符串
public String replaceFirst(String regex, String replacement) {
return Pattern.compile(regex).matcher(this).replaceFirst(replacement);
}
66.public String replaceAll(String regex, String replacement)
将所有正则表达式匹配的字符串取代
67.public String replace(CharSequence target, CharSequence replacement)
找到跟target一样的字符串将其取代为replacement
68.public String[] split(String regex, int limit)
将字符串从正则表达式匹配处开始切割，limit限制了返回的字符串数量
public String[] split(String regex, int limit) {
char ch = 0;
if (((regex.value.length == 1 &&
".$|()[{^?*+\\".indexOf(ch = regex.charAt(0)) == -1) ||
(regex.length() == 2 &&
regex.charAt(0) == '\\' &&
(((ch = regex.charAt(1))-'0')|('9'-ch)) < 0 &&
((ch-'a')|('z'-ch)) < 0 &&
((ch-'A')|('Z'-ch)) < 0)) &&
(ch < Character.MIN_HIGH_SURROGATE ||
ch > Character.MAX_LOW_SURROGATE))
{
int off = 0;
int next = 0;
boolean limited = limit > 0;
ArrayList<String> list = new ArrayList<>();
while ((next = indexOf(ch, off)) != -1) {
if (!limited || list.size() < limit - 1) {
list.add(substring(off, next));
off = next + 1;
} else { // last one
//assert (list.size() == limit - 1);
list.add(substring(off, value.length));
off = value.length;
break;
}
}
// If no match was found, return this
if (off == 0)
return new String[]{this};
// Add remaining segment
if (!limited || list.size() < limit)
list.add(substring(off, value.length));
// Construct result
int resultSize = list.size();
if (limit == 0) {
while (resultSize > 0 && list.get(resultSize - 1).length() == 0) {
resultSize--;
}
}
String[] result = new String[resultSize];
return list.subList(0, resultSize).toArray(result);
}
return Pattern.compile(regex).split(this, limit);
}
69.public static String join(CharSequence delimiter, CharSequence… elements)
字符拼接，底层用StringJoiner实现。
public static String join(CharSequence delimiter, CharSequence... elements) {
Objects.requireNonNull(delimiter);
Objects.requireNonNull(elements);
// Number of elements not likely worth Arrays.stream overhead.
StringJoiner joiner = new StringJoiner(delimiter);
for (CharSequence cs: elements) {
joiner.add(cs);
}
return joiner.toString();
}
70.public static String join(CharSequence delimiter,Iterable<? extends CharSequence> elements)
同理，这里是迭代器中的所有元素
71.public String toLowerCase(Locale locale)
转为小写，需要指定本地的语言环境
72.public String toLowerCase()
用默认的本地语言环境
73.public String toUpperCase(Locale locale)
转为大写，需要指定本地的语言环境
74.public String toUpperCase（）
用默认的本地语言环境
75.public String 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] <= ' ')) {
len--;
}
return ((st > 0) || (len < value.length)) ? substring(st, len) : this;
}
76.public String toString()
复写Object中的toString方法，使得返回的就是字符串本身
77.public char[] toCharArray()
将字符串转成字节数组
public char[] toCharArray() {
// Cannot use Arrays.copyOf because of class initialization order issues
char result[] = new char[value.length];
System.arraycopy(value, 0, result, 0, value.length);
return result;
}
78.public static String format(String format, Object… args)
将字符串进行格式化后输出
79.public static String valueOf(Object obj)
字符串化，本质上就是调用对象的toString方法
public static String valueOf(Object obj) {
return (obj == null) ? "null" : obj.toString();
}
80.public static String valueOf(char data[])
将字节数组转化成字符串
81.public static String valueOf(char data[], int offset, int count)
指定字节数组中的一定范围来生成字符串
82.public static String copyValueOf(char data[], int offset, int count)
同上
83.public static String copyValueOf(char data[])
同上
84.public static String valueOf(boolean b)
将布尔值转换成字符串
85.public static String valueOf(char c)
将单个字节转换成字符串
86.public static String valueOf(int i)
将int转换成字符串
87.public static String valueOf(long l)
将long转换成字符串
88.public static String valueOf(float f)
将float转换成字符串
89.public static String valueOf(double d)
将double转换成字符串
90.public native String intern()
底层用C++实现的方法，在常量池中查找该字符串，如果找到，就返回常量池中等值字符串的地址，否则，就返回原地址
165
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
