Java String类源码阅读笔记

/**

• 参数为一个char字符数组

• 将数组值拷贝赋给不可变字符数组

• 这里为什么不直接赋值呢？

• 因为参数char value[]是可变的，如果直接赋值，当参数数组发生变化时，就会影响到新生成的String对象，着就破坏的String的“不可变性”。

*/

public String(char value[]) {

this.value = Arrays.copyOf(value, value.length);

}

• 参数为字符数组(指定起止位置)的有参构造方法

/**

• 参数为char字符数组,offset(起始位置，偏移量),count(个数)

• 在char数组的基础上，从offset位置开始计数count个，构成一个新的String的字符串

**/

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;

}

}

// 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);

}

• 参数为int数组(指定起止位置)的有参构造方法

/**

• 参数为int字符数组,offset(起始位置，偏移量),count(个数)

• int数组的元素则是字符对应的ASCII整数值

*/

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;

}

}

// 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];

if (Character.isBmpCodePoint©)

continue;

else if (Character.isValidCodePoint©)

n++;

else throw new IllegalArgumentException(Integer.toString©);

}

// 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©)

v[j] = (char)c;

else

Character.toSurrogates(c, v, j++);

}

this.value = v;

}

有一些标为过时我们就不再关注了。

• 参数为byte数组(指定起止位置、字符编码)的有参构造方法

/**

• 参数为byte数组,offset(起始位置，偏移量),长度，和字符编码格式

• 传入一个byte数组，从offset开始截取length个长度，其字符编码格式为charsetName，如UTF-8

*/

public String(byte bytes[], int offset, int length, String charsetName)

throws UnsupportedEncodingException {

if (charsetName == null)

throw new NullPointerException(“charsetName”);

//判断byte数组是否越界

checkBounds(bytes, offset, length);

this.value = StringCoding.decode(charsetName, bytes, offset, length);

}

StringCoding类的decode方法：

static char[] decode(String charsetName, byte[] ba, int off, int len)

throws UnsupportedEncodingException

{

StringDecoder sd = deref(decoder);

String csn = (charsetName == null) ? “ISO-8859-1” : charsetName;

if ((sd == null) || !(csn.equals(sd.requestedCharsetName())

|| csn.equals(sd.charsetName()))) {

sd = null;

try {

Charset cs = lookupCharset(csn);

if (cs != null)

sd = new StringDecoder(cs, csn);

} catch (IllegalCharsetNameException x) {}

if (sd == null)

throw new UnsupportedEncodingException(csn);

set(decoder, sd);

}

return sd.decode(ba, off, len);

}

其余的从byte数组构造String的构造方法都是调用这个方法，这里就不再赘述。

• 参数为StringBuffer的有参构造方法

/**

• 参数类型为StringBuffer,将StringBuffer值数组拷贝给String的值数组

• 线程安全的

**/

public String(StringBuffer buffer) {

synchronized(buffer) {

this.value = Arrays.copyOf(buffer.getValue(), buffer.length());

}

}

使用StringBuilder为参数构造类似，不过不是线程安全的。

4、长度/判空

---

• length()

/**

• 返回value数组的长度

*/

public int length() {

return value.length;

}

• isEmpty()

/**

• value数组的长度是否为0

*/

public boolean isEmpty() {

return value.length == 0;

}

5、取字符

---

• charAt(int index)

/**

• 获取下标为index的value数组字符

*/

public char charAt(int index) {

if ((index < 0) || (index >= value.length)) {

throw new StringIndexOutOfBoundsException(index);

}

return value[index];

}

• codePointAt(int index)

/**

• 返回String对象的char数组index位置的元素的ASSIC码(int类型)

*/

public int codePointAt(int index) {

if ((index < 0) || (index >= value.length)) {

throw new StringIndexOutOfBoundsException(index);

}

return Character.codePointAtImpl(value, index, value.length);

}

• codePointBefore(int index)

/**

• 返回index位置元素的前一个元素的ASSIC码(int型)

*/

public int codePointBefore(int index) {

int i = index - 1; //获得index前一个元素的索引位置

if ((i < 0) || (i >= value.length)) { //所以，index不能等于0，因为i = 0 - 1 = -1

throw new StringIndexOutOfBoundsException(index);

}

return Character.codePointBeforeImpl(value, index, 0);

}

