JAVA学习笔记_常用API

1. 什么叫API

• 概述：

  API(Application Programming Interface)，应用程序编程接口。Java API是一本程序员的 字典 ，是JDK中提供给我们使用的类的说明文档。这些类将底层的代码实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可。所以我们可以通过查询API的方式，来学习Java提供的类，并得知如何使用它们 。

• API使用步骤：

  1. 打开帮助文档。
  2. 点击显示，找到索引，看到输入框。
  3. 你要找谁？在输入框里输入，然后回车。
  4. 看包。java.lang下的类不需要导包，其他需要。
  5. 看类的解释和说明。
  6. 学习构造方法。
  7. 使用成员方法。

2. Scanner类

• 什么是Scanner类

一个可以使用正则表达式来解析基本类型和字符串的简单文本扫描器。

• 使用

  Scanner sc = new Scanner(System.in);
  int i = sc.nextInt();
  

  备注：System.in 系统输入指的是通过键盘录入数据。

• Scanner使用步骤

引用类型的一般使用步骤：

1. 导包
   import 包路径.类名称;
   如果需要使用的目标类，和当前类位于同一个包下，则可以省略导包语句不写。
   只有java.lang包下的内容不需要导包，其他的包都需要import语句。

2. 创建
   类名称 对象名 = new 类名称();

3. 使用
   对象名.成员方法名()

import java.util.Scanner; //导包

public class DemoScanner {

    public static void main(String[] args) {
        // 2. 创建
        // 备注：System.in代表从键盘进行输入
        Scanner sc = new Scanner(System.in);

        // 3. 获取键盘输入的int数字
        int num = sc.nextInt();
        System.out.println("输入的int数字是：" + num);

        // 4. 获取键盘输入的字符串
        String str = sc.next();
        System.out.println("输入的字符串是：" + str);
    }
}

3. Random 类

Random类用来生成随机数字。使用起来也是三个步骤：

1. 导包
   import java.util.Random;
2. 创建
   Random r = new Random(); // 小括号当中留空即可
3. 使用
   获取一个随机的int数字（范围是int所有范围，有正负两种）：int num = r.nextInt()
   获取一个随机的int数字（参数代表了范围，左闭右开区间）：int num = r.nextInt(3)
   实际上代表的含义是：[0,3)，也就是0~2

• 实列生成100以内的随机整数

  // 1.导包
  import java.util.Random;
  
  public class DemoRandom {
      public static void main(String[] args) {
        // 2.创建
          Random num_r = new Random();
          for (int i = 0; i < 10; i++) {
              // 3.使用
              int num = num_r.nextInt(100);
              System.out.println("Random number is : " + num);
          }
      }
  }
  

• 猜数字小游戏

  import java.util.Random;
  import java.util.Scanner;
  
  public class DemoGuessRandomnum {
      public static void main(String[] args) {
          // 系统产生一个随机数1‐100之间的。
          Random r = new Random();
          int number = r.nextInt(100) + 1;
          int num = 0;
          while (true) {
              // 键盘录入我们要猜的数据
              Scanner sc = new Scanner(System.in);
              System.out.println("请输入你要猜的数字(1‐100)：");
              int guessNumber = sc.nextInt();
              num++;
              // 比较这两个数据(用if语句)
              if (guessNumber > number) {
                  System.out.println("你猜的数据" + guessNumber + "大了");
              } else if (guessNumber < number) {
                  System.out.println("你猜的数据" + guessNumber + "小了");
              } else {
                  System.out.println("恭喜你,猜中了");
                  System.out.println("一共猜了" + num + "次");
                  System.out.println("游戏结束......");
                  break;
              }
          }
      }
  }
  

4. ArrayList 类

数组的长度不可以发生改变。
但是ArrayList集合的长度是可以随意变化的。

对于ArrayList<E>来说，有一个尖括号<E>代表泛型。
泛型：也就是装在集合当中的所有元素，全都是统一的什么类型。泛型只能是引用类型，不能是基本类型。

