Java 常用 API

一、Math

Math 包含执行基本数字运算的方法。
Math 没有构造方法，那么如何使用类中的成员呢？
通过查看帮助文档，看类的成员是否都是静态的，如果是，那我们可以通过类名直接调用。

如果 API 在 java.lang 包下，则使用的时候是不需要导包的！

Math 类的常用方法：

//Test.java
package com.an;
public class Test {
    public static void main(String[] args) {
        System.out.println(Math.max(12, 23)); //23
        System.out.println(Math.ceil(12.55)); //13.0
        System.out.println(Math.round(12.37)); //12
        System.out.println(Math.abs(-1)); //1
    }
}

//随机生成0到100之间的整数，包括0，不包括100
(int)(Math.random() * 100)

二、System

System 包含几个有用的类字段和方法，它不能被实例化，因为它的成员都是被静态修饰的，那我们可以通过类名来访问。

System 类的常用方法：

//终止Java虚拟机
System.exit(0); 
//当前时间与1970年之间所隔的年数
System.currentTimeMillis() * 1.0 / 1000 / 60 / 60 / 24 / 365 

//计算for循环耗时多久
long start = System.currentTimeMillis();
for (int i = 0; i < 10000; i++) {
    System.out.println(i);
}
long end = System.currentTimeMillis();
System.out.println("共耗时：" + (end - start) + "毫秒！");

三、Object

类 Object 是类层次结构的根。每个类都有 Object 作为超类，所有对象（包括数组）都直接或间接地继承自该类。

回想面向对象中，为什么说子类的构造方法默认访问的是父类的无参构造方法？
因为它们的顶级父类只有无参构造方法。

想要查看方法的源码，选中方法，按下 Ctrl + B！

1. toString() 方法

toString() 方法返回对象的字符串表示形式。

Student s = new Student();
s.setName("刘德华");
s.setAge(30);
System.out.println(s);

如上代码，程序的输出结果其实是 s 的地址，为什么不是 s 对象的内容呢？
这是因为，直接输出 s 其实默认调用的是 Object 中的 toString() 方法，而 toString 方法中定义的就是对象的地址。
如何输出对象内容呢？
在 Student 类中重写 toString() 方法即可。这里重写方法不需要你去自己写，我们还是按下 Alt + Insert，找到 toString()，将成员变量全部选中，最后回车键就可以了。

2. equals() 方法

equals() 方法用于比较两个对象是否相等。

//比较s1和s2的内容是否相同
Student s1 = new Student();
s1.setName("刘德华");
s1.setAge(30);
Student s2 = new Student();
s2.setName("刘德华");
s2.setAge(30);
System.out.println(s1.equals(s2));

这里千万不要犯 s1 == s2 这样的低级错误，学生对象是引用类型，直接比较的话，比较的其实它们的是地址，不是内容，答案显然是 false。
但是当我们写成 s1.equals(s2) 的时候，结果仍然是 false，WHY？
因为 equals() 方法默认比较的原则依然是比较地址。同样，需要在 Student 类中重写 equals() 方法，Alt + Insert，找到 equals() and hashCode()，它会帮我们重写两个方法，一会把后面那个删掉即可，点进去 Template 下，我们选 IntelliJ Default 模板，一直 Next，Finish。

四、Arrays

1. 冒泡排序

定义：冒泡排序是一种排序的方式，对要进行排序的数据中相邻的数据进行两两比较，将较大的数据放在后面，依次对所有的数据进行操作，直至所有数据都按要求完成排序。

① 如果有 n 个数据进行排序，总共需要比较 n - 1 次；
② 每一次比较完毕，下一次的比较就会少一个数据参与。

