Java 进阶，学习笔记-1，基础API使用
Java 进阶-1，常见 API 的简单用法
包含 Scanner，匿名对象，Random 类，对象数组，ArrayList 集合，字符串常量池，字符串相关方法，截取子字符串，字符串转换，字符串分割方法，static 修饰成员变量，static 修饰成员方法，静态代码块，数组工具类 Arrays，Math 类
文章目录
- Scanner 的使用
- 匿名对象
- Random 类
- ArrayList 集合
- 对象数组
- ArrayList
- String
- 字符串常量池
- 字符串相关方法
- 截取子字符串
- 字符串转换
- 字符串分割方法
- static 关键字
- static 修饰成员变量
- static 修饰成员方法
- 静态代码块
- 数组工具类 Arrays
- Math 类
Scanner 的使用
1、先导入 java.util 包里面的 Scanner 类
import java.util.Scanner;
2、创建 Scanner 对象
Scanner sc = new Scanner();
3、进行输入赋值
int num = sc.nextInt();
示例代码：
/*
对三个变量进行输入 a, b, c，然后求出它们中的最大值
*/
// 导入包
import java.util.Scanner;
public class test {
public static void main(String[] args) {
// 创建 Scanner 对象
Scanner sc = new Scanner(System.in);
// 进行输入
System.out.print("请输入 a：");
int a = sc.nextInt();
System.out.print("请输入 b：");
int b = sc.nextInt();
System.out.print("请输入 c：");
int c = sc.nextInt();
int max = (a > b ? a :b) > c ? (a > b ? a :b) : c;
System.out.println("它们中的最大值为：" + max);
}
}
匿名对象
匿名对象只有右边的对象，没有左边的名字和赋值运算符
new 类名称();
注意事项：匿名对象只能使用唯一的一次，下次再用不得不再创建一个新对象
使用建议：如果确定一个对象只需要使用唯一的一次，就可以使用匿名对象
public class Student {
String name;
int age;
public void showName() {
System.out.println("我叫" + name);
}
}
public class test {
public static void main(String[] args) {
Student stu1 = new Student();
stu1.name = "A";
stu1.showName();
new Student().name = "Alex";
new Student().showName();
}
}
使用匿名对象进行传参
import java.util.Scanner;
public class test {
public static void main(String[] args) {
// 使用匿名对象进行传参
int num = input(new Scanner(System.in));
print(num);
}
// 输入函数
public static int input(Scanner sc) {
return sc.nextInt();
}
// 打印函数
public static void print(int n) {
System.out.println(n);
}
}
匿名对象作为返回值
import java.util.Scanner;
public class test {
public static void main(String[] args) {
// 接收为匿名对象的返回值
Scanner sc = scanner();
System.out.print("请输入值：");
int num = sc.nextInt();
System.out.println("num = " + num);
}
public static Scanner scanner() {
return new Scanner(System.in);
}
}
Random 类
用来生成随机数字
所属包
import java.util.Random;
import java.util.Random;
public class test {
public static void main(String[] args) {
Random r = new Random();
// 随机生成整数
int num1 = r.nextInt();
System.out.println("num1 = " + num1);
// 生成指定范围内的整数
// 会随机产生 0 - 9 之间的整数，不会产生 10
System.out.print("随机产生 10 个 0 - 9 之间的数：");
for (int i = 0; i < 10; i++) {
System.out.print(r.nextInt(10) + " ");
}
System.out.println();
// 随机产生 10 个 1 - 10 之间的整数
System.out.print("随机产生 10 个 1 - 10 之间的数：");
for (int i = 0; i < 10; i++) {
System.out.print((r.nextInt(10) + 1) + " ");
}
System.out.println();
// 拓展（乱想出来的）
// 生成 10 个 23-56 之间的整数
// int num4 = r.nextInt(23) + 23;
System.out.print("随机产生 10 个 23 - 45 之间的数：");
for (int i = 0; i < 10; i++) {
System.out.print((r.nextInt(23) + 23) + " ");
}
System.out.println();
}
}
输出：
num1 = -1444734230
随机产生 10 个 0 - 9 之间的数：5 1 1 2 6 2 2 2 9 9
随机产生 10 个 1 - 10 之间的数：9 8 10 10 7 2 10 8 6 7
随机产生 10 个 23 - 45 之间的数：30 23 45 34 30 25 32 31 35 42
ArrayList 集合
对象数组
用来存放对象的数组叫做对象数组
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class test {
public static void main(String[] args) {
// 创建 Student 类的对象数组 arrayObj
Student[] arrayObj = new Student[3];
// 单独创建三个 Student 对象
Student stu1 = new Student("stu1", 15);
Student stu2 = new Student("stu2", 16);
Student stu3 = new Student("stu3", 18);
// 把创建好的三个对象装进 arrayObj 里面
arrayObj[0] = stu1;
arrayObj[1] = stu2;
arrayObj[2] = stu3;
System.out.println("打印它们的地址值：");
System.out.println(arrayObj[0]);
System.out.println(arrayObj[1]);
System.out.println(arrayObj[2]);
System.out.println();
System.out.println(arrayObj[0].getName() + " 的年龄是 " + arrayObj[0].getAge() + " 岁！");
System.out.println(arrayObj[1].getName() + " 的年龄是 " + arrayObj[1].getAge() + " 岁！");
System.out.println(arrayObj[2].getName() + " 的年龄是 " + arrayObj[2].getAge() + " 岁！");
}
}
ArrayList
数组的长度不可以该表，但是 ArrayList 集合的长度可以改变
A r r a y L i s t < E > ArrayList^{
泛型只能是引用类型，不能是基本类型
简单实用：
import java.util.ArrayList;
public class test {
public static void main(String[] args) {
ArrayList<String> list= new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");
System.out.println(list);
}
}
ArrayList 集合的常用方法
list.add(E e) // 在末尾添加元素
list.get(int index) // 获取指定索引的元素
list.remove(int index) // 移除指定索引的元素
list.removeRange(int start, int end) // 移除指定范围的元素，不包括 end
list.isEmpty() // 返回数组是否为空
list.contains(Object o) // 元素是否包含在数组内
list.clear() // 移除列表中的所有元素
list.size() // 列表有多少个元素
简单举例：
public class test {
public static void main(String[] args) {
ArrayList<String> list= new ArrayList<>();
System.out.println("原来的列表：" + list);
list.add("A");
list.add("B");
list.add("C");
System.out.println("添加元素后的列表：" + list);
list.add(1, "1");
System.out.println("在第 1 个位置添加元素后的列表：" + list);
System.out.println("列表是否为空：" + list.isEmpty());
System.out.println("列表有多少个元素：" + list.size());
System.out.println("元素 A 在不在列表内：" + list.contains("A"));
System.out.println("元素 F 在不在列表内：" + list.contains("F"));
// 删除元素
list.remove(3);
System.out.println("删除第 3 个元素后的列表：" + list);
// 清空列表
list.clear();
System.out.println("清空元素后的列表：" + list);
System.out.println("列表是否为空：" + list.isEmpty());
}
}
输出：
原来的列表：[]
添加元素后的列表：[A, B, C]
在第 1 个位置添加元素后的列表：[A, 1, B, C]
列表是否为空：false
列表有多少个元素：4
元素 A 在不在列表内：true
元素 F 在不在列表内：false
删除第 3 个元素后的列表：[A, 1, B]
清空元素后的列表：[]
列表是否为空：true
注意：我们在使用 ArrayList 的时候，只能使用引用基本类型，那如果是数据基本类型的话，我们就不能用。
解决办法：我们可以用包装类来代替基本类型
以下一一对应：
| 基本类型 | 包装类（引用类型，都位于 java.lang 包下） |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| char | Character |
| boolean | Boolean |
练习1：
随机生成 6 个 1-33 之间的随机整数，存放到列表中，并遍历列表
import java.util.ArrayList;
import java.util.Random;
public class test {
public static void main(String[] args) {
ArrayList<Integer> list= new ArrayList<>();
Random r = new Random();
// 用循环生成 6 个随机整数 1 - 33
for (int i = 0; i < 6; i++) {
list.add(r.nextInt(33) + 1);
}
// 遍历列表
iterArray(list);
}
// 遍历列表方法
public static void iterArray(ArrayList<Integer> L) {
for (int i = 0; i < L.size(); i++) {
System.out.print(L.get(i) + " ");
}
System.out.println();
}
}
输出：
10 12 25 1 9 23
练习2：
import java.util.ArrayList;
import java.util.Random;
public class test {
public static void main(String[] args) {
ArrayList<Integer> list= new ArrayList<>();
Random r = new Random();
// 用循环生成 20 个随机整数 1 - 100
for (int i = 0; i < 6; i++) {
list.add(r.nextInt(100) + 1);
}
// 遍历列表
System.out.println("原来的列表：");
iterArray(list);
// 筛选出大于 60 的所有数字并存放到小集合中
System.out.println("筛选出来的列表：");
ArrayList<Integer> newList = satisfy(list);
iterArray(newList);
}
// 遍历列表方法
public static void iterArray(ArrayList<Integer> L) {
for (int i = 0; i < L.size(); i++) {
System.out.print(L.get(i) + " ");
}
System.out.println();
}
// 筛选大于 60 的数字
public static ArrayList<Integer> satisfy(ArrayList<Integer> list) {
ArrayList<Integer> list1 = new ArrayList<>();
for (int i = 0; i < list.size(); i++) {
if (list.get(i) >= 60)
list1.add(list.get(i));
}
return list1;
}
}
输出：
原来的列表：
30 69 20 72 86 15
筛选出来的列表：
69 72 86
String
Java 程序中，所有的双引号字符串，其实都是 String 类的对象。（就算没有通过 new 也是）
特点：
1、字符串的内容用不可变
2、字符串是可以共享使用的
3、字符串效果上相当于是 char 字符数组，但是底层原理仍然是 byte[] 字节数组
三种构造方法：
public String()，创建一个空白字符串，不含有任何内容
public String(char[] array)，根据字符数组的内容，来创建对应的字符串
public String(byte[] array)，根据字节数组的内容，来创建对应的字符串
当然还有最方便的直接创建
String str = "Hello, World";
上面的创建方式虽然没有进行 new，但是默认也是进行了 new 的。
public class test {
public static void main(String[] args) {
// 创建一个空参字符串
String str1 = new String();
System.out.println("str1: " + str1);
// 创建一个字符数组字符串
char[] charArray = {'a', 'b', 'c'};
String str2 = new String(charArray);
System.out.println("str2: " + str2);
// 创建一个字节型数组字符串
byte[] byteArray = {65, 66, 67, 68};
String str3 = new String(byteArray);
System.out.println("str3: " + str3);
}
}
输出：
str1:
str2: abc
str3: ABCD
字符串常量池
字符串常量池，程序当中直接写上的双引号字符串，就在字符串常量池中。字符串常量池位于堆中
注意：
对于基本类型来说，== 是进行数值的比较
对于引用类型来说，== 是进行地址值的比较
所以，这里我们比较的都是地址值
public class test {
public static void main(String[] args) {
// 分别直接创建两个字符串
String str1 = "abc";
String str2 = "abc";
// 创建一个字符型数组字符串
char[] charArray1 = {'a', 'b', 'c'};
char[] charArray2 = {'a', 'b', 'c'};
String str3 = new String(charArray1);
String str4 = new String(charArray2);
// 两两比较它们是否相等
System.out.println("比较它们是否相等：");
System.out.println("str1 == str2: " + (str1 == str2));
System.out.println("str2 == str3: " + (str2 == str3));
System.out.println("str1 == str3: " + (str1 == str3));
System.out.println("比较两个通过字符型数组创建的字符串：");
System.out.println("str3 == str4: " + (str3 == str4));
// 用 equals() 来比较它们是否相等
System.out.println("用 equals() 方法来比较它们是否相等：");
System.out.println("str1 equals str2: " + (str1.equals(str2)));
System.out.println("str2 equals str3: " + (str2.equals(str3)));
System.out.println("str1 equals str3: " + (str1.equals(str3)));
System.out.println("str3 equals str4: " + (str3.equals(str4)));
}
}
输出：
比较它们是否相等：
str1 == str2: true
str2 == str3: false
str1 == str3: false
比较两个通过字符型数组创建的字符串：
str3 == str4: false
用 equals() 方法来比较它们是否相等：
str1 equals str2: true
str2 equals str3: true
str1 equals str3: true
str3 equals str4: true
总结
1、常量池中的常量相同共用地址值。对于上面的代码，我们可以看出，str1、str2、str3、str4 产生出来的内容都是相同的，但是我们在比较的时候为什么会不同呢？因为双引号产生的字符串被放在常量池当中。str1 被创建了之后，位于常量池中。而 str1 会被转化成一个 byte[] 数组 [97, 98, 99]保存在常量池中。当 str2 被产生时也会相应的转换成 byte[]，但是因为它们转换后的 byte[] 相同，所以共用一个地址。这也说明为什么叫常量池，就是用来保存常量的值。保存在常量池中的常量相同就共用一个地址值。
2、new 产生的地址值都不相同。后面的 str3 由先产生 charArray1 产生，再封装成字符串。是通过 new 产生的。所以就不再常量池中。先由 charArray1 产生 char[] 字符型数组 [‘a’, ‘b’, ‘c’]，再通过 String 对像把 [‘a’, ‘b’, ‘c’] 转换成 byte[] 数组 [97, 98, 99]。然后把地址传给 str3，所以 str3 和 str1 不同，也即是和 str2 不同。同理 str4 也是通过 new 产生的一个新的地址，所以也和上面的地址都不相同。
3、equals() 方法可以比较它们值是否相等如果要比较它们的数值是否相等，那么可以通过 equals 方法来比较
4、equals() 方法推荐使用"abc".equals(str)，不推荐str.eqquals("abc")，如果 str 为 null 值，那么第一种不会报错，第二种会报错。
5、在 String 中，还有一种方法可以比较，"Abc".equalsIgnoreCase("abc")， 即进行比较，不区分大小。
字符串相关方法
public int length()：获取字符串当中含有的字符个数
public String concat(String str)：将当前字符串和参数字符串拼接成为新的字符串作为返回值
public char charAt(int index)：获取指定索引位置的单个字符
public int indexOf(String str)：查找参数字符串在本字符串当中首次出现的索引位置，如果没有则返回 -1
简单练习：
public class test {
public static void main(String[] args) {
String str1 = "Hi, Alex. I'm ";
String str2 = "Jim";
// 拼接字符串
String str3 = str1.concat(str2);
System.out.println("拼接后的字符串 str3 是：" + str3);
// 查看字符串的长度
System.out.println("\"" + str3 + "\" 字符串的长度是：" + str3.length());
// 查看索引位置的字符
char a = str3.charAt(5);
System.out.println("在第 5 个位置的字符是：\'" + a + "\'");
// 查看参数字符串在原来字符串中第一次出现的索引
System.out.println("\"Alex\" 在字符串 \"" + str3 + "\" 中第一次出现的位置是：" + str3.indexOf("Alex"));
System.out.println("\"am\" 在字符串 \"" + str3 + "\" 中第一次出现的位置是：" + str3.indexOf("am"));
}
}
输出：
拼接后的字符串 str3 是：Hi, Alex. I'm Jim
"Hi, Alex. I'm Jim" 字符串的长度是：17
在第 5 个位置的字符是：'l'
"Alex" 在字符串 "Hi, Alex. I'm Jim" 中第一次出现的位置是：4
"am" 在字符串 "Hi, Alex. I'm Jim" 中第一次出现的位置是：-1
截取子字符串
public String substring(int index)：截取从参数位置一直到字符串末尾，返回新字符串
public String substring(int begin, int end)：截取从 begin 开始，end 结束的中间的字符串，[begin, end)
public class test {
public static void main(String[] args) {
String str1 = "Hi, Alex. I'm Jim";
String subStr1 = str1.substring(4);
String subStr2 = str1.substring(4, 8);
System.out.println("subStr1: " + subStr1);
System.out.println("subStr2: " + subStr2);
}
}
输出：
subStr1: Alex. I'm Jim
subStr2: Alex
字符串一旦创建不可变的理解：假如创建了一个字符串 String str1 = “Wow!”，另外我们给 str1 重新赋值 str1 = “Java”，最后输出的是 Java，这不是已经变了么？其实不是的，以前我们创建的存放 “Wow!” 依然存在。我们的重新赋值只不过将地址指向了另外一个字符串。
字符串转换
public char[] toCharArray()：将当前字符串拆分成为字符数组作为返回值
public byte[] getBytes()：获得当前字符串底层的字节数组
public String replace(CharSequence oldString, CharSequence newString)：将所有出现的老字符串替换成为新的额字符串，返回替换之后的结果新字符串
注意：上面的 CharSequence 即可接受字符串类型
public class test {
public static void main(String[] args) {
String str1 = "Hi, Alex. I'm Jim";
System.out.println(str1);
// 转换成字符型数组
char[] charArray = str1.toCharArray();
for (int i = 0; i < charArray.length; i++) {
System.out.print(charArray[i] + "-");
}
System.out.println();
// 转换成为字节型数组
byte[] bytes = str1.getBytes();
for (int i = 0; i < bytes.length; i++) {
System.out.print(bytes[i] + " ");
}
System.out.println();
// 替换
String str2 = str1.replace("Alex", "fjc");
System.out.println(str2);
}
}
输出：
Hi, Alex. I'm Jim
H-i-,- -A-l-e-x-.- -I-'-m- -J-i-m-
72 105 44 32 65 108 101 120 46 32 73 39 109 32 74 105 109
Hi, fjc. I'm Jim
字符串分割方法
public String[] split(String regex)：按照参数的规则，将字符串切分成若干部分
注意：split 方法中的参数是一个正则表达式
public class test {
public static void main(String[] args) {
String str1 = "Hi, Alex. I'm Jim";
// 按照空格切割
String[] strs = str1.split(" ");
for (int i = 0; i < strs.length; i++) {
System.out.println(strs[i]);
}
}
}
输出：
Hi,
Alex.
I'm
Jim
简单练习
计算一个字符串内大写字母，小写字母，数字，其它字符各有多少个
public class test {
public static void main(String[] args) {
String str = "fRfsvt3sDf2a6.47qVs3,54E";
int numberNum = 0;
int upperNum = 0;
int lowerNum = 0;
int otherNum = 0;
char[] charArray = str.toCharArray();
for (int i = 0; i < charArray.length; i++) {
char ch = charArray[i];
if (ch >= 'A' && ch <= 'Z')
upperNum++;
else if (ch >= 'a' && ch <= 'z')
lowerNum++;
else if (ch >= '0' && ch <= '9')
numberNum++;
else
otherNum++;
}
System.out.println("数字有："+ numberNum);
System.out.println("大写有："+ upperNum);
System.out.println("小写有："+ lowerNum);
System.out.println("其它有："+ otherNum);
}
}
输出：
数字有：8
大写有：4
小写有：10
其它有：2
static 关键字
在 Java 中，一旦用了 static 关键字，那么这样的内容就不再属于对象自己，而是属于类的。即凡是本类的对象，都共享同一份数据。
static 修饰成员变量
简单举例：
public class Student {
private int id;
private String name;
private int age;
private static int idCounter = 0;
public Student() {
this.id = ++idCounter;
}
public Student(String name, int age) {
this.id = id;
this.name = name;
this.age = age;
this.id = ++idCounter;
}
public static int getIdCounter() {
return idCounter;
}
public static void setIdCounter(int idCounter) {
Student.idCounter = idCounter;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class test {
public static void main(String[] args) {
Student stu1 = new Student("小明", 23);
Student stu2 = new Student("小红", 21);
Student stu3 = new Student("小孙", 19);
System.out.println("姓名：" + stu1.getName() + "，年龄：" + stu1.getAge() + "，学号：" + stu1.getId());
System.out.println("姓名：" + stu2.getName() + "，年龄：" + stu2.getAge() + "，学号：" + stu2.getId());
System.out.println("姓名：" + stu3.getName() + "，年龄：" + stu3.getAge() + "，学号：" + stu3.getId());
}
}
输出：
姓名：小明，年龄：23，学号：1
姓名：小红，年龄：21，学号：2
姓名：小孙，年龄：19，学号：3
static 修饰成员方法
一旦使用了 static 修饰成员方法，那么这个方法就成了静态发那个方法。静态方法不属于对象，而属于类。
如果有了 static 关键字，那么不需要创建对象，直接就能通过类名来使用它
public class Method {
// 定义一个普通成员方法
public void ordinaryMethod() {
System.out.println("这是一个普通成员方法");
}
// 定义一个静态成员方法
public static void staticMethod() {
System.out.println("这是一个静态成员方法");
}
}
public class test {
public static void main(String[] args) {
Method obj = new Method();
obj.ordinaryMethod();
obj.staticMethod(); // 对象调用静态成员方法
Method.staticMethod(); // 类调用静态成员方法
}
}
输出：
这是一个普通成员方法
这是一个静态成员方法
这是一个静态成员方法
对于上面定义的方法来说，我们可以对象来调用静态成员方法，也可以使用类来调用静态成员方法。不过我们一般不建议使用对象来调用静态成员方法，在编译的过程中，对象调用静态成员方法也会被翻译为类调用静态成员方法。所以我们更多的是用类来调用静态成员方法
静态变量：类名称.静态变量
静态方法：类名称.静态方法()
注意事项：
1、静态不能直接访问非静态
因为在内存当中，先有静态内容，再有非静态内容。“先人不知道后人，后人知道先人”
2、静态方法当中不能用 this，
因为 this 代表当前对象，谁调用的方法，谁就是当前对象
3、根据类访问惊天成员变量的时候，全程和对象就没关系，只和类有关系
静态代码块
格式：
public class 类名称 {
static {
// 静态代码块的内容
}
}
特点：当第一次用到本类的时候，静态代码块执行唯一的一次
静态内容总是优先于非静态，所以静态代码块比构造方法更先执行
用途：
用来一次性地对静态成员变量进行赋值
public class Person {
static {
System.out.println("静态代码块执行了！");
}
public Person() {
System.out.println("构造方法执行了！");
}
}
public class test {
public static void main(String[] args) {
System.out.println("创建 person1: ");
Person person1 = new Person();
System.out.println("\n创建 person2: ");
Person person2 = new Person();
}
}
输出：
创建 person1:
静态代码块执行了！
构造方法执行了！
创建 person2:
构造方法执行了！
数组工具类 Arrays
所属类
import java.util.Arrays;
public static String toString(数组)：将参数数组变成字符串，按照默认形式 [元素1, 元素2, 元素3, 元素3, ···]
public static ovid sort(数组)：按照升序对数组的元素进行排序
注意：
1、如果是数值， sort 默认按照升序从小到大排序
2、如果是字符串，sort 默认按照字母升序排列
3、如果是自定义的类型的话，那么这个自定义的类需要有 Comparable 或者 Comparator 接口的支持
import java.util.Arrays;
public class test {
public static void main(String[] args) {
int[] a = {1, 4, 6, 3, 7};
String[] str = {"aaa", "ccc", "ddd"};
Arrays.sort(a);
System.out.println(Arrays.toString(a));
Arrays.sort(str);
System.out.println(Arrays.toString(str));
}
}
输出：
[1, 3, 4, 6, 7]
[aaa, ccc, ddd]
将字符串内容排序并并进行倒叙打印
import java.util.Arrays;
public class test {
public static void main(String[] args) {
String randomStr = "dafgavxcaf";
char[] charArray = randomStr.toCharArray();
// 排序
Arrays.sort(charArray);
// 倒序打印
for (int i = charArray.length -1; i >= 0; i--) {
System.out.print(charArray[i]);
}
System.out.println();
}
}
输出：
xvgffdcaaa
Math 类
在 Java 中， Math 类是数学相关的工具类，里面提供了大量的静态方法。完成与数学运算相关的操作
所属包（不需要导入包即可使用）
import java.util.Math;
public static double abs(double num)：获取绝对值
public static double ceil(double num)：向上取整
public static double floor(double num)：向下取整
public static long round(double num)：四舍五入
public class test {
public static void main(String[] args) {
double num = -25.3;
System.out.println("绝对值：" + Math.abs(num));
System.out.println("向下取整：" + Math.ceil(num));
System.out.println("向上取整：" + Math.floor(num));
System.out.println("四舍五入：" + Math.round(num));
}
}
输出：
绝对值：25.3
向下取整：-25.0
向上取整：-26.0
四舍五入：-25
以上为 Java 学习整理笔记，如有错误，请留言提出