Java—常用API之Math、System、Object、Arrays、基本类型包装类、Date、Calendar

一、Math类

示例

public class APIDemo {
    public static void main(String[] args) {
        //返回参数的绝对值
        System.out.println("public static int abs(int a)：返回参数的绝对值");
        System.out.println(Math.abs(-99));
        System.out.println(Math.abs(99));
        System.out.println("-----------");

        //返回大于或等于参数的最小double值
        System.out.println("public static double ceil(double a)：返回大于或等于参数的最小double值,等于一个整数");
        System.out.println(Math.ceil(23.2));
        System.out.println(Math.ceil(-23.2));
        System.out.println("-----------");

        //返回小于或等于参数的最大double值
        System.out.println("public static double floor(double a)：返回小于或等于参数的最大double值,等于一个整数");
        System.out.println(Math.floor(23.2));
        System.out.println(Math.floor(-23.2));
        System.out.println("-----------");

        //按四舍五入返回最接近参数的int
        System.out.println("public static int round(float a)：按四舍五入返回最接近参数的int");
        System.out.println(Math.round(23.2));
        System.out.println(Math.round(23.9));
        System.out.println("-----------");

        //返回两个int中的较大值
        System.out.println("public static int max(int a, int b)：返回两个int中的较大值");
        System.out.println(Math.max(2, 5));
        System.out.println("-----------");

        //返回两个int中的较小值
        System.out.println("public static int min(int a, int b)：返回两个int中的较小值");
        System.out.println(Math.min(2, 5));
        System.out.println("-----------");

        //返回a的b次幂的值
        System.out.println("public static double pow(double a ,double b)：返回a的b次幂的值");
        System.out.println(Math.pow(2, 3));
        System.out.println("-----------");

        //生成随机数，返回值为double的正值，[0.0,1.0)
        System.out.println("public static double random():生成随机数，返回值为double的正值，[0.0,1.0)");
        //生成[0.0,1.0)范围内的随机数，返回值是double
        System.out.println(Math.random());
        //生成[0.0,100.0)之间的随机数，返回值是double
        System.out.println(Math.random() * 100);
        //生成[0.0,100.0)之间的随机数，返回值是int
        System.out.println((int) (Math.random() * 100));
        //生成[1.0,100.0]之间的随机数，返回值是int
        System.out.println((int) (Math.random() * 100 + 1));
    }
}

运行结果

二、System类

• public static void exit(int status)：中止当前运行的Java虚拟机，非零表示异常终止

public class exitDemo {
    public static void main(String[] args) {
        System.out.println("开始");
        System.exit(0);
        System.out.println("结束");
    }
}

• public static long currentTimeMillis()：返回当前时间（以毫秒为单位），返回的是距离1970年1月1日的时间

public class CurrentTimeMillisDemo {
    public static void main(String[] args) {
        //返回当前时间
        System.out.println(System.currentTimeMillis());
        //返回当前时间距离1970年1月1日的年数
        System.out.println(System.currentTimeMillis() * 1.0 / 1000 / 60 / 60 / 24 / 365 + "年");
        //返回下列代码运行的时间
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10; i++) {
            System.out.println(i);
        }
        long end = System.currentTimeMillis();
        System.out.println("程序运行耗时：" + (end - start) + "毫秒");
    }
}

三、Object类

Object是类层次结构的根，每个类都可以将Object作为超类，所有类都直接或间接的继承自该类。

Object类有构造方法：public Object()。因为顶级父类只有无参构造方法，所以说子类的构造方法默认访问的是父类的无参构造方法。

• 建议子类重写toString方法

没有重写toString方法的示例如下：

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 StudentDemo {
    public static void main(String[] args) {
        Student s = new Student();
        s.setName("zlx");
        s.setAge(18);
        System.out.println(s);
    }
}

上述示例，在为名字和年龄赋值后，直接输出Student的对象时，无法显示设置好的内容。因此，需要子类重写Object类的toString方法，如下：

