详讲Java开发中的六个常用API（Math，System，Object，Integer，Date）

个人名片：

🐼作者简介：一名大一在校生 🐻‍❄️个人主页：​​小新爱学习.​​
🕊️系列专栏：零基础学java ----- 重识c语言
🐓每日一句：宇宙山河浪漫，生活点滴温暖，都值得我前进。

文章目录

• ​​常用API​​

• ​​Math​​

• ​​1.1 Math概述​​
• ​​1.2Math的常用方法​​

• ​​2.1 System类​​

• ​​2.2 System常用方法​​

• ​​3.1 Object类的概述​​
• ​​Arrays​​

• ​​4.1 冒泡排序​​
• ​​4.2 Arrays类的概述和常用方法​​

• ​​5.基本类型包装类​​

• ​​5.1基本数据类型包装类概述​​
• ​​5.2 Integer 类的概述和使用​​
• ​​5.3 int和 String 的相互转化​​
• ​​5.4自动装箱和拆箱​​

• ​​6.日期类​​

• ​​6.1Date类概述和构造方法​​
• ​​6.2 Date 类的常用方法​​
• ​​6.3 SimplDateFormat 类概述​​

• ​​Calendar类概述​​

• ​​6.7 Calendar的常用方法​​

常用API

Math

1.1 Math概述

public final class Math

extends Object

Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。

没有构造方法，

使用： 看类的成员是否都是静态，即static修饰，如果是，直接类名调方法

1.2Math的常用方法

public class MathDemo {
    public static void main(String[] args) {
        //    public static int abs(int a) 返回参数的绝对值
        System.out.println(Math.abs(-52));
        System.out.println(Math.abs(22));
//    public static double ceil(double a) 返回大于或等于参数的最小double值，等于一个整数
        System.out.println(Math.ceil(12.24));
        System.out.println(Math.ceil(-12.33));
//    public static double floor(double a 返回小于或等于参数的最大double值，等于一个整数
        System.out.println(Math.floor(11.25));
        System.out.println(Math.floor(11.99));
//            public static int round(float a) 按照四舍五入返回最接近参数的int
        System.out.println(Math.round(30.65F));
        System.out.println(Math.round(29.49F));
//    public static int max(int a,int b) 返回两个int值中的较大值
        System.out.println(Math.max(111,999));
//    public static int min(int a,int b) 返回两个int值中的较小值
        System.out.println(Math.min(111,999));
//    public static double pow(double a,double b)返回a的b次幂的值
        System.out.println(Math.pow(2,2));
//    public static double random() 返回值为double的正值，[0.0,1.0)
        System.out.println(Math.random());

    }

}

2.1 System类

public final class

Systemextends Object

System 类包含一些有用的类字段和方法。它不能被实例化。被static稀释，直接类名调对象

在 System 类提供的设施中，有标准输入、标准输出和错误输出流；对外部定义的属性和环境变量的访问；加载文件和库的方法；还有快速复制数组的一部分的实用方法。

2.2 System常用方法

/*
system 常用方法
 */
public class SystemDemo {
    public static void main(String[] args) {
        //System.out.println("开始");
        //public static void exit(int status),终止当前运行的java虚拟机，非零表示异常终止
        //System.exit(0);

        //System.out.println("结束");
        //public static void currenTimeMillis(),返回当前时间，以毫秒为单位
        System.out.println(System.currentTimeMillis() / 1000 / 60 / 60 / 24 / 365);

        //计算
        long start = System.currentTimeMillis();
        for (int i = 0; i<1000000; i++){
            System.out.println(i);
        }
        long end = System.currentTimeMillis();
        System.out.println((double)(end - start)/1000);

    }
}

3.1 Object类的概述

public class Object类

Object 是类层次结构的根类。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。

equals方法

public boolean equals(Object obj)指示其他某个对象是否与此对象“相等”。

equals 方法在非空对象引用上实现相等关系：