注意事项：
对于ArrayList集合来说，直接打印得到的不是地址值，而是内容。
如果内容是空，得到的是空的中括号：[]

// 导包

import java.util.ArrayList;

public class DemoArrayList {
    public static void main(String[] args) {
        // 创建
        ArrayList<String> list = new ArrayList<>();
        // 使用
        list.add("床前明月光，");
        System.out.println(list);
        list.add("疑是地上霜。");
        list.add("举头望明月，");
        list.add("低头思故乡。");
        System.out.println(list);
    }
}

4.1 ArrayList 常用的方法

• public boolean add(E e)：向集合当中添加元素，参数的类型和泛型一致。返回值代表添加是否成功（boolean 类型）。
  备注：对于ArrayList集合来说，add添加动作一定是成功的，所以返回值可用可不用。但是对于其他集来说，add添加动作不一定成功。
• public E get(int index)：从集合当中获取元素，参数是索引编号，返回值就是对应位置的元素。
• public E remove(int index)：从集合当中删除元素，参数是索引编号，返回值就是被删除掉的元素。
• public int size()：获取集合的尺寸长度，返回值是集合中包含的元素个数。

4.2 存储的基本数据类型

基本类型 包装类（引用类型，包装类都位于java.lang包下）
byte Byte
short Short
int Integer 【特殊】
long Long
float Float
double Double
char Character 【特殊】
boolean Boolean

import java.util.ArrayList;

public class DemoArrayListBasic {

    public static void main(String[] args) {
        ArrayList<String> listA = new ArrayList<>();
        
        // 错误写法！泛型只能是引用类型，不能是基本类型
        //ArrayList<int> listB = new ArrayList<>();
        ArrayList<Integer> listC = new ArrayList<>();
        listC.add(100);
        listC.add(200);
        System.out.println(listC); // [100, 200]
        int num = listC.get(1);
        System.out.println("第1号元素是：" + num);
    }
}

• 实列

  //题目：
  //        用一个大集合存入20个随机数字(0-99)，然后筛选其中的偶数元素，放到小集合当中。
  //        要求使用自定义的方法来实现筛选。
  
  import java.util.ArrayList;
  import java.util.List;
  import java.util.Random;
  
  public class Demo10Test04 {
      public static void main(String[] args) {
          Random r = new Random();
          ArrayList<Integer> list_big = new ArrayList<>();
          ArrayList<Integer> list = new ArrayList<>();
          for (int i = 0; i < 20; i++) {
              list_big.add(r.nextInt(100)) ;
          }
          for (int i = 0; i < list_big.size(); i++) {
              if (list_big.get(i)%2 == 0){
              list.add(list_big.get(i));
              }
          }
          System.out.println(list_big);
          System.out.println(list);
      }
  } 
  

5. String 类

java.lang.String类代表字符串。
API当中说：Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。
其实就是说：程序当中所有的双引号字符串，都是String类的对象。（就算没有new，也照样是。）

1. 字符串的内容永不可变。【重点】
2. 正是因为字符串不可改变，所以字符串是可以共享使用的。
3. 字符串效果上相当于是char[]字符数组，但是底层原理是byte[]字节数组。

创建字符串的常见3+1种方式。
三种构造方法：
public String()：创建一个空白字符串，不含有任何内容。
public String(char[] array)：根据字符数组的内容，来创建对应的字符串。
public String(byte[] array)：根据字节数组的内容，来创建对应的字符串。
一种直接创建：
String str = "Hello"; // 右边直接用双引号

注意：直接写上双引号，就是字符串对象。

• public boolean equals(Object obj)：参数可以是任何对象，只有参数是一个字符串并且内容相同的才会给true；否则返回false。

  如：

  String 常用的四种创造方法

  public class DemoStringBuild {
      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 = {88, 89, 90};
          String str3 = new String(byteArray);
          System.out.println("str3 = " + str3);
  
          // 使用""直创建
          String str4 = "直接创建";
        System.out.println("str4 = " + str4);
      }
  }
  

5.1 字符串常量池