@Override
public String toString() {
    return "Student{" +
            "name='" + name + '\'' +
            ", age=" + age +
            '}';
}

因此，通常情况下，子类需要重写toString方法，这样可以通过输出类对象的方法输出内容。

重写toString方法的快捷方式，Alt + Insert，选择toString()可以自动生成。

• equals()方法默认比较的是地址是否相同，建议子类重写equals()，以此判断类的两个对象内容是否相同

@Override
public boolean equals(Object o) {
	//判断地址是否相同，如果相同直接返回true
     if (this == o) return true;

	//判断参数是否为空
	//判断两个对象是否来自于同一个类
     if (o == null || getClass() != o.getClass()) return false;

	//向下转型
     Student student = (Student) o;

	//比较年龄是否相同
     if (age != student.age) return false;

	//比较姓名内容是否相同
     return name != null ? name.equals(student.name) : student.name == null;
 }

此时，可以使用s.equals(s2)判断两个对象的内容是否相同。equals()函数可以自动生成，步骤是Alt + Insert，选择equals() and hashCode()可以自动生成。

四、Arrays

Arrays类包含用于操作数组的各种方法

• public static String toString(int[] a)：返回指定数组的内容的字符串表示形式
• public static void sort(int[] a)：按照数字顺序排列指定的数组

public class Demo {
    public static void main(String[] args) {
        int[] a = {25, 37, 15, 26};
        System.out.println("排序前：" + Arrays.toString(a));
        Arrays.sort(a);
        System.out.println("排序后：" + Arrays.toString(a));
    }
}

注：工具类的设计思想：①构造方法用private修饰，②成员用public static修饰

五、基本类型包装类

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据

基本数据类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

基本类型包装类最常见操作就是用于基本类型和字符串之间的相互转换。

• int类型转换为String类型

有下列两种方式：

public class Demo1 {
    public static void main(String[] args) {
        int a = 100;
        //方式1
        String s = "" + a;
        System.out.println(s);

        //方式2
        //public static String valueOf(int i)
        String s2 = String.valueOf(a);
        System.out.println(s2);
    }
}

• String类型转换为int类型

有下列两种方式：

public class StringToInt {
    public static void main(String[] args) {
        String s = "100";
        //方式1 String->Integer->int
        Integer i = Integer.valueOf(s);
        //public int intValue()
        int x = i.intValue();
        System.out.println(x);

        //方式2
        //public static int parseInt(String s)
        int y = Integer.parseInt(s);
        System.out.println(y);
    }
}

• 自动装箱和拆箱

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

在使用包装类类型时，如果做操作，最好先判断是否为null，否则会报NullPointerException的错误。

public class Demo4 {
    public static void main(String[] args) {
        //装箱
        Integer i = Integer.valueOf(100);
        //自动装箱,实际上也做了valueOf(100)的操作
        Integer i1 = 100;

        //拆箱
        i1 = i1.intValue() + 200;
        //自动拆箱
        i1 += 200;

        //NullPointerException
        Integer i3 = null;
        if (i3 != null) {
            i3 += 300;
        }
    }
}

六、Date类

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

1、构造方法

• public Date()：分配一个Date对象，并初始化，以便代表它被分配的时间，精确到毫秒。

• public Date(long date)：分配一个Date对象，并将其初始化为表示从标准基准时间起指定的毫秒数。

public class Demo {
    public static void main(String[] args) {
        //无参构造方法
        Date d1 = new Date();
        System.out.println(d1);

        //有参构造方法
        Date d2 = new Date(1000 * 60 * 60);
        System.out.println(d2);
    }
}

2、Date类的常用方法

• public long getTime()：获取的是日期对象从1970年1月1日00：00：00到现在的毫秒值
• public void setTime(long time)：设置时间，给的是毫秒值

public class Demo2 {
    public static void main(String[] args) {
        Date d = new Date();
        //public long getTime()：获取的是日期对象从1970年1月1日00：00：00到现在的毫秒值
        System.out.println(d.getTime());
        System.out.println(d.getTime() * 1.0 / 1000 / 60 / 60 / 24 / 365 + "年");

        //public void setTime(long time)：设置时间，给的是毫秒值
        d.setTime(60 * 60 * 60);
        System.out.println(d.getTime());
        System.out.println(d);
    }
}