• getChars(char dst[], int dstBegin)

/**

• 将value数组dstBegin下标起的字符拷贝给dst

*/

void getChars(char dst[], int dstBegin) {

System.arraycopy(value, 0, dst, dstBegin, value.length);

}

6、比较

---

• equals(Object anObject)

/**

• String的equals方法，重写了Object的equals方法（区分大小写）

• 比较的是两个字符串的值是否相等

• 参数是一个Object对象，而不是一个String对象。这是因为重写的是Object的equals方法，所以是Object

*/

public boolean equals(Object anObject) {

//如果较地址是否相等，是同一个对象

if (this == anObject) {

return true;

}

//判断anObject是否是String类型

if (anObject instanceof String) {

//将anObject转换为String类型

String anotherString = (String)anObject;

int n = value.length;

//判断anotherString是否和当前String的value数组长度相同

if (n == anotherString.value.length) {

//v1为当前String的值，v2为参数对象anotherString的值

char v1[] = value;

char v2[] = anotherString.value;

int i = 0;

//每次循环长度-1,直到长度消耗完，循环结束

while (n-- != 0) {

//相同下标位置字符串比较，有一个不相同，返回false

if (v1[i] != v2[i])

return false;

i++;

}

//如比较期间没有问题，则说明相等，返回true

return true;

}

}

return false;

}

• equalsIgnoreCase(String anotherString)

/**

• 这也是一个String的equals方法，与上一个方法不用，该方法(不区分大小写)，从名字也能看出来

• 是对String的equals方法的补充。

• 这里参数这是一个String对象，而不是Object了，因为这是String本身的方法，不是重写谁的方法

*/

public boolean equalsIgnoreCase(String anotherString) {

//先判断是否为同一个对象

return (this == anotherString) ? true

(anotherString != null)

//再判断长度是否相等

&& (anotherString.value.length == value.length)

//再调用regionMatchs方法

&& regionMatches(true, 0, anotherString, 0, value.length);

}

• compareTo(String anotherString)

/**

• 这是一个比较字符串中字符大小的函数，因为String实现了Comparable接口，所以重写了compareTo方法

• Comparable是排序接口。若一个类实现了Comparable接口，就意味着该类支持排序。

• 实现了Comparable接口的类的对象的列表或数组可以通过Collections.sort或Arrays.sort进行自动排序。

• 参数是需要比较的另一个String对象

• 返回的int类型，正数为大，负数为小，是基于字符的ASSIC码比较的

*/

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;

}

7、包含

---

• startsWith(String prefix, int toffset)

/**

• 作用就是当前对象[toffset,toffset + prefix.value.lenght]区间的字符串片段等于prefix

• 也可以说当前对象的toffset位置开始是否以prefix作为前缀

• prefix是需要判断的前缀字符串，toffset是当前对象的判断起始位置

*/

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;

}

//循环pc次，既prefix的长度

while (–pc >= 0) {

//每次比较当前对象的字符串的字符是否跟prefix一样

if (ta[to++] != pa[po++]) {

//一样则pc–,to++,po++,有一个不同则返回false

return false;

}

}

return true;

}

• startsWith(String prefix)

// 判断当前对象[0, prefix.value.lenght]区间的字符串片段等于prefix。

public boolean startsWith(String prefix) {

return startsWith(prefix, 0);

}

• endsWith(String suffix)

//判断当前字符串对象是否以字符串prefix结尾

public boolean endsWith(String suffix) {

return startsWith(suffix, value.length - suffix.value.length);

}

//是否含有CharSequence这个子类元素，通常用于StrngBuffer,StringBuilder

public boolean contains(CharSequence s) {

return indexOf(s.toString()) > -1;

}

8、hashCode

---

/**

• String类重写了Object类的hashCode方法。

• 哈希表来实现的数据结构来使用，比如String对象要放入HashMap中。

*/

public int hashCode() {

//hash是成员变量，所以默认为0

int h = hash;

如果hash为0，且字符串对象长度大于0，不为""

if (h == 0 && value.length > 0) {

//获取当前对象的value

char val[] = value;

// 通过算法s[0]31^(n-1) + s[1]31^(n-2) + … + s[n-1]计算hash值

for (int i = 0; i < value.length; i++) {

//每次都是31 * 每次循环获得的h +第i个字符的ASSIC码

h = 31 * h + val[i];

}

hash = h;

}

return h;

}