//Test.java
package com.an;
public class Test {
    public static void main(String[] args) {
        int[] arr = {12, 3, 69, 42, 7, 25};
        //数组从小到大冒泡排序
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        String result = arrayToString(arr);
        System.out.println(result);
    }
    //把数组中的元素按照指定的规则组成一个字符串
    public static String arrayToString(int[] arr) {
        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. Arrays 常用方法

如上是冒泡排序的代码，看起来非常繁琐。现在我们学习 Arrays 的两个常用方法，不需要自己写代码，直接调用方法实现冒泡排序功能。

//Test.java
package com.an;
import java.util.Arrays;
public class Test {
    public static void main(String[] args) {
        int[] arr = {12, 3, 69, 42, 7, 25};
        Arrays.sort(arr);
        String s = Arrays.toString(arr);
        System.out.println(s);
    }   
}

工具类的设计思想：
① 构造方法用 private 修饰，为防止外界创建对象；
② 成员用 public static 修饰，让外界可以使用类名直接访问成员方法。

五、基本类型包装类

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。
常用的操作之一：用于基本数据类型与字符串之间的转换。

//判断一个数据是否在int范围内
int number;
if (number >= Integer.MIN_VALUE && number <= Integer.MAX_VALUE) {
    System.out.println("true");
}

1. Integer

Integer 包装一个对象中的原始类型 int 的值。

//返回表示指定的int值的Integer实例
Integer i = Integer.valueOf(100);
System.out.println(i);

2. int 和 String 相互转换

① int 类型转换为 String 类型

int number = 100;
//方式一
String s1 = "" + number;
//方式二
String s2 = String.valueOf(number);

② String 类型转换为 int 类型

String s = "100";
//方式一
Integer i = Integer.valueOf(s);
int x = i.intValue();
//方式二
int y = Integer.parseInt(s);

3. 字符串中数据排序

需求：有一个字符串：“91 27 46 38 50”，请写程序实现最终输出结果：“27 38 46 50 91”。

思路：
① 给数据排序，我们首先想到的就是数组的排序方法，Arrays.sort(arr)；
② 现在题目给出的是一个字符串，并非数组，而我们需要将字符串中用空格隔开的这些数据都一一对应地复制到一个数组中，进行排序；
③ 字符串中的每个数据都要搬运到一个新的数组中，一定是要用到 for 循环进行遍历，数组遍历的前提得有终止条件，也就是需要知道数组长度，而这个数组的长度正是我们字符串中数据的个数；
④ 问题就转移到了如何获取到数据的个数，不要忘了我们的字符串也是有数组的，题目给出的是字符串，接下来我们需要将字符串的数据放到字符串数组中；
⑤ 创建一个字符串数组，这里给我们提供了一个方法 split()，字符分隔符，它可以将字符串中的每一个数据通过空格分隔开，如 String[] str = s.split(" ")；
⑥ 创建一个 int 数组，用于后续排序，int 数组的长度即字符串数组的长度，通过 str.length 获取；
⑦ 现在数组的长度知道了，我们就可以利用 for 循环为数组添加数据，自然是将字符串数组的每个数据依次赋值给 int 数组，赋值过程我们可以发现这两个数组中的数据根本不是同一种数据类型，所以不可能直接赋值，这里通过上面讲到的 String 类型转换为 int 类型方法对其进行转换，然后循环赋值；
⑧ 得到数组之后，我们对该数组进行排序，Arrays.sort(arr)；
⑨ 排序之后还没结束，因为我们最终要的结果并非一个数组，它还是要输出一个字符串，且以空格分隔，采用拼接字符串的方式实现，之前我们学到过一个 StringBuilder，利用它的 append() 方法将字符串拼接成我们想要的格式，对于数组中的数据，依然采用 for 循环进行遍历，将遍历到的结果添加至字符串尾，输出结果。

//Test.java
package com.an;
import java.util.Arrays;
public class Test {
    public static void main(String[] args) {
        String s = "91 27 46 38 50";
        String[] str = s.split(" ");
        int[] arr = new int[str.length];
        for (int i = 0; i < arr.length; i++) {
            int k = Integer.parseInt(str[i]);
            arr[i] = k;
        }
        Arrays.sort(arr);
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < arr.length; i++) {
            if (i == args.length - 1) {
                sb.append(arr[i]);
            } else {
                sb.append(arr[i]).append(" ");
            }
        }
        String result = sb.toString();
        System.out.println(result);
    }
}

4. 自动装箱和拆箱

装箱：把基本数据类型转换为对应的包装类类型。
拆箱：把包装类类型转换为对应的基本数据类型。

//普通装箱
Integer i = Integer.valueOf(100);
//自动装箱
Integer ii = 100;
//普通拆箱
ii = ii.intValue() + 200;
//自动拆箱
ii += 200;
//一般我们都会先判断一下它是否为空，再进行下一步操作
Integer k = null;
if (k != null) {
   k += 300;
}

六、日期类

1. Date

Date 代表了一个特定的时间，精确到毫秒。

好多包下都有 Date 类，我们用 util 包下的 Date。

//得到当前日期信息
Date d = new Date();
System.out.println(d);

Date 类常用方法：

//Test.java
package com.an;
import java.util.Date;
public class Test {
    public static void main(String[] args) {
        Date d = new Date();
        long time = 10000*60*60;
        System.out.println(d.getTime());
        d.setTime(time);
        System.out.println(d);
    }
}

直接输出 d 得到的是当前时间，设置了 time 之后得到的 d 是 1970 年又过了 time 毫秒后的时间！

2. SimpleDateFormat

SimpleDateFormat 是一个具体的类，用于以区域设置敏感的方式格式化和解析日期，它允许格式化，解析和规范化。
日期和时间格式由日期和时间模式字符串指定，在日期和时间模式字符串中，从 ‘A’ 到 ‘Z’ 以及从 ‘a’ 到 ‘z’ 引号的字母被解释为表示日期或时间字符串的组件的模式字母。

常用的模式字母及对应关系如下：

SimpleDateFormat 的构造方法如下：

① 格式化（从 Date 到 String）
format(Date date)：将日期格式化成日期 / 时间字符串。

② 解析（从 String 到 Date）
parse(String source)：从给定字符串的开始解析文本以生成日期。

//格式化
package com.zxe;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Test {
    public static void main(String[] args) {
        Date d = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        String s = sdf.format(d);
        System.out.println(s);
    }
}

//解析
package com.zxe;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Test {
    public static void main(String[] args) throws ParseException {
        String s = "2033-2-14 20:10:13";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date d = sdf.parse(s);
        System.out.println(d);
    }
}

3. Calendar

Calendar 为某一时刻和一组日历字段之间的转换提供了一些方法，并为操作日历字段提供了一些方法。
Calendar 提供了一个类方法 getInstance 用于获取 Calendar 对象，其日历字段已使用当前日期和时间初始化.

//获取对象
Calendar c = Calendar.getInstance();
int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH) + 1;
int date = c.get(Calendar.DATE);
System.out.println(year + "年" + month + "月" + date + "日");

Calendar 的常用方法：

//年份减3，三年前的今天
Calendar c = Calendar.getInstance();
c.add(Calendar.YEAR, -3);
int year = c.get(Calendar.YEAR);
System.out.println(year);
//设置年月日
Calendar cc = Calendar.getInstance();
cc.set(2024, 2, 28);
int year = cc.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH) + 1;
int date = c.get(Calendar.DATE);
System.out.println(year + "年" + month + "月" + date + "日");

4. 二月天

需求：获取任意一年的二月有多少天。

思路：
① 键盘录入任意年份；
② 设置日历对象的年月日，年来自于键盘录入，这里的月份是从 0 开始的，所以设置为 2，日设置为 1 日；
③ 3 月 1 日往前推一天，就是 2 月的最后一天；
④ 获取到这一天，然后输出即可。

//Test.java
package com.zxe;
import java.util.Calendar;
import java.util.Scanner;
public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int year = sc.nextInt();
        Calendar c = Calendar.getInstance();
        c.set(year, 2, 1);
        c.add(Calendar.DATE, -1);
        int date = c.get(Calendar.DATE);
        System.out.println(year + "年的2月份有" + date + "天！");
    }
}