3、SimpleDateFormat类

• SimpleDateFormat是一个具体的类，用于以区域设置敏感的方式格式化和解析日期。
• 日期和时间格式由日期和时间模式字符串指定，在日期和时间模式字符串中，从’A’到’Z’以及从’a’到’z’引号的字母被解释为表示日期或时间字符串的组件的模式字母。常用的模式字母及对应关系如下：

模式字母	对应表示
y	年
M	月
d	日
H	时
m	分
s	秒

• 构造方法
  ①public SimpleDateFormat()：构造一个SimpleDateFormat，使用默认模式和日期格式
  ②public SimpleDateFormat(String pattern)：构造一个SimpleDateFormat，使用给定的模式和默认的日期格式
• 格式化（从Date到String)
  public final String format(Date date)：将日期格式化成日期/时间字符串
• 解析（从String到Date)
  public Date parse(String source)：从给定字符串的开始解析文本以生成日期

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Demo3 {
    public static void main(String[] args) throws ParseException {
        Date d = new Date();
        //格式化
        SimpleDateFormat sdf = new SimpleDateFormat();
        String s = sdf.format(d);
        System.out.println(s);

        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String s1 = sdf1.format(d);
        System.out.println(s1);

        //解析
        String s2 = "2022-04-17 14:23:36";
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date dd = sdf2.parse(s2);
        System.out.println(dd);
    }
}

七、Calendar类

• Calendar为某一时刻和一组日历字段之间的转换提供了一些方法，并为操作日历字段提供了一些方法
• Calendar提供了一个类方法getInstance用于获取Calendar对象，其日历字段已使用当前日期和时间初始化：
  Calendar rightNow = Calendar.getInstance();
  注意，这里的月份字段是从0开始的，使用时需要+1
• public int get(int field)：返回给定日历字段的值

import java.util.Calendar;

public class Demo {
    public static void main(String[] args) {
        //获取对象
        Calendar rightNow = Calendar.getInstance();
        System.out.println(rightNow);

        //获取具体的字段
        int year = rightNow.get(Calendar.YEAR);
        int month = rightNow.get(Calendar.MONTH) + 1;
        int date = rightNow.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");
    }
}

• public abstract void add(int filed,int amount)：根据日历的规则，将指定的时间量添加或减去给定的日历字段
• public final void set(int year,int month,int date)：设置当前日历的年月日

public class Demo {
    public static void main(String[] args) {
        //获取对象
        Calendar rightNow = Calendar.getInstance();
        System.out.println(rightNow);

        //获取具体的字段
        int year = rightNow.get(Calendar.YEAR);
        int month = rightNow.get(Calendar.MONTH) + 1;
        int date = rightNow.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");

        //3年前的今天
        rightNow.add(Calendar.YEAR, -3);
        int year1 = rightNow.get(Calendar.YEAR);
        int month1 = rightNow.get(Calendar.MONTH) + 1;
        int date1 = rightNow.get(Calendar.DATE);
        System.out.println(year1 + "年" + month1 + "月" + date1 + "日");

        //十年后的五天前(上一步的基础上进行操作)
        rightNow.add(Calendar.YEAR, 10);
        rightNow.add(Calendar.DATE, -5);
        int year2 = rightNow.get(Calendar.YEAR);
        int month2 = rightNow.get(Calendar.MONTH) + 1;
        int date2 = rightNow.get(Calendar.DATE);
        System.out.println(year2 + "年" + month2 + "月" + date2 + "日");

        //set方法
        rightNow.set(2000, 2, 4);
        int year3 = rightNow.get(Calendar.YEAR);
        int month3 = rightNow.get(Calendar.MONTH);
        int date3 = rightNow.get(Calendar.DATE);
        System.out.println(year3 + "年" + month3 + "月" + date3 + "日");
    }
}