9、查询索引

---

• indexOf(int ch, int fromIndex)

/**

• index方法就是返回ch字符第一次在字符串中出现的位置

• 既从fromIndex位置开始查找，从头向尾遍历，ch整数对应的字符在字符串中第一次出现的位置

• -1代表字符串没有这个字符，整数代表字符第一次出现在字符串的位置

*/

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;

}

一个char占用两个字节，如果ch小于2的16次方（65536），绝大多数字符都在此范围内

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;

//从 fromIndex位置起遍历value数组

for (int i = fromIndex; i < max; i++) {

//存在相等的字符，返回第一次出现该字符的索引位置，并终止循环

if (value[i] == ch) {

return i;

}

}

return -1;

} else {

return indexOfSupplementary(ch, fromIndex);

}

}

public int indexOf(int ch) {

return indexOf(ch, 0);//从第一个字符开始搜索

}

• indexOf(String str)

/**

• 这是一个不对外公开的静态函数

• source就是原始字符串，sourceOffset就是原始字符串的偏移量，起始位置。

• sourceCount就是原始字符串的长度，target就是要查找的字符串。

• fromIndex就是从原始字符串的第fromIndex开始遍历

*/

static int indexOf(char[] source, int sourceOffset, int sourceCount,

String target, int fromIndex) {

return indexOf(source, sourceOffset, sourceCount,

target.value, 0, target.value.length,

fromIndex);

}

/**

• 从fromIndex开始遍历，返回第一次出现str字符串的位置

*/

public int indexOf(String str, int fromIndex) {

return indexOf(value, 0, value.length,

str.value, 0, str.value.length, fromIndex);

}

/**

• 返回第一次出现的字符串的位置

*/

public int indexOf(String str) {

return indexOf(str, 0);

}

• lastIndexOf(int ch)

/**

• 从尾部向头部遍历，返回cn第一次出现的位置，value.length - 1就是起点

• 为了理解，我们可以认为是返回cn对应的字符在字符串中最后出现的位置

• ch是字符对应的整数

*/

public int lastIndexOf(int ch) {

return lastIndexOf(ch, value.length - 1);

}

• public int lastIndexOf(int ch, int fromIndex)

/**

• 从尾部向头部遍历，从fromIndex开始作为起点，返回ch对应字符第一次在字符串出现的位置

• 既从头向尾遍历，返回cn对应字符在字符串中最后出现的一次位置，fromIndex为结束点

*/

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);

}

}

10、获取子串

---

• substring(int beginIndex)

/**

• 截取当前字符串对象的片段，组成一个新的字符串对象

• beginIndex为截取的初始位置，默认截到len - 1位置

*/

public String substring(int beginIndex) {

if (beginIndex < 0) {

throw new StringIndexOutOfBoundsException(beginIndex);

}

int subLen = value.length - beginIndex;

if (subLen < 0) {

throw new StringIndexOutOfBoundsException(subLen);

}

//利用构造函数生成新的String对象

return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);

}

• substring(int beginIndex, int endIndex)

/**

• 截取一个区间范围

• [beginIndex,endIndex)，不包括endIndex

*/

public String substring(int beginIndex, int endIndex) {

if (beginIndex < 0) {

throw new StringIndexOutOfBoundsException(beginIndex);

}

if (endIndex > value.length) {

throw new StringIndexOutOfBoundsException(endIndex);

}

int subLen = endIndex - beginIndex;

if (subLen < 0) {

throw new StringIndexOutOfBoundsException(subLen);

}

return ((beginIndex == 0) && (endIndex == value.length)) ? this

new String(value, beginIndex, subLen);

}

11、拼接

---

• concat(String str)

/**

• String的拼接函数

• 例如:String str = “abc”; str.concat(“def”) output: “abcdef”

*/

public String concat(String str) {

int otherLen = str.length();

if (otherLen == 0) {

return this;

}

//获得当前String对象的长度

int len = value.length;

//将数组扩容，将value数组拷贝到buf数组中，长度为len + str.lenght

char buf[] = Arrays.copyOf(value, len + otherLen);

//然后将str字符串从buf字符数组的len位置开始覆盖，得到一个完整的buf字符数组

str.getChars(buf, len);

//生成新的Strintg对象

return new String(buf, true);

}