自反性：对于任何非空引用值 x，x.equals(x) 都应返回 true。
对称性：对于任何非空引用值 x 和 y，当且仅当 y.equals(x) 返回 true 时，x.equals(y) 才应返回 true。
传递性：对于任何非空引用值 x、y 和 z，如果 x.equals(y) 返回 true，并且 y.equals(z) 返回 true，那么 x.equals(z) 应返回 true。
一致性：对于任何非空引用值 x 和 y，多次调用 x.equals(y) 始终返回 true 或始终返回 false，前提是对象上 equals 比较中所用的信息没有被修改。
对于任何非空引用值 x，x.equals(null) 都应返回 false。
Object 类的 equals 方法实现对象上差别可能性最大的相等关系；即，对于任何非空引用值 x 和 y，当且仅当 x 和 y 引用同一个对象时，此方法才返回 true（x == y 具有值 true）。
学生类：

public class Student {
    private String name;
    private int age;

    public Student(){

    }
    public Student(String name, int 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;
    }

    @Override
    public boolean equals(Object o) {
        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;
    }


}

测试类：

public class ObjectDemo {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("hmm");
        s1.setAge(19);

        Student s2 = new Student();
        s2.setName("hmm");
        s2.setAge(19);

        System.out.println(s1.equals(s2));//未重写equals方法，比较的是地址

    }
}

注意：当此方法被重写时，通常有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定，该协定声明相等对象必须具有相等的哈希码。

参数：
obj - 要与之比较的引用对象。
返回：
如果此对象与 obj 参数相同，则返回 true；否则返回 false。
另请参见：
hashCode(), Hashtable

toString方法
public String toString()返回该对象的字符串表示。通常，toString 方法会返回一个“以文本方式表示”此对象的字符串。结果应是一个简明但易于读懂的信息表达式。建议所有子类都重写此方法。
Object 类的 toString 方法返回一个字符串，该字符串由类名（对象是该类的一个实例）、at 标记符“@”和此对象哈希码的无符号十六进制表示组成。换句话说，该方法返回一个字符串，它的值等于：

getClass().getName() + ‘@’ + Integer.toHexString(hashCode())

返回：
该对象的字符串表示形式。

学生类：

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;
    }

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

测试类：

public class ObjectDemo {
    public static void main(String[] args) {
        Student s  =new Student();
        s.setName("hmm");
        s.setAge(10);
        System.out.println(s);
        System.out.println(s.toString());
    }
}

Arrays

4.1 冒泡排序

排序：将一组数据按照固定规则进行排列

冒泡排序： 一种排序的方法，对于进行的数据排序中相邻的数据进行两两比较，将较大的数据放在后面，依次对所有数据进行操作，直至所有数据按要求完成排序
1. 算法步骤
比较相邻的元素。如果第一个比第二个大，就交换他们两个。

对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

针对所有的元素重复以上的步骤，除了最后一个。

持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

图示：

public class BubbleSort implements IArraySort {

    @Override
    public int[] sort(int[] sourceArray) throws Exception {
        // 对 arr 进行拷贝，不改变参数内容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        for (int i = 1; i < arr.length; i++) {
            // 设定一个标记，若为true，则表示此次循环没有进行交换，也就是待排序列已经有序，排序已经完成。
            boolean flag = true;

            for (int j = 0; j < arr.length - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int tmp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tmp;

                    flag = false;
                }
            }

            if (flag) {
                break;
            }
        }
        return arr;
    }
}

注：

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

4.2 Arrays类的概述和常用方法

public class Arrays

extends Object

此类包含用来操作数组（比如排序和搜索）的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。

除非特别注明，否则如果指定数组引用为 null，则此类中的方法都会抛出 NullPointerException。

此类中所含方法的文档都包括对实现 的简短描述。应该将这些描述视为实现注意事项，而不应将它们视为规范 的一部分。实现者应该可以随意替代其他算法，只要遵循规范本身即可。（例如，sort(Object[]) 使用的算法不必是一个合并排序算法，但它必须是稳定的。）

此类是 Java Collections Framework 的成员。

toString 方法

sort方法

import java.util.Arrays;

public class ArraysDemo {
    public static void main(String[] args) {
        int arr[] = {10,52,555,74,2,6,5};
        System.out.println("排序前"+Arrays.toString(arr));
        Arrays.sort(arr);

        System.out.println("排序后"+Arrays.toString(arr));
    }
}

注：工具类的设计思想

• 构造方法用private修饰
• 成员用public static 修饰

5.基本类型包装类

