目录
一、API的概述与帮助文档的使用
1.1概述
API是应用程序编程接口，Java中的API就是JDK中提供的各种功能的Java类，这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可，我们可以通过帮助文档来学习这些API如何使用。
1.2帮助文档
第一步：打开帮助文档
可以自行搜索API帮助文档进行下载，最好下载1.8之后的，因为版本更新，有许多新更新的在之前的API帮助文档版本内查询不到
第二步：点击索引，就可以在输入框内查询你想要查找的类
第三步：比如你想查找string类，就直接输入string
看类在哪个包下
此时看到左上角的Class String即可知当前是String类的介绍，在Class String上面有个软件包java.lang代表着String类是在lang包下的
看类的描述（是一个什么类）
再往下看可以看到帮助文档内对String类的描述，String类代表字符串。Java程序中的所有字符串文字（例如"abc"）都被实现为此类的实例等等描述，都能让我们借助帮助文档更好地了解所查询类的书面理解知识。
看构造方法（用来创造对象）
往下再看构造方法，可以根据你的需要来进行构造方法的撰写，这里提到已过时，已过时不是不能用，但是有新的写法代替了它，在程序中如果写已过时的构造方法也能运行，但是精简程度还是比不上新的写法。
看成员方法（有什么功能）
往下再看成员方法，当你在写程序时有一些条件不知道用什么方法来写了，可以尝试打开帮助文档看看有没有对应的成员方法，这不失为一条解决问题的途径。
遇到不会的类，要快速的查询API文档去使用
二、较为常用的API
2.1键盘录入字符串-Scanner
-
Scanner类中有许多输入类型对应的方法，比如int类型就对应nextInt()，double类型就对应nextDouble()等，之中比较特殊的还是next()
注意：没有单独的nextChar()方法，可用字符串String，nextLine()
nextxxx()方法：当扫描器扫描到空格、回车、tab时会过滤掉这部分的数据，过滤掉的数据就会被放入扫描器的缓存中，如果下次扫描器继续扫描时，会将数据取出
解决方法
- 在调用下一次有效输入前，调用一次nextLine()方法，将先前缓存中的数据清除掉，这样下次读取的时候就是空的数据，就不输出了
- next()方法，遇到空格不再录入数据，next只认有效数据，不认缓存，结束标记：空格 tab键
代码实现
import java.util.Scanner; public class Demo1Scanner { /* next() : 遇到了空格, 就不再录入数据了 结束标记: 空格, tab键 nextLine() : 可以将数据完整的接收过来 结束标记: 回车换行符 */ public static void main(String[] args) { // 1. 创建Scanner对象 Scanner sc = new Scanner(System.in); System.out.println("请输入:"); // 2. 调用nextLine方法接收字符串 // ctrl + alt + v : 快速生成方法的返回值 String s = sc.nextLine(); System.out.println(s); } }import java.util.Scanner; public class Demo2Scanner { /* nextInt和nextLine方法配合使用的时候, nextLine方法就没有键盘录入的机会了 建议: 今后键盘录入数据的时候, 如果是字符串和整数一起接受, 建议使用next方法接受字符串. */ public static void main(String[] args) { Scanner sc = new Scanner(System.in); System.out.println("请输入整数:"); int num = sc.nextInt(); // 10 + 回车换行 System.out.println("请输入字符串:"); String s = sc.nextLine(); System.out.println(num); System.out.println(s); } }2.2String类
概述
- String 类在 java.lang 包下，所有在 java.lang 包下的类使用的时候都不需要导包，所有String类使用时无需导包
- 所有的字符串字面量（例如"abc"）都是一个String类的对象
- 字符串不可变，它们的值在创建后不能被更改
构造方法
方法名 如何构造 说明 public String() 无参构造方法
String str1 = new String();
System.out,println(str1);
创建一个空白字符串对象，不含有任何内容 public String(char[] chs) char[] chs = {'a','b','c','d'};
String str2 = new String (chs);
System.out.pringln(str2);
根据字符数组（参数）的内容来创建字符串对象 public String(String original) String str3 = new String ("hello world");
System.out.println(str3);
根据传入的字符串内容来创建字符串对象 String s = "abc"; String str4 = "hello world";
System.out.println(str4);
直接赋值的方式创建字符串对象，内容就是abc 示例代码
public class Demo2StringConstructor { /* String类常见构造方法: public String() : 创建一个空白字符串对象，不含有任何内容 public String(char[] chs) : 根据字符数组的内容，来创建字符串对象 public String(String original) : 根据传入的字符串内容，来创建字符串对象 String s = “abc”; 直接赋值的方式创建字符串对象，内容就是abc 注意: String这个类比较特殊, 打印其对象名的时候, 不会出现内存地址 而是该对象所记录的真实内容. 面向对象-继承, Object类 */ public static void main(String[] args) { // public String() : 创建一个空白字符串对象，不含有任何内容 String s1 = new String(); System.out.println(s1); // public String(char[] chs) : 根据字符数组的内容，来创建字符串对象 char[] chs = {'a','b','c'}; String s2 = new String(chs); System.out.println(s2); // public String(String original) : 根据传入的字符串内容，来创建字符串对象 String s3 = new String("123"); System.out.println(s3); } }字符串特点
- 用双引号""引起来。比如"abc"，这就是个字符串；
- 不可变。在创建之后就是固定的值，后续再改变，变得不是原先创建的值，变得是栈指向的值。比如String str1="abc";str1 = "abcd";这两行代码，str1本来直接赋值为abc，直接指向方法区中新开辟出来的放abc的空间，但是第二行又赋值abcd，此时str1就不再指向abc，而是指向新开辟出来的放abcd的空间，然而abc此时没有任何变化，只是str1不再指向它而已；
- 值可共享。创建对象时，如果直接赋值的这个值存在，那么可直接指向这个值，不必再开辟新空间，不存在时才会开辟新空间存放这个值。比如String str2 = "abc";接第二点的例子，已经有一个存放abc的空间了，所以此时不会开辟新空间，str2会直接指向之前创建出来的“abc”空间。
创建字符串对象的区别
-
通过构造方法创建
通过 new 创建的字符串对象，每一次 new 都会申请一个内存空间，虽然内容相同，但是地址值不同
-
直接赋值方式创建
以“”方式给出的字符串，只要字符序列相同(顺序和大小写)，无论在程序代码中出现几次，JVM 都只会建立一个 String 对象，并在字符串池中维护
方法小结
equals 字符串比较
- public boolean equals(String s)
比较两个字符串内容是否相同、区分大小写
-
== 比较基本数据类型：比较的是具体的值
-
== 比较引用数据类型：比较的是对象地址值
boolean 返回值 str1.equals(str2)
不想区分大小写可以用equalsIgnoreCase(忽略大小写)
public class Demo1Equals { public static void main(String[] args) { String s1 = "abc"; String s2 = "ABC"; String s3 = "abc"; // equals : 比较字符串内容, 区分大小写 System.out.println(s1.equals(s2)); System.out.println(s1.equals(s3)); // equalsIgnoreCase : 比较字符串内容, 忽略大小写 System.out.println(s1.equalsIgnoreCase(s2)); } }length() 返回字符串长度
- public int length()
使用时直接写对象名.length就能得到字符串的长度
charAt 返回指定索引处的char值
- public char charAt(int index)
字符串的索引也是从0开始的
应用-遍历字符串
键盘录入一个字符串，使用程序实现在控制台遍历该字符串
import java.util.Scanner; public class Char { /* 需求：键盘录入一个字符串，使用程序实现在控制台遍历该字符串 思路： 1. 键盘录入一个字符串，用 Scanner 实现 2. 遍历字符串，首先要能够获取到字符串中的每一个字符 public char charAt(int index)：返回指定索引处的char值，字符串的索引也是从0开始的 3. 遍历字符串，其次要能够获取到字符串的长度 public int length()：返回此字符串的长度 4. 遍历打印 */ public static void main(String[] args) { // 1. 键盘录入一个字符串，用 Scanner 实现 Scanner sc = new Scanner(System.in); System.out.println("请输入:"); String s = sc.nextLine(); // 2. 遍历字符串，首先要能够获取到字符串中的每一个字符 for(int i = 0; i < s.length(); i++){ // i : 字符串的每一个索引 char c = s.charAt(i); System.out.println(c); } } }toCharArray() 将字符串拆分为字符数组
- public char[] toCharArray( )
应用-统计字符次数
import java.util.Scanner; public class Counts { /* 需求：键盘录入一个字符串，使用程序实现在控制台遍历该字符串 思路： 1. 键盘录入一个字符串，用 Scanner 实现 2. 将字符串拆分为字符数组 public char[] toCharArray( )：将当前字符串拆分为字符数组并返回 3. 遍历字符数组 */ public static void main(String[] args) { // 1. 键盘录入一个字符串，用 Scanner 实现 Scanner sc = new Scanner(System.in); System.out.println("请输入:"); String s = sc.nextLine(); // 2. 将字符串拆分为字符数组 char[] chars = s.toCharArray(); // 3. 遍历字符数组 for (int i = 0; i < chars.length; i++) { System.out.println(chars[i]); } } }substring 截取字符串
- public String substring (int beginIndex,int endIndex)
- 包头不包尾，根据开始和结束索引进行截取，得到新字符串
- public String substring (int beginIndex)
- 从头到尾截取，得到新字符串
不会改变原来字符串的内容，截取的结果会创建一个新的字符串对象，所以对原字符串的内容无影响
应用-手机号屏蔽
import java.util.Scanner; public class Subs { /* 需求：以字符串的形式从键盘接受一个手机号，将中间四位号码屏蔽 最终效果为：156****1234 思路： 1. 键盘录入一个字符串，用 Scanner 实现 2. 截取字符串前三位 3. 截取字符串后四位 4. 将截取后的两个字符串，中间加上****进行拼接，输出结果 */ public static void main(String[] args) { // 1. 键盘录入一个字符串，用 Scanner 实现 Scanner sc = new Scanner(System.in); System.out.println("请输入手机号:"); String phoneNum = sc.nextLine(); // 2. 截取字符串前三位 String start = phoneNum.substring(0,3); // 3. 截取字符串后四位 String end = phoneNum.substring(7); // 4. 将截取后的两个字符串，中间加上****进行拼接，输出结果 System.out.println(start + "****" + end); } }replace 字符串替换
- public String replace(CharSequence target, CharSequence replacement)
使用新值，将字符串中的旧值替换掉，得到新字符串，也不会改变原字符串的内容
应用-敏感词替换
import java.util.Scanner; public class Rep { /* 需求：键盘录入一个 字符串，如果字符串中包含（TMD），则使用***替换 思路： 1. 键盘录入一个字符串，用 Scanner 实现 2. 替换敏感词 String replace(CharSequence target, CharSequence replacement) 将当前字符串中的target内容，使用replacement进行替换，返回新的字符串 3. 输出结果 */ public static void main(String[] args) { // 1. 键盘录入一个字符串，用 Scanner 实现 Scanner sc = new Scanner(System.in); System.out.println("请输入:"); String s = sc.nextLine(); // 2. 替换敏感词 String result = s.replace("TMD","***"); // 3. 输出结果 System.out.println(result); } }split 切割字符串
- public String[] split(String regex)
根据传入的规则切割字符串得到字符串数组，字符串中拆分符号是什么就要输入对应的regex，比如拆分符号是英文的逗号，那么在控制台输入的时候也要输入英文的逗号，输入中文的则会出错。
应用-切割有效数据封装为Student学生对象
import com.wedu.domain.Student; import java.util.Scanner; public class StudentTest { /* 需求：以字符串的形式从键盘录入学生信息，例如：“张三 , 23” 从该字符串中切割出有效数据,封装为Student学生对象 思路： 1. 编写Student类，用于封装数据 2. 键盘录入一个字符串，用 Scanner 实现 3. 根据逗号切割字符串，得到（张三）（23） String[] split(String regex) ：根据传入的字符串作为规则进行切割 将切割后的内容存入字符串数组中，并将字符串数组返回 4. 从得到的字符串数组中取出元素内容，通过Student类的有参构造方法封装为对象 5. 调用对象getXxx方法，取出数据并打印。 */ public static void main(String[] args) { // 2. 键盘录入一个字符串，用 Scanner 实现 Scanner sc = new Scanner(System.in); System.out.println("请输入学生信息:"); String stuInfo = sc.nextLine(); // stuInfo = "张三,23"; // 3. 根据逗号切割字符串，得到（张三）（23） String[] sArr = stuInfo.split(","); // System.out.println(sArr[0]); // System.out.println(sArr[1]); // 4. 从得到的字符串数组中取出元素内容，通过Student类的有参构造方法封装为对象 Student stu = new Student(sArr[0],sArr[1]); // 5. 调用对象getXxx方法，取出数据并打印。 System.out.println(stu.getName() + "..." + stu.getAge()); } }2.3StringBuilder类
概述
- StringBuilder 是一个可变的字符串类，我们可以把它看成是一个容器，这里的可变指的是 StringBuilder 对象中的内容是可变的
- 适用于大量字符串拼接的场景，因为每"+"一次都会创新产生大量临时的StringBuilder对象和临时字符串对象，很浪费空间
构造方法
方法名 说明 public StringBuilder() 创建一个空白可变字符串对象，不含有任何内容 public StringBuilder(String str) 根据字符串的内容，来创建可变字符串对象 public class StringBuilderDemo01 { public static void main(String[] args) { //public StringBuilder()：创建一个空白可变字符串对象，不含有任何内容 StringBuilder sb = new StringBuilder(); System.out.println("sb:" + sb); System.out.println("sb.length():" + sb.length()); //public StringBuilder(String str)：根据字符串的内容，来创建可变字符串对象 StringBuilder sb2 = new StringBuilder("hello"); System.out.println("sb2:" + sb2); System.out.println("sb2.length():" + sb2.length()); } }常用的成员方法
- public StringBuilder append(任意类型) 添加数据，并返回对象本身
链式调用，每次调用返回的数据类型还是自己
StringBuilder sb2=sb1.append("abc").append("def").append(false)
输出abcdeffalse
- public StringBuilder reverse() 返回相反的字符序列
StringBuilder reverse=sb2.reverse()
输出eslaffedcba
StringBuilder和String相互转换
-
StringBuilder转换为String
public String toString()：通过 toString() 就可以实现把 StringBuilder 转换为 String
public class StringExam01 { public static void main(String[] args) { StringBuilder sb=new StringBuilder(); sb.append("hello"); String s=sb.toString(); System.out.println(s); //System.out.println(sb); } }sout(s)和sout(sb)任选其一写，因为默认调用sb的toString方法
-
String转换为StringBuilder
public StringBuilder(String s)：通过构造方法就可以实现把 String 转换为 StringBuilder
public class StringExam01 { public static void main(String[] args) { String str="hello"; StringBuilder sb=new StringBuilder(str); System.out.println(sb); } }应用-拼接字符串
需求：定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，
并在控制台输出结果。例如，数组为int[] arr = {1,2,3}; ，执行方法后的输出结果为：[1, 2, 3]
/* 思路： 1:定义一个 int 类型的数组，用静态初始化完成数组元素的初始化 2:定义一个方法，用于把 int 数组中的数据按照指定格式拼接成一个字符串返回。 返回值类型 String，参数列表 int[] arr 3:在方法中用 StringBuilder 按照要求进行拼接，并把结果转成 String 返回 4:调用方法，用一个变量接收结果 5:输出结果 */ public class StringBuilderTest01 { public static void main(String[] args) { //定义一个 int 类型的数组，用静态初始化完成数组元素的初始化 int[] arr = {1, 2, 3}; //调用方法，用一个变量接收结果 String s = arrayToString(arr); //输出结果 System.out.println("s:" + s); } //定义一个方法，用于把 int 数组中的数据按照指定格式拼接成一个字符串返回 /* 两个明确： 返回值类型：String 参数：int[] arr */ public static String arrayToString(int[] arr) { //在方法中用 StringBuilder 按照要求进行拼接，并把结果转成 String 返回 StringBuilder sb = new StringBuilder(); sb.append("["); for(int i=0; i<arr.length; i++) { if(i == arr.length-1) { sb.append(arr[i]); } else { sb.append(arr[i]).append(", "); } } sb.append("]"); String s = sb.toString(); return s; } }
2.4Math
- Math包含执行基本数字运算的方法，不需要导包
- Math类中无构造方法，但内部的方法都是静态的，则可以通过 类名.进行调用
- 常用方法
| 方法名 | 说明 |
|---|---|
| public static int abs(int a) | 返回参数的绝对值 |
| public static double ceil(double a) | 返回大于或等于参数的最小double值，等于一个整数 向上取整 |
| public static double floor(double a) | 返回小于或等于参数的最大double值，等于一个整数 向下取整 |
| public static int round(float a) | 按照四舍五入返回最接近参数的int |
| public static int max(int a,int b) | 返回两个int值中的较大值 |
| public static int min(int a,int b) | 返回两个int值中的较小值 |
| public static double pow (double a,double b) | 返回a的b次幂的值 |
| public static double random() | 返回值为double的正值，[0.0,1.0) |
向上取整：比如输入10.9，那么输出11.0，输入10.1，也输出11.0，输入小数位1-9的都直接进位，这就是向上取整；
向下取整：与向上取整相反，输入小数位1-9的都直接舍去，比如输入10.9，就输出10.0；
2.5System
System类是被final修饰不可继承的！
常用方法
| 方法名 | 说明 |
|---|---|
| public static void exit(int status) | 终止当前运行的 Java 虚拟机，非零表示异常终止 |
| public static long currentTimeMillis() | 返回当前时间(以毫秒为单位) |
应用-代码执行时间
需求：在控制台输出1-10000，计算这段代码执行了多少毫秒
public class SystemDemo {
public static void main(String[] args) {
// 获取开始的时间节点
long start = System.currentTimeMillis();
for (int i = 1; i <= 10000; i++) {
System.out.println(i);
}
// 获取代码运行结束后的时间节点
long end = System.currentTimeMillis();
System.out.println("共耗时：" + (end - start) + "毫秒");
}
}2.6Object类
Object 是类层次结构的根，每个类都可以将 Object 作为超类。所有类都直接或者间接的继承自该类， 所有对象（包括数组）都实现
查看方法源码：ctrl+b
toString方法
-
重写toString方法的方式
- Alt + Insert 选择toString
- 在类的空白区域，右键 -> Generate -> 选择toString
-
toString方法的作用：
-
以良好的格式，更方便的展示对象中的属性值
-
equals方法
-
equals方法的作用
-
用于对象之间的比较，返回true和false的结果
-
举例：s1.equals(s2); s1和s2是两个对象
-
-
重写equals方法的场景
-
不希望比较对象的地址值，想要结合对象属性进行比较的时候。
-
-
重写equals方法的方式
- alt + insert 选择equals() and hashCode()，IntelliJ Default，一路next，finish即可
- 在类的空白区域，右键 -> Generate -> 选择equals() and hashCode()，后面的同上。
面试题
// 看程序,分析结果
String s = “abc”;
StringBuilder sb = new StringBuilder(“abc”);
s.equals(sb);
sb.equals(s);
public class InterviewTest {
public static void main(String[] args) {
String s1 = "abc";
StringBuilder sb = new StringBuilder("abc");
//1.此时调用的是String类中的equals方法.
//保证参数也是字符串,否则不会比较属性值而直接返回false
//System.out.println(s1.equals(sb)); // false
//StringBuilder类中是没有重写equals方法,用的就是Object类中的.
System.out.println(sb.equals(s1)); // false
}
}如果不想通过父类的equals来比较，可以用子类重写equals来比较
Objects（1.7之后才开始使用）
常用方法
| 方法名 | 说明 |
|---|---|
| public static String toString(对象) | 返回参数中对象的字符串表示形式。 |
| public static String toString(对象, 默认字符串) | 返回对象的字符串表示形式。 |
| public static Boolean isNull(对象) | 判断对象是否为空 |
| public static Boolean nonNull(对象) | 判断对象是否不为空 |
BigDecimal
适用于精度比较高的场景，需要导包进行运用
先将十进制转换为二进制进入运算，得出结果再转为十进制进行显示，而浮点数没法通过二进制进行精确表示，所以存在精度误差，这时候就需要用到BigDecimal来进行精确计算
构造方法
| 方法名 | 说明 |
|---|---|
| BigDecimal(double val) | 参数为double |
| BigDecimal(String val) | 参数为String |
通过传递字符串的构造方法才可以解决精度问题，再转的过程中会出现精度问题就要用String构造方法，不会出现问题就可以用double构造方法
常用方法
| 方法名 | 说明 |
|---|---|
| public BigDecimal add(另一个BigDecimal对象) | 加法 |
| public BigDecimal subtract (另一个BigDecimal对象) | 减法 |
| public BigDecimal multiply (另一个BigDecimal对象) | 乘法 |
| public BigDecimal divide (另一个BigDecimal对象) | 除法 |
| public BigDecimal divide (另一个BigDecimal对象，精确几位，舍入模式) | 除法 |
总结
-
BigDecimal是用来进行精确计算的
-
创建BigDecimal的对象，构造方法使用参数类型为字符串的。
-
四则运算中的除法，如果除不尽请使用divide的三个参数的方法。
BigDecimal divide = bd1.divide(参与运算的对象,小数点后精确到多少位,舍入模式);
参数1 ，表示参与运算的BigDecimal 对象。
参数2 ，表示小数点后面精确到多少位
参数3 ，舍入模式
BigDecimal.ROUND_UP 进一法
BigDecimal.ROUND_FLOOR 去尾法
BigDecimal.ROUND_HALF_UP 四舍五入
arraycopy
- arraycopy(Object src,int srcPos,Object dest,int destPos,int length);
arraycopy：从指定源数组中复制一个数组
Object src：源数组
int srcPos：复制从指定位置开始
Object dest：复制到的目标数组
int destPos：目标数组的指定位置
int length：指定复制的长度，最终需要复制的个数
代码示例
int[] src={1,2,3,4,5};
int[] dest=new int[10];
System.array.copy(src,0,dest,0,5);最后输出的意思是从原数组中复制一个从索引0开始的长度为5的数组，复制到目标数组索引为0的索引处开始，如果长度为6，根据我们设置的数组长度会越界！
三、包装类
将八大基本数据类型都给到一个相应的包装类，功能更强大
基本类型包装类的作用
将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据
常用的操作之一：用于基本数据类型与字符串之间的转换
基本类型对应的包装类
| 基本数据类型 | 包装类 |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| char | Character |
| boolean | Boolean |
延伸-Integer类
构造方法
| 方法名 | 说明 |
|---|---|
| public Integer(int value) | 根据 int 值创建 Integer 对象(过时) |
| public Integer(String s) | 根据 String 值创建 Integer 对象(过时) |
| public static Integer valueOf(int i) | 返回表示指定的 int 值的 Integer 实例 |
| public static Integer valueOf(String s) | 返回一个保存指定值的 Integer 对象 String |
基本数据类型经过装箱能作为引用数据类型使用，引用数据类型一拆箱就可当基本数据类型使用，自动装、拆箱则在jdk1.5之后出现
自动装箱：把基本数据类型转换为对应的包装类类型
Integer i = 100;自动拆箱：把包装类类型转换为对应的基本数据类型
i += 200;
// i = i + 200; i + 200 自动拆箱；i = i + 200; 是自动装箱int和String类型的相互转换
int转换为String
- 直接在数字后加一个空字符串
String str1=num+" "- 通过String类静态方法valueOf()
String str2=String.valueOf(num);String转换为int
- 先将字符串数字转成Integer自动拆箱，再调用valueOf()方法
String ->Integer->int
String str3="1234";
int num2=Integer.valueOf(str3);
//字符串转包装类时，字符串中要是有效内容
//无效内容或者数字格式化错误的会报错
//字符串中如果是12er34则会报错- 通过Integer静态方法parseInt()进行转换
int num3=Integer.parseInt(str3);
System.out.println(num3);字符串数据排序
-
案例需求
有一个字符串：“91 27 46 38 50”，请写程序实现最终输出结果是：27 38 46 50 91
-
代码实现
public class IntegerTest {
public static void main(String[] args) {
//定义一个字符串
String s = "91 27 46 38 50";
//把字符串中的数字数据存储到一个int类型的数组中
String[] strArray = s.split(" ");
// for(int i=0; i<strArray.length; i++) {
// System.out.println(strArray[i]);
// }
//定义一个int数组，把 String[] 数组中的每一个元素存储到 int 数组中
int[] arr = new int[strArray.length];
for(int i=0; i<arr.length; i++) {
arr[i] = Integer.parseInt(strArray[i]);
}
//对 int 数组进行排序
Arrays.sort(arr);
for(int i=0; i<arr.length; i++){
System.out.print(arr[i] + " ");
}
}
1097
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
