} catch( NumberFormatException nfe) {
// If the property cannot be parsed into an int, ignore it.
}
}
// 设置缓存提供最大的值为h
high = h;
// 根据最大值和最小值计算数组长度，创建数组
cache = new Integer[(high - low) + 1];
int j = low;
// 循环填充数据，数组位置从0开始，数值从-128开始
for(int k = 0; k < cache.length; k++)
cache[k] = new Integer(j++);
// 假设缓存的最大值大于等于127
assert IntegerCache.high >= 127;
}
// 私有化构造方法
private IntegerCache() {}
}
[]( )3.构造方法
------------------------------------------------------------------------
### []( )1）参数为int
**Integer.java中的相关代码：**
public Integer(int value) {
// 保存到全局变量
this.value = value;
}
### []( )2）参数为String
**Integer.java中的相关代码：**
public Integer(String s) throws NumberFormatException {
// 调用parseInt方法，将字符串按十进制解析成int数值
this.value = parseInt(s, 10);
}
[]( )4\. parseInt方法
--------------------------------------------------------------------------------
将字符串型整数解析成int型数值。
**Integer.java中的相关代码：**
public static int parseInt(String s) throws NumberFormatException {
// 调用重载方法，按照十进制进行解析
return parseInt(s,10);
}
调用了重载的parseInt方法。
将指定进制的字符串型整数解析成int型的数。
**Integer.java中的相关代码：**
public static int parseInt(String s, int radix)
throws NumberFormatException
{
/*
* 注意: 在IntegerCache完成初始化之前的虚拟机初始化阶段
* 可以使用parseInt方法，注意不要使用valueOf方法。
*/
// 若字符串为空，则抛出异常
if (s == null) {
throw new NumberFormatException("null");
}
// 若数值的进制小于最小的进制数2，则抛出异常
// Character.MIN_RADIX = 2
if (radix < Character.MIN_RADIX) {
throw new NumberFormatException("radix " + radix +
" less than Character.MIN_RADIX");
}
// 若数值的进制大于最大的进制数36，则抛出异常
// Character.MAX_RADIX = 36
if (radix > Character.MAX_RADIX) {
throw new NumberFormatException("radix " + radix +
" greater than Character.MAX_RADIX");
}
int result = 0; // 用于保存转换后的数值
boolean negative = false; // 表示数值是否为负数，默认为正数
int i = 0, len = s.length(); // len表示字符串长度，i为指针
int limit = -Integer.MAX_VALUE; // 表示数值最大不能超过的范围
int multmin; // 每次进行乘以进制数之前，不能超过的范围，超过会发生溢出
int digit; // 用于承接字符串中每一位的数值
// 若长度大于0
if (len > 0) {
// 获取首位字符
char firstChar = s.charAt(0);
// 小于’0’，说明可能为‘+’或‘-’
if (firstChar < '0') {
// 若为负号
if (firstChar == '-') {
// 设置标志位为负
negative = true;
// 设置最大范围
limit = Integer.MIN_VALUE;
} else if (firstChar != '+') // 若不是加号，说明为其它字符，则抛出异常
throw NumberFormatException.forInputString(s);
//若长度为1，说明只有符号，没有数值，则抛出异常
if (len == 1)
throw NumberFormatException.forInputString(s);
// 指针指向下一位
i++;
}
// 计算乘以进制数前数值的最大范围
multmin = limit / radix;
// 计算方法：对不同进制的字符串，先用result乘以字符串本身的进制，
// 1）用result乘以字符串本身的进制数，保存到result中
// 2）从前向后依次取字符串中的字符，转换为十进制对应的数值，
// 累加到result上
// 3）循环执行1）和2），遍历所有字符，最后的结果就是对应的int型数。
// 同时为了防止在最大值出发生意外，采用负向累加的方法
// 即：对于正数，每次减去字符表示的数值，再乘以进制数，最后进行
// 符号调整。负数每次加上字符表示的数值，再乘以进制数，因为是负数，
// 所以最后不调整符号。
// 循环
while (i < len) {
// 获取字符，指针指向下一位
// 调用Character的digit方法
// 该方法会返回在指定进制下字符表示的十进制数
digit = Character.digit(s.charAt(i++),radix);
// 若返回的数小于0，则抛出异常
if (digit < 0) {
throw NumberFormatException.forInputString(s);
}
// 若超过乘以进制数前数值的最大范围
// 说明乘以进制数后会溢出，因此抛出异常
// 因为两个数都是负数，所以用<比较
if (result < multmin) {
throw NumberFormatException.forInputString(s);
}
// 乘以进制数，并保存到result中
result *= radix;
// 预先判断rusult减去字符对应的十进制数后会不会
// 超过最大值范围，超过则抛异常。
// 正常因该为result-digit<limit，为了防止result-digit溢出
// 所以digit移到了右边
if (result < limit + digit) {
throw NumberFormatException.forInputString(s);
}
// 减去digit，因为result为负数，所以相当于反向增大
result -= digit;
}
} else { // 若字符串长度等于0，则抛出异常
throw NumberFormatException.forInputString(s);
}
// 若是负数，直接返回，若是正数，则调整符号再返回
return negative ? result : -result;
}
[]( )5\. parseUnsignedInt方法
----------------------------------------------------------------------------------------
将String按照无符号十进制整数进行解析。
**Integer.java中的相关代码：**
public static int parseUnsignedInt(String s) throws NumberFormatException {
// 调用了重载方法，按照十进制进行解析
return parseUnsignedInt(s, 10);
}
调用了重载的parseUnsignedInt方法。
将指定进制的字符串型无符号整数解析成int型的数。
**Integer.java中的相关代码：**
public static int parseUnsignedInt(String s, int radix)
throws NumberFormatException {
// 若字符串为空，则抛出异常
if (s == null) {
throw new NumberFormatException("null");
}
// 获取字符串长度
int len = s.length();
// 若长度大于0
if (len > 0) {
// 获取首位的字符
char firstChar = s.charAt(0);
// 如果是减号，则抛出异常，因为是无符号型整数
if (firstChar == '-') {
throw new
NumberFormatException(String.format("Illegal leading minus sign " +
"on unsigned string %s.", s));
} else {// 若不是减号
// 先判断符号位是否被占用
// 即是否可以按照有符号情况的处理
// 若长度小于等于5或十进制下长度小于等于9
// 小于等于5是因为在int的数值范围内同时不占用符号位
// 只能有5个最大进制——36进制的字符
// 如果为10进制，满足范围要求和不占用符号位条件下
// 只能有9个十进制的字符
if (len <= 5 || (radix == 10 && len <= 9) ) {
// 满足要求，可以按有符号情况进行处理
// 调用parseInt处理
return parseInt(s, radix);
} else { // 若不能按照有符号数进行处理
// 调用Long的parseLong处理
long ell = Long.parseLong(s, radix);
// 若高32位为0，说明没有超过int的32位范围
if ((ell & 0xffff_ffff_0000_0000L) == 0) {
// 进行类型转换，返回
return (int) ell;
} else { // 若高32位不为0，说明有溢出，则抛出异常
throw new
NumberFormatException(String.format("String value %s exceeds " +"range of unsigned int.", s));
}
}
}
} else { // 长度小于等于0，则抛出异常
throw NumberFormatException.forInputString(s);
}
}
[]( )6\. valueOf方法
-------------------------------------------------------------------------------
将String类型的数转换为Integer对象。
### []( )1）参数为String
#### []( )指定进制数：
**Integer.java中的相关代码：**
public static Integer valueOf(String s, int radix) throws NumberFormatException {
// 调用parseInt解析成int数值
// 再调用重载方法，对int数值包装成Integer对象
return Integer.valueOf(parseInt(s,radix));
}
#### []( )不指定进制数：
**Integer.java中的相关代码：**
public static Integer valueOf(String s) throws NumberFormatException {
// 调用parseInt解析成int数值，默认10进制
// 再调用重载方法，对int数值包装成Integer对象
return Integer.valueOf(parseInt(s, 10));
}
### []( )2）参数为int
**Integer.java中的相关代码：**
public static Integer valueOf(int i) {
// 若参数满足缓存的数值范围
if (i >= IntegerCache.low && i <= IntegerCache.high)
// 在缓存中查找，返回
return IntegerCache.cache[i + (-IntegerCache.low)];
// 缓存中没有，则创建新对象，返回
return new Integer(i);
}
[]( )7\. byteValue方法
---------------------------------------------------------------------------------
获取当前数值对应的byte型数值。
**Integer.java中的相关代码：**
public byte byteValue() {
// 类型转换，返回
return (byte)value;
}
[]( )8\. shortValue方法
----------------------------------------------------------------------------------
获取当前数值对应的short型数值。
**Integer.java中的相关代码：**
public short shortValue() {
// 类型转换，返回
return (short)value;
}
[]( )9\. intValue方法
--------------------------------------------------------------------------------
获取当前数值对应的int型数值。
**Integer.java中的相关代码：**
public int intValue() {
// 直接返回
return value;
}
[]( )10\. longValue方法
----------------------------------------------------------------------------------
获取当前数值对应的long型数值。
**Integer.java中的相关代码：**
public long longValue() {
// 类型转换，返回
return (long)value;
}
[]( )11\. floatValue方法
-----------------------------------------------------------------------------------
获取当前数值对应的float型数值。
**Integer.java中的相关代码：**
public float floatValue() {
// 类型转换，返回
return (float)value;
}
[]( )12\. doubleValue方法
------------------------------------------------------------------------------------
获取当前数值对应的double型数值。
**Integer.java中的相关代码：**
public double doubleValue() {
// 类型转换，返回
return (double)value;
}
[]( )13\. toString方法
---------------------------------------------------------------------------------
将Integer对象转换为String对象。
### []( )1）无参数
**Integer.java中的相关代码：**
public String toString() {
// 调用重载方法
return toString(value);
}
### []( )2）参数为int
只能将数值转换为十进制表示的字符串。
**Integer.java中的相关代码：**
public static String toString(int i) {
// 若为最小值，直接返回"-2147483648"
if (i == Integer.MIN_VALUE)
return "-2147483648";
// 调用stringSize方法获取数字的长度
// 小于0时，因为有负号，所以加一
// 详解在a）处
int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i);
// 根据长度创建字符数组
char[] buf = new char[size];
// 调用getChars方法，对字符数组进行填充
// 详解在b）处
getChars(i, size, buf);
// 根据字符数组的内容，创建新的字符串
return new String(buf, true);
}
#### []( )a）stringSize方法
获取一个数字的长度。
**Integer.java中的相关代码：**
static int stringSize(int x) {
// 循环，判断该数是否i位数的最大值
for (int i=0; ; i++)
// 若该数大于i位数的最大值
if (x <= sizeTable[i])
// 因为i是从0开始，但没有0位数，
// 数字最少1位，所以要加1。
return i+1;
}
#### []( )b）getChars方法
该方法用于将数字填充到字符数组中。
**Integer.java中的相关代码：**
static void getChars(int i, int index, char[] buf) {
int q, r; // q，r用于承接个位、十位、百位、千位…的数字
int charPos = index; // 指针，从后向前填充字符数组
char sign = 0; // 用于保存数字的符号
// 若数值小于0
if (i < 0) {
// 设置符号为负号
sign = '-';
// 将负数变成正数
i = -i;
}
// 对于大于65536的数
// 先通过迭代，每次向字符数组中填充两个字符
while (i >= 65536) {
q = i / 100;
// 该操作实际效果等同于r = i - (q * 100);
// r实际上就是数值的后两位
r = i - ((q << 6) + (q << 5) + (q << 2));
// i此时变成了去除了后两位数字的数
i = q;
// 从数组中查找，填充字符数组，指针向前移动
buf [--charPos] = DigitOnes[r];
buf [--charPos] = DigitTens[r];
}
// 对于小于65536的数字
// 每次向字符数组中填充一个字符
for (;;) {
// 该操作相当于q = i /10;
q = (i * 52429) >>> (16+3);
// 该操作相当于r = i-(q*10);
r = i - ((q << 3) + (q << 1));
// 经过上面两部操作，r的值为i的最后一位
// 查找数组，填充字符数组，指针向前移动
buf [--charPos] = digits [r];
// 此时i变为去除最后一位数字的数
i = q;
// 若i为0，说明没有数字可以填充，跳出循环
if (i == 0) break;
}
// 若sign不为0,说明为负数
if (sign != 0) {
// 填充负号
buf [--charPos] = sign;
}
}
### []( )3）参数为int
支持将数值转换为不同进制表示的字符串。
**Integer.java中的相关代码：**
public static String toString(int i, int radix) {
// 若进制数大于最大进制数36或小于最小进制数2
if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
// 则默认进制数为10
radix = 10;
// 若进制为10
if (radix == 10) {
// 调用重载的toString方法处理
return toString(i);
}
// 创建字符数组
// 长度最长时为二进制情况下，共32位，因为可能有负号
// 所以加1，共33位
char buf[] = new char[33];
// 标志位，用于判断数值的正负
boolean negative = (i < 0);
// 指针，从后向前
int charPos = 32;
// 若为正数，则将正值变成负值
// 这样处理，可以防止正向溢出
if (!negative) {
i = -i;
}
// 当负的数值小于等于负的进制数
while (i <= -radix) {
// i除以radix取余，再将余数变成正数，查找数组
// 填充到字符数组，指针向前移动
buf[charPos--] = digits[-(i % radix)];
// 实际效果相当于去掉i小于进制数radix的部分
i = i / radix;
}
// 填充最后一个字符
buf[charPos] = digits[-i];
// 若为负数
if (negative) {
// 填充负号，指针向前移动
buf[--charPos] = '-';
}
// 根据字符数组的内容和长度，创建新字符串
return new String(buf, charPos, (33 - charPos));
}
[]( )14\. hashCode方法
---------------------------------------------------------------------------------
获取当前对象的哈希值。
**Integer.java中的相关代码：**
@Override
public int hashCode() {
// 调用静态方法hashCode
return Integer.hashCode(value);
}
调用静态方法hashCode。
**Integer.java中的相关代码：**
public static int hashCode(int value) {
// 直接返回数值
return value;
}
[]( )15\. equals方法
-------------------------------------------------------------------------------
比较两个Integer对象的值是否相等。
**Integer.java中的相关代码：**
public boolean equals(Object obj) {
// 若为Integer对象
if (obj instanceof Integer) {
// 比较两个对象的值是否相等
return value == ((Integer)obj).intValue();
}
// 若不是Integer对象，返回false
return false;
}
[]( )16\. getInteger方法
-----------------------------------------------------------------------------------
从系统变量中读取Integer数值。
### []( )1）不指定默认值
**Integer.java中的相关代码：**
public static Integer getInteger(String nm) {
// 调用重载方法，若获取不到，则返回为空
// 详解在3）处
return getInteger(nm, null);
}
### []( )2）指定默认值
**Integer.java中的相关代码：**
public static Integer getInteger(String nm, int val) {
// 调用重载方法，若获取不到，则返回为空
// 详解在3）处
Integer result = getInteger(nm, null);
// 若返回值为空，则将默认值包装成Integer对象，返回
// 若返回值不为空，则直接返回
return (result == null) ? Integer.valueOf(val) : result;
}
### []( )3）重载的getInteger方法
**Integer.java中的相关代码：**
public static Integer getInteger(String nm, Integer val) {
// 用于保存获取的系统变量
String v = null;
try {
// 获取系统变量
v = System.getProperty(nm);
} catch (IllegalArgumentException | NullPointerException e) {
}
// 若系统变量不为空
if (v != null) {
try {
// 将系统变量进行解码成Integer对象，返回
return Integer.decode(v);
} catch (NumberFormatException e) {
}
}
// 若系统变量不存在，则返回默认值
return val;
}
[]( )17\. decode方法
-------------------------------------------------------------------------------
将字符串解码成Integer对象。
该方法支持带有进制标识符(如：0x，#)的8、10、16进制的字符串，但是字符串中不能有空格。
**Integer.java中的相关代码：**
public static Integer decode(String nm) throws NumberFormatException {
// 默认进制为10
int radix = 10;
// 指针从0开始
int index = 0;
// 判断正负数的标志位，默认正数
boolean negative = false;
// 用于保存解码后的结果
Integer result;
// 若长度为0，抛出异常
if (nm.length() == 0)
throw new NumberFormatException("Zero length string");
// 获取首位字符
char firstChar = nm.charAt(0);
// 若为负号
if (firstChar == '-') {
// 设置标志位，指针向后移动
negative = true;
index++;
// 若为正号
} else if (firstChar == '+')
// 指针向后移动
index++;
// 对进制标识符进行处理
// 若以“0x”或“0X”开头
if (nm.startsWith("0x", index) || nm.startsWith("0X", index)) {
// 指针后移两位
index += 2;
// 设置进制为16进制
radix = 16;
} // 若以“#”开头
else if (nm.startsWith("#", index)) {
// 指针向后移动
index ++;
// 设置进制为16进制
radix = 16;
} // 若以“0”开头，同时不是只有一个0
else if (nm.startsWith("0", index) && nm.length() > 1 + index) {
// 指针向后移动
index ++;
// 设置进制为8进制
radix = 8;
}
// 若在进制标识符后出现正负号，则抛出异常
if (nm.startsWith("-", index) || nm.startsWith("+", index))
throw new NumberFormatException("Sign character in wrong position");
try {
// 截取数值部分，调用valueOf方法进行解析
result = Integer.valueOf(nm.substring(index), radix);
// 对数值的正负进行调整
result = negative ? Integer.valueOf(-result.intValue()) : result;
} catch (NumberFormatException e) {
// 若数值为Integer.MIN_VALUE，将发生异常
// 因为Integer的最大负值的绝对值比最大正值的绝对值大1
// 若为负数，把负号拼接到数值前面
String constant = negative ? ("-" + nm.substring(index))
: nm.substring(index);
// 调用valueOf方法进行解析
result = Integer.valueOf(constant, radix);
}
// 返回
return result;
}
[]( )18\. compare方法
--------------------------------------------------------------------------------
比较两个int数值。
**Integer.java中的相关代码：**
public static int compare(int x, int y) {
// 若x小于y，则返回-1。
// 若x大于y，则返回1。
// 若x等于y，则返回0。
return (x < y) ? -1 : ((x == y) ? 0 : 1);
}
[]( )19\. compareTo方法
----------------------------------------------------------------------------------
比较两个Integer数值。
若相等则返回0，若小于anotherInteger则返回-1，若大于anotherInteger则返回1。
**Integer.java中的相关代码：**
public int compareTo(Integer anotherInteger) {
// 调用compare方法
return compare(this.value, anotherInteger.value);
}
[]( )20\. compareUnsigned方法
----------------------------------------------------------------------------------------
比较两个无符号数。
若x等于y则返回0，若x小于y则返回一个小于0的数，若x大于y则返回一个大于0的数。
**Integer.java中的相关代码：**
public static int compareUnsigned(int x, int y) {
// 调用compare方法
// 加上MIN_VALUE，占用符号位，变成无符号整数
return compare(x + MIN_VALUE, y + MIN_VALUE);
}
[]( )21\. toUnsignedLong方法
---------------------------------------------------------------------------------------
将int数变成无符号long型数。
**Integer.java中的相关代码：**
public static long toUnsignedLong(int x) {
// 类型转换，和掩码进行与运算，让该是1的是1，该是0的是0
return ((long) x) & 0xffffffffL;
}
[]( )22\. highestOneBit方法
--------------------------------------------------------------------------------------
在数值i的二进制表示中，除去符号位，从高到低找到第一个为1的位置p，返回数值为2的(p-1)次方。如果数值i的二进制表示中除去符号位没有1，则返回0。
**Integer.java中的相关代码：**
public static int highestOneBit(int i) {
i |= (i >> 1);
i |= (i >> 2);
i |= (i >> 4);
i |= (i >> 8);
i |= (i >> 16);
return i - (i >>> 1);
}
[]( )23\. lowestOneBit方法
-------------------------------------------------------------------------------------
在数值i的二进制表示中，除去符号位，从低到高找到第一个为1的位置p，返回数值为2的(p-1)次方。如果数值i的二进制表示中除去符号位没有1，则返回0。
**Integer.java中的相关代码：**
public static int lowestOneBit(int i) {
return i & -i;
}
[]( )24\. numberOfLeadingZeros方法
---------------------------------------------------------------------------------------------
获取数值i的二进制表示下，前导零的数量。
**Integer.java中的相关代码：**
public static int numberOfLeadingZeros(int i) {
if (i == 0)
return 32;
int n = 1;
if (i >>> 16 == 0) { n += 16; i <<= 16; }
if (i >>> 24 == 0) { n += 8; i <<= 8; }
if (i >>> 28 == 0) { n += 4; i <<= 4; }
if (i >>> 30 == 0) { n += 2; i <<= 2; }
n -= i >>> 31;
return n;
}
[]( )25\. numberOfTrailingZeros方法
----------------------------------------------------------------------------------------------
获取数值i的二进制表示下，后补零的数量。
**Integer.java中的相关代码：**
public static int numberOfTrailingZeros(int i) {
int y;
if (i == 0) return 32;
int n = 31;
y = i <<16; if (y != 0) { n = n -16; i = y; }
y = i << 8; if (y != 0) { n = n - 8; i = y; }
y = i << 4; if (y != 0) { n = n - 4; i = y; }
y = i << 2; if (y != 0) { n = n - 2; i = y; }
return n - ((i << 1) >>> 31);
}
[]( )26\. bitCount方法
---------------------------------------------------------------------------------
获取数值i的二进制表示中1的数量。
**Integer.java中的相关代码：**
public static int bitCount(int i) {
i = i - ((i >>> 1) & 0x55555555);
i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
i = (i + (i >>> 4)) & 0x0f0f0f0f;
i = i + (i >>> 8);
i = i + (i >>> 16);
return i & 0x3f;
}
[]( )27\. rotateLeft方法
-----------------------------------------------------------------------------------
将数值i在二进制表示下循环左移distance位。
**Integer.java中的相关代码：**
public static int rotateLeft(int i, int distance) {
return (i << distance) | (i >>> -distance);
}
[]( )28\. rotateRight方法
------------------------------------------------------------------------------------
将数值i在二进制表示下循环右移distance位。
**Integer.java中的相关代码：**
public static int rotateRight(int i, int distance) {
return (i >>> distance) | (i << -distance);
}
[]( )29\. reverse方法
--------------------------------------------------------------------------------
# **学习分享，共勉**
这里是小编拿到的学习资源，其中包括“中高级Java开发面试高频考点题笔记300道.pdf”和“Java核心知识体系笔记.pdf”文件分享，内容丰富，**囊括了JVM、锁、并发、Java反射、Spring原理、微服务、Zookeeper、数据库、数据结构等大量知识点。同时还有Java进阶学习的知识笔记脑图（内含大量学习笔记）！**
> **资料整理不易，读者朋友可以转发分享下！**
**Java核心知识体系笔记.pdf**
**中高级Java开发面试高频考点题笔记300道.pdf**
**架构进阶面试专题及架构学习笔记脑图**
**Java架构进阶学习视频分享**
y = i << 4; if (y != 0) { n = n - 4; i = y; }
y = i << 2; if (y != 0) { n = n - 2; i = y; }
return n - ((i << 1) >>> 31);
}
获取数值i的二进制表示中1的数量。
Integer.java中的相关代码：
public static int bitCount(int i) {
i = i - ((i >>> 1) & 0x55555555);
i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
i = (i + (i >>> 4)) & 0x0f0f0f0f;
i = i + (i >>> 8);
i = i + (i >>> 16);
return i & 0x3f;
}
将数值i在二进制表示下循环左移distance位。
Integer.java中的相关代码：
public static int rotateLeft(int i, int distance) {
return (i << distance) | (i >>> -distance);
}
将数值i在二进制表示下循环右移distance位。
Integer.java中的相关代码：
public static int rotateRight(int i, int distance) {
return (i >>> distance) | (i << -distance);
}
学习分享，共勉
这里是小编拿到的学习资源，其中包括“中高级Java开发面试高频考点题笔记300道.pdf”和“Java核心知识体系笔记.pdf”文件分享，内容丰富，囊括了JVM、锁、并发、Java反射、Spring原理、微服务、Zookeeper、数据库、数据结构等大量知识点。同时还有Java进阶学习的知识笔记脑图（内含大量学习笔记）！
资料整理不易，读者朋友可以转发分享下！
Java核心知识体系笔记.pdf
[外链图片转存中…(img-mQ7Bjb7l-1718781570670)]
中高级Java开发面试高频考点题笔记300道.pdf
[外链图片转存中…(img-jXYZol6X-1718781570671)]
架构进阶面试专题及架构学习笔记脑图
[外链图片转存中…(img-oDz7Pxx0-1718781570672)]
Java架构进阶学习视频分享
248
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