字符串常量池:程序当中直接写上的双引号字符串，就在字符串常量池中。

对于基本类型来说，== 是进行数值的比较。
对于引用类型来说，== 是进行【地址值】的比较。

在创建String时使用""创建的字符串放在了字符串常量池中，而是new创建的放在队堆（heap）中

<img src=" http://www.fate-p.cn/img/01_StringConstPool.png" alt="StringConstPool.png" style="zoom: 67%;" />

public class StringPool {
    public static void main(String[] args) {
        String str1 = "abc";
        String str2 = "abc";

        char[] charArray = {'a', 'b', 'c'};
        String str3 = new String(charArray);

        byte[] byteArray = {97, 98 ,99};
        String str4 = new String(byteArray);

        System.out.println(str1 == str2); // true
        System.out.println(str1 == str3); // false
        System.out.println(str2 == str4); // false
    }
}

• 字符串的内容比较，可以使用两个方法：

  • public boolean equals(Object obj)：参数可以是任何对象，只有参数是一个字符串并且内容相同的才会给true；否则返回false。

    如：

    String 常用的四种创造方法

  public class DemoStringBuild {
  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 = {88, 89, 90};
        String str3 = new String(byteArray);
        System.out.println("str3 = " + str3);
  
        // 使用""直创建
        String str4 = "直接创建";
        System.out.println("str4 = " + str4);
    }
  

  }

  
  
  
  - `public boolean equalsIgnoreCase(String str)`：忽略大小写，进行内容比较。
  
  ```java
  public class DemoStringEquals {
    public static void main(String[] args) {
        String str1 = "ABC";
  
        char[] charArray = {'A', 'B', 'C'};
        String str2 = new String(charArray);
  
        byte[] byteArray = {65, 66, 67};
        String str3 = new String(byteArray);
  
        String str4 = "ABc";
        String str5 = null;
  
        System.out.println(str1.equals(str2)); //true
        System.out.println(str3.equals(str2)); //true
        System.out.println(str2.equals(str4)); //false
        System.out.println(str2.equalsIgnoreCase(str3)); //true
        System.out.println("abc".equals(str5)); //推荐 false
        //System.out.println(str5.equals("abc")); //不推荐：报错，空指针异常                  //NullPointerException
    }
  }
  

5.2 String 中的常用方法

5.2.1 与获取相关的方法

1. public int length()：获取字符串当中含有的字符个数，拿到字符串长度。
2. public String concat(String str)：将当前字符串和参数字符串拼接成为返回值新的字符串。
3. public char charAt(int index)：获取指定索引位置的单个字符。（索引从0开始。）
4. public int indexOf(String str)：查找参数字符串在本字符串当中首次出现的索引位置，如果没有返回-1值。

public class DemoStringGet {
    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = "World";
        // 获取字符串的长度
        System.out.println("str1的长度为:" + str1.length());
        System.out.println("==============");

        // 拼接
        String str3 = str1.concat(str2);
        System.out.println("str1 拼接 str2 = " + str3);
        System.out.println("==============");

        // 获取字符串索引值位置的单个字符
        System.out.println("str3中的第三个字符为: " + str3.charAt(2));
        System.out.println("==============");

        // 获取查找的字符串参数在字符串中的第一次出现的位置,没找到返回-1
        String str4 = "JAVAJAVAJAVAJAVA";
        System.out.println("AV在字符串str4中第一次出现的索引值为:" + str4.indexOf("AV"));
        System.out.println("PP在字符串str4中第一次出现的索引值为:" + str4.indexOf("PP"));
    }
}

5.2.2 字符串的截取方法

1. public String substring(int index)：截取从参数位置一直到字符串末尾，返回新字符串。
2. public String substring(int begin, int end)：截取从begin开始，一直到end结束，中间的字符串。
   备注：[begin,end)，包含左边，不包含右边

public class DemoSubString {
    public static void main(String[] args) {
        String str1 = "HelloWorld";
        String str2 = str1.substring(5);
        System.out.println(str1); // HelloWorld，原封不动
        System.out.println(str2); // World，新字符串
        System.out.println("================");

        String str3 = str1.substring(4, 7);
        System.out.println(str3); // oWo
        System.out.println("================");
    }
}

5.2.3 字符串与转换相关的方法

1. public char[] toCharArray()：将当前字符串拆分成为字符数组作为返回值。
2. public byte[] getBytes()：获得当前字符串底层的字节数组。
3. public String replace(CharSequence oldString, CharSequence newString)：将所有出现的老字符串替换成为新的字符串，返回替换之后的结果新字符串。
   备注：CharSequence意思就是说可以接受字符串类型。

public class DemoStringConvert {
    public static void main(String[] args) {
        // 转换成为字符数组
        char[] chars = "Hello".toCharArray();
        System.out.println(chars[0]); // H
        System.out.println(chars.length); // 5
        System.out.println("==============");

        // 转换成为字节数组
        byte[] bytes = "abc".getBytes();
        for (int i = 0; i < bytes.length; i++) {
            System.out.println(bytes[i]);
        }
        System.out.println("==============");

        // 字符串的内容替换
        String str1 = "How do you do?";
        String str2 = str1.replace("o", "*");
        System.out.println(str1); // How do you do?
        System.out.println(str2); // H*w d* y*u d*?
        System.out.println("==============");

    }
}

5.2.4 字符串的分割方法

public String[] split(String regex)：按照参数的规则，将字符串切分成为若干部分。

注： regex 使用的为正则表达式进行切割

public class DemoStringSplit {
    public static void main(String[] args) {
        
        String str = "aaa,AAA,ccc,DDD";
        String[] array1 = str.split(",");
        for (int i = 0; i < array1.length; i++) {
            System.out.println(array1[i]);
        }
    }
}

附：正则表达式表

字符	描述
\	将下一个字符标记为一个特殊字符、或一个原义字符、或一个向后引用、或一个八进制转义符。例如，“n"匹配字符"n"。"\n"匹配一个换行符。串行"\\"匹配"\"而"\("则匹配"("。
^	匹配输入字符串的开始位置。如果设置了RegExp对象的Multiline属性，^也匹配“\n"或"\r"之后的位置。
$	匹配输入字符串的结束位置。如果设置了RegExp对象的Multiline属性，$也匹配“\n"或"\r"之前的位置。
*	匹配前面的子表达式零次或多次。例如，zo能匹配“z"以及"zoo"。等价于{0,}。
+	匹配前面的子表达式一次或多次。例如，“zo+"能匹配"zo"以及"zoo"，但不能匹配"z"。+等价于{1,}。
?	匹配前面的子表达式零次或一次。例如，“do(es)?"可以匹配"does"或"does"中的"do"。?等价于{0,1}。
{n}	n是一个非负整数。匹配确定的n次。例如，“o{2}"不能匹配"Bob"中的"o"，但是能匹配"food"中的两个o。
{n,}	n是一个非负整数。至少匹配n次。例如，“o{2,}"不能匹配"Bob"中的"o"，但能匹配"foooood"中的所有o。"o{1,}"等价于"o+"。"o{0,}"则等价于"o*"。
{n,m}	m和n均为非负整数，其中n<=m。最少匹配n次且最多匹配m次。例如，“o{1,3}"将匹配"fooooood"中的前三个o。"o{0,1}"等价于"o?"。请注意在逗号和两个数之间不能有空格。
?	当该字符紧跟在任何一个其他限制符（,+,?，{n}，{n,}，{n,m*}）后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串“oooo"，"o+?"将匹配单个"o"，而"o+"将匹配所有"o"。
.	匹配除“\n"之外的任何单个字符。要匹配包括"\n"在内的任何字符，请使用像"(.|\n)"的模式。
(pattern)	匹配pattern并获取这一匹配。所获取的匹配可以从产生的Matches集合得到，在VBScript中使用SubMatches集合，在JScript中则使用9属性。要匹配圆括号字符，请使用“\("或"\)"。
(?:pattern)	匹配pattern但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供以后使用。这在使用或字符“(|)"来组合一个模式的各个部分是很有用。例如"industr(?:y|ies)"就是一个比"industry|industries"更简略的表达式。
(?=pattern)	正向肯定预查，在任何匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如，“Windows(?=95|98|NT|2000)"能匹配"Windows2000"中的"Windows"，但不能匹配"Windows3.1"中的"Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。
(?!pattern)	正向否定预查，在任何不匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如“Windows(?!95|98|NT|2000)"能匹配"Windows3.1"中的"Windows"，但不能匹配"Windows2000"中的"Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始
(?<=pattern)	反向肯定预查，与正向肯定预查类拟，只是方向相反。例如，“(?<=95|98|NT|2000)Windows"能匹配"2000Windows"中的"Windows"，但不能匹配"3.1Windows"中的"Windows"。
(?<!pattern)	反向否定预查，与正向否定预查类拟，只是方向相反。例如“(?"能匹配"3.1Windows"中的"Windows"，但不能匹配"2000Windows"中的"Windows`"。
x|y	匹配x或y。例如，“z|food"能匹配"z"或"food"。"(z|f)ood"则匹配"zood"或"food"。
[xyz]	字符集合。匹配所包含的任意一个字符。例如，“[abc]"可以匹配"plain"中的"a"。
[^xyz]	负值字符集合。匹配未包含的任意字符。例如，“[^abc]"可以匹配"plain"中的"p"。
[a-z]	字符范围。匹配指定范围内的任意字符。例如，“[a-z]"可以匹配"a"到"z"范围内的任意小写字母字符。
[^a-z]	负值字符范围。匹配任何不在指定范围内的任意字符。例如，“[^a-z]"可以匹配任何不在"a"到"z"范围内的任意字符。
\b	匹配一个单词边界，也就是指单词和空格间的位置。例如，“er\b"可以匹配"never"中的"er"，但不能匹配"verb"中的"er"。
\B	匹配非单词边界。“er\B"能匹配"verb"中的"er"，但不能匹配"never"中的"er"。
\cx	匹配由x指明的控制字符。例如，\cM匹配一个Control-M或回车符。x的值必须为A-Z或a-z之一。否则，将c视为一个原义的“c"字符。
\d	匹配一个数字字符。等价于[0-9]。
\D	匹配一个非数字字符。等价于[^0-9]。
\f	匹配一个换页符。等价于\x0c和\cL。
\n	匹配一个换行符。等价于\x0a和\cJ。
\r	匹配一个回车符。等价于\x0d和\cM。
\s	匹配任何空白字符，包括空格、制表符、换页符等等。等价于[ \f\n\r\t\v]。
\S	匹配任何非空白字符。等价于[^ \f\n\r\t\v]。
\t	匹配一个制表符。等价于\x09和\cI。
\v	匹配一个垂直制表符。等价于\x0b和\cK。
\w	匹配包括下划线的任何单词字符。等价于“[A-Za-z0-9_]"。
\W	匹配任何非单词字符。等价于“[^A-Za-z0-9_]"。
\xn	匹配n，其中n为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如，“\x41"匹配"A"。"\x041"则等价于"\x04&1"。正则表达式中可以使用ASCII编码。.
*num*	匹配num，其中num是一个正整数。对所获取的匹配的引用。例如，“(.)\1"匹配两个连续的相同字符。
*n*	标识一个八进制转义值或一个向后引用。如果*n之前至少n个获取的子表达式，则n为向后引用。否则，如果n为八进制数字（0-7），则n*为一个八进制转义值。
*nm*	标识一个八进制转义值或一个向后引用。如果*nm之前至少有nm个获得子表达式，则nm为向后引用。如果*nm之前至少有n个获取，则n为一个后跟文字m的向后引用。如果前面的条件都不满足，若n和m均为八进制数字（0-7），则*nm将匹配八进制转义值nm*。
*nml*	如果n为八进制数字（0-3），且m和l均为八进制数字（0-7），则匹配八进制转义值nml。
\un	匹配n，其中n是一个用四个十六进制数字表示的Unicode字符。例如，\u00A9匹配版权符号（©）。