• join(CharSequence delimiter, CharSequence… elements)

/**

• 拼接CharSequence，包含String、StringBuilder、StringBuffer

*/

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();

}

12、替换

---

• 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 */

//循环len次

while (++i < len) {

//找到第一个旧字符，打断循环

if (val[i] == oldChar) {

break;

}

}

//如果第一个旧字符的位置小于len

if (i < len) {

//new一个字符数组，len个长度

char buf[] = new char[len];

for (int j = 0; j < i; j++) {

//把旧字符的前面的字符都复制到新字符数组上

buf[j] = val[j];

}

//从i位置开始遍历

while (i < len) {

char c = val[i];

//发现旧字符就替换，不相关的则直接复制

buf[i] = (c == oldChar) ? newChar : c;

i++;

}

//通过新字符数组buf重构一个新String对象

return new String(buf, true);

}

}

return this;

}

• replaceAll(String regex, String replacement)

//当不是正规表达式时，与replace效果一样，都是全体换。如果字符串的正则表达式，则规矩表达式全体替换

public String replaceAll(String regex, String replacement) {

return Pattern.compile(regex).matcher(this).replaceAll(replacement);

}

13、切割

---

• split(String regex, int limit)

/**

• 根据切割符号切割字符串

*/

public String[] split(String regex, int limit) {

/* 1、单个字符，且不是".$|()[{^?*+\"其中一个

• 2、两个字符，第一个是""，第二个大小写字母或者数字

*/

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;

//大于0，limitedtrue,反之limitedfalse

boolean limited = limit > 0;

ArrayList list = new ArrayList<>();

while ((next = indexOf(ch, off)) != -1) {

//当参数limit<=0 或者 集合list的长度小于 limit-1

if (!limited || list.size() < limit - 1) {

list.add(substring(off, next));

off = next + 1;

} else { // last one

//判断最后一个list.size() == limit - 1

list.add(substring(off, value.length));

off = value.length;

break;

}

}

//如果没有一个能匹配的，返回一个新的字符串，内容和原来的一样

if (off == 0)

return new String[]{this};

// 当 limit<=0 时，limited==false,或者集合的长度 小于 limit是，截取添加剩下的字符串

if (!limited || list.size() < limit)

list.add(substring(off, value.length));

// 当 limit == 0 时，如果末尾添加的元素为空（长度为0），则集合长度不断减1，直到末尾不为空

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);

}

• split(String regex)

public String[] split(String regex) {

return split(regex, 0);

}

14、大小写转换

---

• toLowerCase(Locale locale)

/**

• 将大写字符转换为小写

*/

public String toLowerCase(Locale locale) {

if (locale == null) {

throw new NullPointerException();

}

int firstUpper;

final int len = value.length;

/* Now check if there are any characters that need to be changed. */

scan: {

for (firstUpper = 0 ; firstUpper < len; ) {

char c = value[firstUpper];

//判断字符是否大写

if ((c >= Character.MIN_HIGH_SURROGATE)

&& (c <= Character.MAX_HIGH_SURROGATE)) {

int supplChar = codePointAt(firstUpper);

if (supplChar != Character.toLowerCase(supplChar)) {

break scan;

}

firstUpper += Character.charCount(supplChar);

} else {

if (c != Character.toLowerCase©) {

break scan;

}

firstUpper++;

}

}

return this;

}

char[] result = new char[len];

int resultOffset = 0; /* result may grow, so i+resultOffset

• is the write location in result */

/* Just copy the first few lowerCase characters. */

System.arraycopy(value, 0, result, 0, firstUpper);

String lang = locale.getLanguage();

boolean localeDependent =

(lang == “tr” || lang == “az” || lang == “lt”);

char[] lowerCharArray;

int lowerChar;

int srcChar;

int srcCount;

for (int i = firstUpper; i < len; i += srcCount) {

srcChar = (int)value[i];

if ((char)srcChar >= Character.MIN_HIGH_SURROGATE

&& (char)srcChar <= Character.MAX_HIGH_SURROGATE) {

srcChar = codePointAt(i);

srcCount = Character.charCount(srcChar);

} else {

srcCount = 1;

}

if (localeDependent ||

srcChar == ‘\u03A3’ || // GREEK CAPITAL LETTER SIGMA

srcChar == ‘\u0130’) { // LATIN CAPITAL LETTER I WITH DOT ABOVE

lowerChar = ConditionalSpecialCasing.toLowerCaseEx(this, i, locale);

} else {

lowerChar = Character.toLowerCase(srcChar);

}

if ((lowerChar == Character.ERROR)

|| (lowerChar >= Character.MIN_SUPPLEMENTARY_CODE_POINT)) {

if (lowerChar == Character.ERROR) {

lowerCharArray =

ConditionalSpecialCasing.toLowerCaseCharArray(this, i, locale);

} else if (srcCount == 2) {

resultOffset += Character.toChars(lowerChar, result, i + resultOffset) - srcCount;

continue;

} else {

lowerCharArray = Character.toChars(lowerChar);

}

/* Grow result if needed */

int mapLen = lowerCharArray.length;

if (mapLen > srcCount) {

char[] result2 = new char[result.length + mapLen - srcCount];

System.arraycopy(result, 0, result2, 0, i + resultOffset);

result = result2;

}

for (int x = 0; x < mapLen; ++x) {

result[i + resultOffset + x] = lowerCharArray[x];

}

resultOffset += (mapLen - srcCount);

} else {

result[i + resultOffset] = (char)lowerChar;

}

}

return new String(result, 0, len + resultOffset);

}

