包装类及其对应的基本数据类型
9.1.1 Integer 类1、Integer类有两种构造方法
（1）Integer (int number)
该方法以一个int型变量作为参数来获取Integer对象。
Integer number = new Integer(7);
(2)Integer (String str)
该方法以一个String型变量作为参数创建Integer对象。
Integer number = new Integer("45");
2、常用方法
Integer类的常用方法
| 方法 | 返回值 | 功能描述 |
| valueOf(String str) | Integer | 返回保存指定的String值的Integer对象 |
| parseInt(String str) | int | 返回包含在由str指定的字符串中的数字的等价整数值 |
| toString() | String | 返回一个表示该Integer值的String对象（可指定进制基数） |
| toBinaryString(int i) | String | 以二进制无符号整数形式返回一个整数参数的字符串表示形式 |
| toHexString(int i) | String | 以十六进制无符号整数形式返回一个整数参数的字符串表示形式 |
| toOctalString(int i) | String | 以八进制无符号整数形式返回一个整数参数的字符串表示形式 |
| equals(Object IntegerObj) | boolean | 比较此对象与指定的对象是否相等 |
| intValue() | int | 以int型返回此Integer对象 |
| shortValue() | short | 以short型返回此Integer对象 |
| byteValue() | byte | 以byte型返回此Integer对象 |
| compareTo(Integeranother Integer) | int | 在数字上比较两个Integer对象。如果这两个值相等，则返回0；如果调用对象的数值小于anotherInteger的数值，则返回负值 |
public class Demo { //创建类Demo
public static void main(String[] args) { //主方法
int num = Integer.parseInt("456"); //将字符串转换为int类型
Integer iNum = Integer.valueOf("456"); //通过构造函数创建一个Integer对象
System.out.println("int数据与Integer对象的比较 " + iNum.equals(num));
String str2 = Integer.toBinaryString(num); //获取数字的二进制表示
String str3 = Integer.toHexString(num); //获取数字的十六进制表示
String str4 = Integer.toOctalString(num); //获取数字的八进制表示
String str5 = Integer.toString(num); //获取数字的十五进制表示
System.out.println("456的二进制表示为：" + str2);
System.out.println("456的十六进制表示为：" + str3);//将常数值输出
System.out.println("456的八进制表示为：" + str4);
System.out.println("456的十五进制表示为：" + str5);
}
}
3、常量
Integer类提供了以下4个常量
MAX_VALUE:表示int类型可取的最大值，即2-1。
MIN_VALUE:表示int类型可取的最小值，即-2。
SIZE:用来以二进制补码形式表示int值的位数。
TYPE:表示基本类型int的Class实例。
public class GetCon { //创建类GetCon
public static void main(String[] args) { //主方法
// TODO Auto-generated method stub
int maxint = Integer.MAX_VALUE; //获取Integer类的常量值
int minint = Integer.MAX_VALUE;
int intsize = Integer.SIZE;
System.out.println("int类型可取的最大值是：" + maxint); //将常量值输出
System.out.println("int类型可取的最小值是：" + minint); //将常量值输出
System.out.println("int类型的二进制位数是：" + intsize);
}
}
1、构造方法
Double类提供了以下两种构造方法来获得Double类对象
（1）Double(double value)
Double number = new Double(3.14);
(2)Double(String str)
Double number = new Double("3.14");
2、常用方法
Double类的常用方法
| 方法 | 返回值 | 功能描述 |
| valueOf(String str) | Double | 返回保存用参数字符串str表示的double值的Double对象 |
| parseDouble(String s) | double | 返回一个新的double值，该值被初始化为用指定String表示的值，这与Double类的valueOf方法一样 |
| double Value() | double | 以double形式返回此double对象 |
| isNaN() | boolean | 如果此double值是非数字（NaN）值，则返回true，否则返回false |
| intValue() | int | 以int形式返回Double值 |
| byteValue() | byte | 以byte形式返回Double对象值（通过强制转换） |
| longValue() | long | 以long形式返回此double的值（通过强制转换为long类型） |
3、常量
Double类主要提供了以下常量：
（1）MAX_EXPONENT:返回int值，表示有限double变量可能具有的最大指数。
（2）MIN_EXPONENT:返回int值，表示double变量可能具有的最小指数。
(3) NEGATIVE_INFINITY:返回double值，表示保存double类型的负无穷大值的常量。
(4) POSITIVE_INFINITY:返回double值，表示保存double类型的正无穷大值的常量。
public class useDouble { //创建类useDouble
public static void main(String[] args) { //主方法
// TODO Auto-generated method stub
Double dNum = Double.valueOf("3.14"); //通过构造函数创建一个Integer对象
System.out.println("3.14是否为非数字值：" +Double.isNaN(dNum.doubleValue()));
//判断数值是否为非数字值
System.out.println("3.14转换为int值为：" +dNum.intValue()); //转换为int类型
System.out.println("值为3.14的Double对象与3.14的比较结果：" +dNum.equals(3.14));
//判断大小
System.out.println("3.14的十六进制表示为：" +Double.toHexString(dNum));
//转换为十六进制
}
}
1、构造方法
（1）Boolean(boolean value)
该方法创建一个表示value参数的Boolean对象
Boolean b = new Boolean(true);
(2) Boolean(String str)
该方法以S参数tring变量作为参数创建Boolean对象。如果String参数不为null且在忽略大小写时等于true，则分配一个表示true值的Boolean对象，否则获得一个false值的Boolean对象。
Boolean bool = new Boolean("ok");
2、常用方法
Boolean类的常用方法
| 方法 | 返回值 | 功能描述 |
| boolean Value() | Boolean | 将Boolean对象的值以对应的boolean值返回 |
| equals(Object obj) | boolean | 判断调用该方法的对象与obj是否相等，当且仅当参数不是null，而且与调用该方法的对象一样都表示同一个boolean值的Boolean对象时，才返回true |
| parseBoolean(String s) | boolean | 将字符串参数解析为Boolean值 |
| toString() | String | 返回表示该Boolean值的String对象 |
| valueOf(String s) | boolean | 返回一个用指定的字符串表示值的boolean值 |
public class GetBoolean { //创建类GetBoolean
public static void main(String args[]) { //主方法
// TODO Auto-generated method stub
Boolean b1 = new Boolean(true); //创建 Boolean对象
Boolean b2 = new Boolean("ok"); //创建 Boolean对象
System.out.println("b1: " + b1.booleanValue());//输出对象
System.out.println("b2: " + b2.booleanValue());//输出对象
}
}
3、常量
Boolean提供了以下3个常量：
（1）TRUE: 对应基值true的Boolean对象。
（2）FALSE: 对应基值true的Boolean对象。
（3）TYPE: 基本类型boolean的Class对象。
9.1.4 Character 类1、构造方法
Character类的构造方法语法如下：
Character（char value）
以char型变量作为参数，创建Character对象。代码如下：
Character mychar = new Character('s');
2、常用方法
Character类的常用方法
| 方法 | 返回值 | 功能描述 |
| charvalue() | char | 返回此Character对象的值 |
| compareTo(Character anotherCharacter) | int | 根据数字比较两个Character对象，若这两个对象相等则返回0 |
| equals(Odject obj) | Boolean | 将调用该方法的对象与指定的对象相比较 |
| toUpperCase(char ch) | char | 将字符参数转换为大写 |
| toLowerCase(char ch) | char | 将字符参数转换为小写 |
| toString() | String | 返回一个表示指定char值的String对象 |
| charValue() | char | 返回此Character对象的值 |
| isUpperCase(char ch) | boolean | 判断指定字符是否是大写字符 |
| isLowerCase(char ch) | boolean | 判断指定字符是否是小写字符 |
| isLetter(char ch) | boolean | 判断指定字符是否为字母 |
| isDigit(char ch) | boolean | 判断指定字符是否为数字 |
public class UpperOrLower { //创建类UpperOrLower
public static void main(String args[]) { //主方法
// TODO Auto-generated method stub
Character mychar1 = new Character('A'); //声明Character对象
Character mychar2 = new Character('a'); //声明Character对象
if (Character.isUpperCase(mychar1)) { //判断是否为大写字母
System.out.println(mychar1 + "是大写字母");
System.out.println("转换为小写字母的结果：" + Character.toLowerCase(mychar1));
//转换为小写
}
if (Character.isLowerCase(mychar2)) { //判断是否为小写字母
System.out.println(mychar2 + "是小写字母");
System.out.println("转换为大写字母的结果：" + Character.toUpperCase(mychar2));
//转换为大写
}
}
}
3、常量
Character类提供了大量表示特定字符的常量，例如：
（1）CONNECTOR_PUNCTUATION: 返回byte型值，表示Unicode规范中的常规类别“Pc”。
（2）UNASSIGNED: 返回byte型值，表示Unicode规范中的常规类别“Cn”。
（3）TITLECASE_LETTER: 返回byte型值，表示Unicode规范中的常规类别“Lt”。
9.1.5 Number 类对于数值型的包装类，它们有一个共同的父类——Number类，该类是一个抽象类，它是Byte、Integer、Short、Long、Float和double类的父类。其子类必须提供将表示的数值转换为byte、int、short、long、float、double的方法。
Number类的方法分别被Number的各子类所实现，在Number类的所有子类中都包含以上这几种方法。
数值型包装类的共有方法
| 方法 | 返回值 | 功能描述 |
| byteValue() | byte | 以byte形式返回指定的数值 |
| intValue() | int | 以int形式返回指定的数值 |
| floatValue() | float | 以float形式返回指定的数值 |
| shortValue() | short | 以short形式返回指定的数值 |
| longValue() | long | 以long形式返回指定的数值 |
| doubleValue() | double | 以double形式返回指定的数值 |
Math.数学方法
Math.PI //表示圆周率PI的值
Math.E //表示自然数对数底数e的值
System.out.println("圆周率Π的值为：" +Math.PI);
System.out.println("自然对数底数e的值为：" +Math.E);
上面代码的输出结果为：
9.2.2 常用数学运算方法圆周率Π的值为：3.141592653589793
自然对数底数e的值为：2.718281828459045
1、三角函数方法
Math类中的三角函数方法
| 方法 | 返回值 | 功能描述 |
| sin(double a) | double | 返回角的三角正弦 |
| cos(double a) | double | 返回角的三角余弦 |
| tan(double a) | double | 返回角的三角正切 |
| asin(double a) | double | 返回一个值的反正弦 |
| acos(double a) | double | 返回一个值的反余弦 |
| atan(double a) | double | 返回一个值的反正切 |
| toRadians(double angrad) | double | 将角度转换为弧度 |
| toDegrees(double angrad) | double | 将弧度转换为角度 |
public class TrigonometricFunction { //创建类TrigonometricFunction
public static void main(String[] args) {//主方法
// TODO Auto-generated method stub
//取90°的正弦
System.out.println("90度的正弦值：" + Math.sin(Math.PI / 2));
System.out.println("0度的余弦值：" + Math.cos(0));//取0°的余弦
//取60°的正切
System.out.println("60度的正切值：" + Math.tan(Math.PI / 3));
//取2的平方根与2商的反正弦
System.out.println("2的平方根与2商的反余弦值：" + Math.acos(Math.sqrt(2) / 2));
System.out.println("1的反正切值：" + Math.atan(1));//取1的反正切
//取120°的弧度角
System.out.println("120度的弧度值：" + Math.toRadians(120.0));
//取n/2的角度
System.out.println("n/2的角度值：" + Math.toDegrees(Math.PI / 2));
}
}
2、指数函数方法
Math类中的与指数相关的函数方法
| 方法 | 返回值 | 功能描述 |
| exp(double a) | double | 用于获取e的a次方，即取e^a |
| double log(double a) | double | 用于取自然对数，即取lna的值 |
| double log10(double a) | double | 用于取底数为10的对数 |
| sqrt(double a) | double | 用于取a的平方根，其中a的值不能为负值 |
| cbrt(double a) | double | 用于取a的立方根 |
| pow(double a,double a) | double | 用于取a的b次方 |
public class ExponentFunction {//创建类ExponentFunction
public static void main(String[] args) {//主方法
// TODO Auto-generated method stub
System.out.println("e的平方值：" + Math.exp(2)); //取e的2次方
//取以e为底2的对数
System.out.println("以e为底2的对数值：" + Math.log(2)); //取e的2次方
//取以10为底2的对数
System.out.println("以10为底2的对数值：" + Math.log10(2));
System.out.println("4的平方根值：" + Math.sqrt(4));//4的平方根
System.out.println("8的立方根值：" + Math.cbrt(8));//8的立方根
System.out.println("2的2次方值：" + Math.pow(2,2));//2的2次方
}
}
3、取整函数方法
Math类中常用的取整方法
| 方法 | 返回值 | 功能描述 |
| ceil(double a) | double | 返回大于等于参与的最小整数 |
| floor(double a) | double | 返回小于等于参与的最大整数 |
| rint(double a) | double | 返回与参数最接近的整数，如果两个同为整数且同样接近，则结果取偶数 |
| round(float a) | double | 将参数加上0.5后返回与参数最接近的整数 |
| round(double a) | double | 将参数加上0.5后返回与参数最接近的整数，然后强制转换为长整型 |
注意：由于数1.0和2.0的距离数1.5都是0.5个单位长度，因此Math.rint返回偶数2.0。
public class IntFunction {//创建类IntFunction
public static void main(String[] args) {//主方法
// TODO Auto-generated method stub
//返回第一个大于等于参数的整数
System.out.println("使用ceil()方法取整：" + Math.ceil(5.2));
//返回第一个小于等于参数的整数
System.out.println("使用floor()方法取整：" + Math.floor(2.5));
//返回与参数最接近的整数
System.out.println("使用rint()方法取整：" + Math.rint(2.7));
//返回与参数最接近的整数
System.out.println("使用rint()方法取整：" + Math.rint(2.5));
//将参数加上0.5后返回最接近的整数
System.out.println("使用rint()方法取整：" + Math.rint(2.7));
//将参数加上0.5后返回最接近的整数，并将结果强制转换为长整型
System.out.println("使用rint()方法取整：" + Math.rint(2.7));
}
}
4、取最大值、最小值、绝对值函数方法
Math类中其他的常用数据 *** 作方法
| 方法 | 返回值 | 功能描述 |
| max(double a,double b) | double | 取a与b之间的最大值 |
| min(int a,int b) | int | 取a与b之间的最小值，参数为整型 |
| min(long a,long b) | long | 取a与b之间的最小值，参数为长整型 |
| min(float a, float b) | float | 取a与b之间的最小值，参数为浮点型 |
| min(double a,double b) | double | 取a与b之间的最小值，参数为双精度型 |
| abs(int a) | int | 返回整型参数的绝对值 |
| abs(long a) | long | 返回长整型参数的绝对值 |
| abs(f loat a) | float | 返回浮点型参数的绝对值 |
| abs(double a) | double | 返回双精度型参数的绝对值 |
public class AnyFunction { //创建类AnyFunction
public static void main(String[] args) {//主方法
// TODO Auto-generated method stub
System.out.println("4和8较大者：" + Math.max(4,8));
//取两个参数的最小值
System.out.println("4.4和4较小者：" + Math.min(4.4,4));
System.out.println("-7的绝对值：" + Math.abs(-7));//取参数的绝对值
}
}
在Java中主要提供了两种方式生成随机数，分别调用Math类的random()方法和Rando类提供的生成各类数据类型随机数的方法。
9.3.1 Math.random()方法import java.util.Scanner;
public class NumGame {//创建类NumGame
public static void main(String[] args) {//主方法
// TODO Auto-generated method stub
System.out.println("————————猜数字游戏——————————\n");
int iNum;
int iGuess;
Scanner in = new Scanner(System.in); //创建扫描器对象，用于输入
iNum = (int) (Math.random() * 100); //生成1到100之间的随机数
System.out.println("请输入你猜的数字：");
iGuess = in.nextInt(); //输入首次猜测的数字
while ((iGuess !=-1) && (iGuess != iNum)) { //判断输入的数字不是-1或者准数
if (iGuess < iNum) //若猜测的数字小于基准数，则提示用户输入的数太小，并让用户重新输入
{
System.out.println("太小，请重新输入");
iGuess = in.nextInt();
} else //若猜测的数字小于基准数，则提示用户输入的数太大，并让用户重新输入
{
System.out.println("太大，请重新输入：");//输出内容
iGuess = in.nextInt();
}
}
if (iGuess == -1) //若最后一次输入的数字是-1，循环结束的原因是用户选择退出游戏
{
System.out.println("退出游戏！");
} else //若最后一次输入的数字不是-1，用户猜对数字，获得成功，游戏结束
{
System.out.println("恭喜你，你赢了，猜中的数字是：" + iNum); //输出内容
}
System.out.println("————————游戏结束——————————"); //输出内容
}
}除了随机生成数字以外，使用 Math 类的 random（）方法还可以随机生成字符，例如，可以使用下面代码生成a--z 之间的字符：
（char）('a' + Math.random() * ('z'-'a'+1));
通过上述表达式可以求出更多的随机字符，如A--Z 之间的随机字符，进而推理出求任意两个字符之间安定随机字符，可以使用以下语句表示：
（char）(cha1+Math.random() * (cha2-cha1+1));
public class MathRandomChar {
//定义获取任意字符之间的随机字符
public static char GetRandomChar(char cha1, char cha2) {
return (char) (cha1 + Math.random() * (cha2 - cha1 + 1));
}
public static void main(String[] args) {
// TODO Auto-generated method stub
//获取a~z之间的随机字符
System.out.println("任意小写字符" + GetRandomChar('a','z'));
//获取A~Z之间的随机字符
System.out.println("任意大写字符" + GetRandomChar('A','Z'));
//获取0~9之间的随机字符
System.out.println("0~9任意数字字符" + GetRandomChar('a','z'));
}
}
除了 Math 类中的 random（）方法可以获取随机数之外，Java 中还提供了一种可以获取随机数的方式，那就是java.util.Random 类，该类表示一个随机数生成器，可以通过实例化一个Random 对象创建一个随机数生成器。语法如下:
Random r= new Random();
以这种方式实例化对象时，Java 编译器以系统当前时间作为随机生成器的种子，因为每时每刻的时间不可能相同，所以生成的随机数将不同，但如果运行速度太快，也会生成两次运行结果相同的随机数。
同时也可以在实例化Random 类对象时，设置随机数生成器的种子。 语法如下：
Random r = new Random(seedValue)
Random类中常用的获取随机数方法
import java.util.Random;
import java.util.Scanner;
public class RedBags { //创建一个RedBags类
public static void main(String[] args) {//主方法
// TODO Auto-generated method stub
System.out.println("——————模拟微信抢红包——————\n");
Scanner sc = new Scanner(System.in);//控制台输入
System.out.println("请输入要装入红包的总金额（元）: ");
double total = sc.nextDouble(); //输入“红包总金额”
System.out.println("请输入红包的个数（个）: ");
int bagsnum = sc.nextInt(); //输入“红包个数”
double min = 0.01; //初始化“红包的最小金额”
Random random = new Random();//创建随机数对象random
for (int i = 1; i< bagsnum; i++) { //设置“循环”
/*
* 通过公式模拟数学中的离散模拟计算一个红包可以放的最大金额
* 本次红包可用最大金额 = 可分配金额 - (红包总数 * 已发出的红包数) * 红包的最小金额
*/
double max = total - (bagsnum - i) * min;
double bound = max - min; //设置随机金额的取值范围
/*
* 据随机金额的取值范围，随机生成红包金额
* 由于nextInt(int bound)只能用整数做参数，所以先将bound乘100（小数点向右挪两位）
* 获取到一个整数后，将这个整数除100（小数点向左挪两位）并转换成与金额相同的浮点类型
*/
double safe = (double) random.nextInt((int) (bound * 100)) / 100;
double money = safe + min;//最后加上红包的最小金额，以防safe出现0值
total = total - money; //替换total的值
System.out.println("第"+i+"个红包：" + String.format("%.2f,money")+ "元");
System.out.println("第"+bagsnum+"个红包：" +String.format("%.2f,total")+ "元");
sc.close();//关闭控制台输入
}
}
}
说明： Date 类的后4种构造方法已经显示过时，他们已经被Calendar 的相应方法或者 DateFormat 类相应方法取代了，后面介绍这两个类。
long timeMillis = System.currentTimeMillis（）；
Date date= new Date(timeMillis);
Date类的常用方法及说明
import java.util.Date;
public class DateTest { //创建类DateTest
public static void main(String[] args) { //主方法
// TODO Auto-generated method stub
Date date = new Date(); //创建现在的日期
long value = date.getTime(); //获得毫秒数
System.out.println("日期: " + date); //输出信息
System.out.println("到现在所以经历的毫秒数为： " + value); //输出信息
}
}
说明： 由于 Date 类创建对象的时间是变化的，所以每次运行程序在控制台所输出的结果都是不一样的。
DateFormat 类是日期/时间格式化子类的抽象类，它位于java.text包中，可以按照指定格式对日期或时间进行格式化。 DateFormat 提供了很多类方法， 以获得基于默认或给定语言环境和多种格式化风格默认日期/时间 Formatter，格式化风格包括SHORT, MODIUM, LONG等4种，分别如下：
* SHORT: 完全为数字， 如 12.13.52或3：30pm.
* MEDIUM: 较长，如 Jan 12,1952.
* LONG: 更长， 如：January 12,1952 或 3：30：32pm.
* FULL: 完全更长， 如 Tuesday, April 12, 1952 AD 或 3:30:42pm PST.
DateFormat df = DateFormat.geDateInstance();
DateFormat类的常用方法及说明
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
public class DateFormatTest {//创建类DateFormatTest
public static void main(String[] args) {//主方法
//创建日期
Date date = new Date();
//创建不同的日期格式
DateFormat df1 = DateFormat.getInstance();
DateFormat df2 = new SimpleDateFormat("yyy-MM-dd hh:mm:ss EE");
DateFormat df3 = new SimpleDateFormat("yyyy年MM月dd日 hh时mm分ss秒 EE",Locale.CHINA);
DateFormat df4 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss EE",Locale.US);
DateFormat df5 = new SimpleDateFormat("yyy-MM-dd");
DateFormat df6 = new SimpleDateFormat("yyyy年MM月dd日");
//将日期按照不同格式进行输出
System.out.println("-------将日期时间按照不同格式进行输出-------");
System.out.println("按照Java默认的日期格式：" + df1.format(date));
System.out.println("按照指定格式yyy-MM-dd hh:mm:ss ,系统默认区域:" + df2.format(date));
System.out.println("按照指定格式yyyy年MM月dd日 hh时mm分ss秒 ,区域为中文:" + df3.format(date));
System.out.println("按照指定格式yyyy-MM-dd hh:mm:ss ,区域为美国:" + df4.format(date));
System.out.println("按照指定格式yyyy-MM-dd:" + df5.format(date));
System.out.println("按照指定格式yyyy年MM月dd日:" + df6.format(date));
}
}
Calendar 提供了一个类方法 getInstance,以获得此类型的一个通用的对象。Calendar的getInstance方法返回一个Calendar 对象，其日历字段已由当前日期和时间初始化。使用方法如下：
Calendar rightNow = Calendar.getInstaance();
Calendar类提供的常用字段及说明
说明：从上表可看出，ａｄｄ 方法和ｒｏｌｌ 方法都用来为给定的日历字段添加或减去指定时间量或，它们的主要区别在于： 使用add方法时会影响大的字段，像数学加法的进位或错位，而使用roll方法设置的日期字段只是进行增加减少，不会改变更大的字段。
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
public class OlympicWinterGames {//创建一个OlympicWinterGames类
public static void main(String[] args) { //主方法
System.out.println("————————冬奥会倒计时——————————");//输出信息
Date date= new Date();//实例化Date
//创建SimpleDateFormat 对象，指定目标格式
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
String today = simpleDateFormat.format(date);
//调用format方法，格式化时间，转换为指定方法
System.out.println("今天是" + today);
//输出当前时间
long time1 = date.getTime();
//计算自1970年1月1日00：00：00至当前时间所经过的毫秒数
Calendar calendar = Calendar.getInstance();
//使用默认时区与语言环境获得一个日历calendar
//设置日历calendar中的年，月，日的值。因为月份是从0开始计算的，所以这里要减1 calendar.set(2022,2-1,4);
//计算2022年2月4日距离当前时间相差天数
long time2 = calendar.getTimeInMillis(); //计算2022年2月4日距离当前时间相差的天数
long day = (time2 - time1)/(1000 * 60 * 60 * 24);
System.out.println("距离2022年“北京——张家口”冬奥会还有 " +day+ "天!");//输出信息
}
}
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）