5.3 字符串的简单练习

题目：
键盘输入一个字符串，并且统计其中各种字符出现的次数。
种类有：大写字母、小写字母、数字、其他

import java.util.Scanner;

public class DemoStringtest {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String input_str = sc.next();

        int countUpper = 0, countLower = 0, countNumber = 0, countOther = 0;
        char[] charArray = input_str.toCharArray();
        for (int i = 0; i < charArray.length; i++) {
            if (charArray[i] >= '0' && charArray[i] <= '9') {
                countNumber++;
            } else if (charArray[i] >= 'A' && charArray[i] <= 'Z') {
                countUpper++;
            } else if (charArray[i] >= 'a' && charArray[i] <= 'z') {
                countLower++;
            } else {
                countOther++;
            }
        }
        System.out.println("大写字母有：" + countUpper);
        System.out.println("小写字母有：" + countLower);
        System.out.println("数字有：" + countNumber);
        System.out.println("其他字符有：" + countOther);
    }
}

6 Static 类

• 在一个类中如果一个成员变量使用了static关键字，那么这个变量不再属于对象自己，而是属于所在的类。多个对象共享同一份数据。

• 一旦使用static修饰成员方法，那么这就成为了静态方法。静态方法不属于对象，而是属于类的。

  对于静态的成员变量、静态的成员方法都推荐使用类名称进行调用。
  静态变量：类名称.静态变量
  静态方法：类名称.静态方法()

  注意事项：

  1. 静态不能直接访问非静态。
     原因：因为在内存当中是【先】有的静态内容，【后】有的非静态内容。
  2. 静态方法当中不能用this。
     原因：this代表当前对象，静态方法使用类名称进行调用。