5.1基本数据类型包装类概述

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

基本数据类型和包装类的区别

区别：

1. 包装类是对象，拥有方法和字段，对象的调用都是通过引用对象的地址，基本数据类型不是
2. 包装类型是引用的传递，基本类型是值的传递
3. 声明方式不同、基本数据类型不需要new关键字，而包装类型需要new在堆内存中进行new来分配内存空间
4. 存储位置不同，基本数据类型直接将值保存在值栈中，而包装类型是把对象放在堆中，然后通过对象的引用来调用它们
5. 初始值不同，eg:int的初始值为0、boolean的初始值为fales ，而包装类型的初始值为null
6. 使用方法不同，基本数据类型直接赋值使用就好，而包装类型是在集合如collction Map时会使用

5.2 Integer 类的概述和使用

构造方法

Integer ：类在对象中包装了一个基本类型 int 的值。Integer 类型的对象包含一个 int 类型的字段。

此外，该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法。

public class IntegerDemo {
    public static void main(String[] args) {
        //构造方法摘要
//Integer(int value)
//          构造一个新分配的 Integer 对象，它表示指定的 int 值。
//Integer(String s)
//          构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。
//
        Integer i = new Integer(100);
        System.out.println(i);

        Integer i1 = new Integer("1000");//由数字组成的字符串
        System.out.println(i1);

        //static Integer valueOf(int i)
        //          返回一个表示指定的 int 值的 Integer 实例。
        //static Integer valueOf(String s)
        //          返回保存指定的 String 的值的 Integer 对象。
        Integer i2 = Integer.valueOf(10);
        System.out.println(i2);

        Integer i3 = Integer.valueOf("10000");
        System.out.println(i3);

    }
}

5.3 int和 String 的相互转化

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

public class ZhuanHuan {
    public static void main(String[] args) {
        //int--->String
        // 方法一
        int number = 100;
        String i = "" + number;
        System.out.println(i);
        //方法二
        //static String valueOf(int i)
        //          返回 int 参数的字符串表示形式。
        String i1 = String.valueOf(number);
        System.out.println(i1);

        System.out.println("-----------------");

        //String --> Integer -- > int
        String s1 = "100";
        //String --->Integer
        Integer i2 = Integer.valueOf(s1);
        // int intValue()
        //          以 int 类型返回该 Integer 的值。
        int x = i2.intValue();
        System.out.println(x);
        //f方法二
        //static int parseInt(String s) 
        //          将字符串参数作为有符号的十进制整数进行解析。 
        int y = Integer.parseInt(s1);
        System.out.println(y);

    }
}

5.4自动装箱和拆箱

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

// - 装箱：把基本数据类型转换为对应包装类类型
// - 拆箱：把包装类型转换为对应的基本数据类型
public class BaoChai {
    public static void main(String[] args) {
        // - 装箱：把基本数据类型转换为对应包装类类型
        Integer i = Integer.valueOf(100);
        Integer ii =100;//自动装箱Integer.valueOf(100);
        //- 拆箱：把包装类型转换为对应的基本数据类型
       /* ii = ii.intValue()+200;
        System.out.println(ii);*/
        ii+=200;//内部隐含ii.intValue()
        System.out.println(ii);


        Integer iii = null;
        if(iii!=null){
            iii+=300;//NullPointerException//内部隐含ii.intValue(),所以null掉对象，会触发空指针异常
        }
    }
}

注意： 在使用包装类类型的时候，若果做操作，最好先判断是否为null
我们推荐的是：只要是对象，在使用之前就必须进行不为null判断

6.日期类

6.1Date类概述和构造方法

import java.util.Date;

//Date()
//          分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒）。
//Date(long date)
//          分配 Date 对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。
public class DateDemo01 {
    public static void main(String[] args) {
        //public Date()
        Date date = new Date();
        System.out.println(date);

        Date date1 = new Date(1000*60*60*24);//中国在东八区+8hour
        System.out.println(date1);
    }
}

6.2 Date 类的常用方法

import java.util.Date;

/*
public long getTime()返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
返回：
自 1970 年 1 月 1 日 00:00:00 GMT 以来此日期表示的毫秒数。
setTime
public void setTime(long time)设置此 Date 对象，以表示 1970 年 1 月 1 日 00:00:00 GMT 以后 time 毫秒的时间点。
参数：
time - 毫秒数。

 */