15、去空格

---

• trim()

/**

• 去除字符串首尾部分的空值，如,’ ’ or " “,非”"

• 原理是通过substring去实现的，首尾各一个指针

• 头指针发现空值就++，尾指针发现空值就–

• ’ '的Int值为32，其实不仅仅是去空的作用，应该是整数值小于等于32的去除掉

*/

public String trim() {

//代表尾指针，实际是尾指针+1的大小

int len = value.length;

//代表头指针

int st = 0;

char[] val = value; /* avoid getfield opcode */

//st<len,且字符的整数值小于32则代表有空值，st++

while ((st < len) && (val[st] <= ’ ')) {

st++;

}

//len - 1才是真正的尾指针，如果尾部元素的整数值<=32,则代表有空值，len–

while ((st < len) && (val[len - 1] <= ’ ')) {

len–;

}

截取st到len的字符串(不包括len位置)

return ((st > 0) || (len < value.length)) ? substring(st, len) : this;

}

16、字符/字符串转换

---

• toString()

//返回自己

public String toString() {

return this;

}

• toCharArray()

/**

• 返回value数组的拷贝

*/

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;

}

• valueOf(Object obj)

//将Object转换为字符串

public static String valueOf(Object obj) {

return (obj == null) ? “null” : obj.toString();

}

17、格式化

---

• format(String format, Object… args)

//JAVA字符串格式化

//新字符串使用本地语言环境，制定字符串格式和参数生成格式化的新字符串。

public static String format(String format, Object… args) {

return new Formatter().format(format, args).toString();

}

• format(Locale l, String format, Object… args)

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Android开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
，st++

while ((st < len) && (val[st] <= ’ ')) {

st++;

}

//len - 1才是真正的尾指针，如果尾部元素的整数值<=32,则代表有空值，len–

while ((st < len) && (val[len - 1] <= ’ ')) {

len–;

}

截取st到len的字符串(不包括len位置)

return ((st > 0) || (len < value.length)) ? substring(st, len) : this;

}

16、字符/字符串转换

---

• toString()

//返回自己

public String toString() {

return this;

}

• toCharArray()

/**

• 返回value数组的拷贝

*/

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;

}

• valueOf(Object obj)

//将Object转换为字符串

public static String valueOf(Object obj) {

return (obj == null) ? “null” : obj.toString();

}

17、格式化

---

• format(String format, Object… args)

//JAVA字符串格式化

//新字符串使用本地语言环境，制定字符串格式和参数生成格式化的新字符串。

public static String format(String format, Object… args) {

return new Formatter().format(format, args).toString();

}

• format(Locale l, String format, Object… args)

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

[外链图片转存中…(img-0LwwAQVQ-1715330884493)]

[外链图片转存中…(img-sBToYLNo-1715330884494)]

[外链图片转存中…(img-xbJq4i50-1715330884494)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Android开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！