• 静态代码块的格式：

  static {
      // 静态代码块的内容
  }
  

  特点：

  ​ 当第一次用到本类时，静态代码块执行唯一的一次。
  ​ 静态内容总是优先于非静态，所以静态代码块比构造方法先执行。

  静态代码块的典型用途：
  用来一次性地对静态成员变量进行赋值。

7 Arrays 工具类

java.util.Arrays是一个与数组相关的工具类，里面提供了大量静态方法，用来实现数组常见的操作。

public static String toString(数组)：将参数数组变成字符串（按照默认格式：[元素1, 元素2, ...]）
public static void sort(数组)：按照默认升序（从小到大）对数组的元素进行排序。

备注：

1. 如果是数值，sort 默认按照升序从小到大
2. 如果是字符串，sort 默认按照字母升序
3. 如果是自定义的类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持。

import java.util.Arrays;

public class DemoArrays {
    public static void main(String[] args) {
        int[] intArray = {1, 2, 5, 4, 3, 9, 8};
        // Arrays.toString() 将数组转为字符串
        System.out.println(Arrays.toString(intArray));

        // Arrays.sort() 将数组按照降序排列
        Arrays.sort(intArray);
        System.out.println(Arrays.toString(intArray));
    }
}

8 Math 工具类

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)：四舍五入。

Math.PI代表近似的圆周率常量（double）。

public class DemoMath {
    public static void main(String[] args) {
        // 取绝对值
        System.out.println(Math.abs(3.14));
        System.out.println(Math.abs(-320.56));
        System.out.println("================");

        // 向上取整(取大)
        System.out.println(Math.ceil(3.9)); // 4.0
        System.out.println(Math.ceil(-3.1)); // -3
        System.out.println(Math.ceil(3.0)); // 3.0
        System.out.println("================");

        // 向下取整（取小）
        System.out.println(Math.floor(30.1)); // 30.0
        System.out.println(Math.floor(-30.9)); // -31.0
        System.out.println(Math.floor(31.0)); // 31.0
        System.out.println("================");
        // 四舍五入（取整）
        System.out.println(Math.round(20.4)); // 20
        System.out.println(Math.round(10.5)); // 11

        // π
        System.out.println(Math.PI);
    }
}