public class DateDemo02 {
    public static void main(String[] args) {
        Date date = new Date();
        long time = date.getTime();
        System.out.println(time / 365 / 24 / 60 / 60 / 1000);
        //public void setTime(long time)设置此 Date 对象，以表示 1970 年 1 月 1 日 00:00:00 GMT 以后 time 毫秒的时间点。
        Date date1 = new Date();
        long time1  = 1000*60*60;
        date1.setTime(time1);
        System.out.println(date1);
    }
}

6.3 SimplDateFormat 类概述

public class SimpleDateFormatextends DateFormatSimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类。它允许进行格式化（日期 -> 文本）、解析（文本 -> 日期）和规范化。
SimpleDateFormat 使得可以选择任何用户定义的日期-时间格式的模式。但是，仍然建议通过 DateFormat 中的 getTimeInstance、getDateInstance 或 getDateTimeInstance 来创建日期-时间格式器。每一个这样的类方法都能够返回一个以默认格式模式初始化的日期/时间格式器。可以根据需要使用 applyPattern 方法来修改格式模式。有关使用这些方法的更多信息，请参阅 DateFormat。
日期和时间模式
日期和时间格式由日期和时间模式 字符串指定。在日期和时间模式字符串中，未加引号的字母 ‘A’ 到 ‘Z’ 和 ‘a’ 到 ‘z’ 被解释为模式字母，用来表示日期或时间字符串元素。文本可以使用单引号 (’) 引起来，以免进行解释。"’’" 表示单引号。所有其他字符均不解释；只是在格式化时将它们简单复制到输出字符串，或者在解析时与输入字符串进行匹配。

定义了以下模式字母（所有其他字符 ‘A’ 到 ‘Z’ 和 ‘a’ 到 ‘z’ 都被保留）：

SimplDateFormat 构造方法

构造方法摘要

SimpleDateFormat()
用默认的模式和默认语言环境的日期格式符号构造 SimpleDateFormat。
SimpleDateFormat(String pattern)
用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat。
SimpleDateFormat(String pattern, DateFormatSymbols formatSymbols)
用给定的模式和日期符号构造 SimpleDateFormat。
SimpleDateFormat(String pattern, Locale locale)
用给定的模式和给定语言环境的默认日期格式符号构造 SimpleDateFormat。

Calendar类概述

Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。瞬间可用毫秒值来表示，它是距历元（即格林威治标准时间 1970 年 1 月 1 日的 00:00:00.000，格里高利历）的偏移量。
该类还为实现包范围外的具体日历系统提供了其他字段和方法。这些字段和方法被定义为 protected。
与其他语言环境敏感类一样，Calendar 提供了一个类方法 getInstance，以获得此类型的一个通用的对象。Calendar 的 getInstance 方法返回一个 Calendar 对象，其日历字段已由当前日期和时间初始化

Calendar rightNow = Calendar.getInstance();

Calendar 对象能够生成为特定语言和日历风格实现日期-时间格式化所需的所有日历字段值**

import java.util.Calendar;

public class CalendarDemo {
    public static void main(String[] args) {
        //获取对象
     Calendar c =   Calendar.getInstance();//多态创建对象
//        System.out.println(c);//[time=1655449283220,
        //public int get (int filed)
        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+"日");
    }
}

6.7 Calendar的常用方法

int get(int field)
返回给定日历字段的值。

abstract void add(int field, int amount)
根据日历的规则，为给定的日历字段添加或减去指定的时间量。

void set(int year, int month, int date)
设置日历字段 YEAR、MONTH 和 DAY_OF_MONTH 的值。

import java.util.Calendar;

public class CalendarDemo {
    public static void main(String[] args) {
        //获取对象
     Calendar c =   Calendar.getInstance();//多态创建对象
//        System.out.println(c);//[time=1655449283220,
        //public int get (int filed)


        //输出十五年后的，三个月后的，十天前
        c.add(Calendar.YEAR,15);
        c.add(Calendar.MONTH,3);
        c.add(Calendar.DATE,-10);
        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+"日");

    }
}