常用API_生成一个包括年月日以及系统毫秒值字符串-CSDN博客

本文链接：https://blog.csdn.net/qq_53529114/article/details/113094893

常用API

1.Math

1.1 Math类概述

Math类包含执行基本数字运算的方法，如基本指数，对数，平方根和三角函数。

没有构造方法，如何使用类中的成员？

看类中的成员是否是静态的，如果是，则可以直接使用类名调用

1.2 Math类常用方法

方法名	说明
public static int abs(int a)	返回参数的绝对值
public static double ceil(double a)	返回大于或等于参数的最小double值，等于一个整数
public static double floor(double a)	返回小于或等于参数的最大double值，等于一个整数
public static double round(float a)	按照四舍五入返回最接近参数的int
public static int max(int a,int b)	返回两个int值中较大值
public static int min(int a,int b)	返回两个int值中较小值
public static double pow(double a,double b)	返回a的b次幂的值
public static double random()	返回值为double的正值，[0.0,1.0)

package com.advanced.math;

//Math常用方法
public class Demo01 {
    public static void main(String[] args) {
        //public static int abs(int a)  返回参数的绝对值
        System.out.println(Math.abs(20));//20
        System.out.println(Math.abs(-13));//13

        //public static double ceil(double a) | 返回大于或等于参数的最小double值，等于一个整数
        System.out.println(Math.ceil(12.56));//13.0
        System.out.println(Math.ceil(11.24));//12.0

        //public static double floor(double a) | 返回小于或等于参数的最大double值，等于一个整数
        System.out.println(Math.floor(45.23f));//45.0
        System.out.println(Math.floor(23.78f));//23.0

        //public static double round(float a) | 按照四舍五入返回最接近参数的int
        System.out.println(Math.round(10.123f));//10

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

        //public static int min(int a,int b) | 返回两个int值中较小值
        System.out.println(Math.min(4,6));//4

        //public static double pow(double a,double b) | 返回a的b次幂的值
        System.out.println(Math.pow(2.0,3.0));//8.0

        //public static double random() | 返回值为double的正值，[0.0,1.0)
        System.out.println(Math.random());
        System.out.println((int)(Math.random()*100)+1);
    }
}

2.System

2.1 System类概述

System类包含几个有用的类字段和方法。它不能被实例化。

2.2 System常用方法

方法名	说明
public static void exit(int status)	终止当前运行的Java虚拟机，非零表示异常终止
public static long currentTimeMillis()	返回当前时间（以毫秒为单位）

package com.advanced.apimethods;

//System常用方法
public class SystemDemo {
    public static void main(String[] args) {
        //public static void exit(int status) | 终止当前运行的Java虚拟机，非零表示异常终止
        System.out.println("开始");
        //System.exit(0);  //在此之后代码不会运行
        System.out.println("结束");

        //public static long currentTimeMillis() | 返回当前时间（以毫秒为单位）
        System.out.println(System.currentTimeMillis()*1.0/1000/60/60/24/365+"年");
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            System.out.println(i);
        }
        long end = System.currentTimeMillis();
        System.out.println("耗时："+ (end-start) +"毫秒");
    }
}

3.Object

3.1 Object类概述

Class Object是类层次结构的根。每个类都有Object作为超类。所有对象（包括数组）都实现了这个类的方法，即所有类都直接或间接继承自该类。

构造方法：public Object()

回到面向对象中，为什么说子类的构造方法默认访问的是父类的无参构造方法？

因为它们的顶级父类只有无参构造方法

3.2 Object类常用方法

方法名	说明
public String toString()	返回对象字符串表示形式。建议所有子类重写该方法，自动生成即可
public boolean equals(Object obj)	比较对象是否相等。默认比较地址，重写可比较内容，自动生成即可

package com.advanced.apimethods;

import java.util.Objects;

//Object类是类层次结构的根，每个类都可以将Object类作为超类，所有类都直接或间接继承Object类
//查看方法：选中方法，ctrl+B 或 选中方法，CTRL+鼠标左键双击
//建议所有子类重写此方法。自动生成即可
public class ObjectDemo {
    public static void main(String[] args) {
        Student student = new Student();
        student.setAge(20);
        student.setName("陈大锤");
        System.out.println(student);//Student{age=20, name='陈大锤'}

        Student student2 = new Student();
        student2.setAge(20);
        student2.setName("陈大锤");
        System.out.println(student==student2);//比较两个对象地址值，不是比较内容
        System.out.println(student.equals(student2));//false，重写equals方法后为true
        /*
        public boolean equals(Object obj) {
            return (this == obj);
            //this = student
            //obj = student2
            //实际仍然比较的地址值，需要重写equals方法
        }
        */
    }
}

class Student{
    int age;
    String name;

    public Student() {
    }

    public Student(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

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

    @Override
    public boolean equals(Object o) {
        //this = student
        //o = student2
        //比较地址是否相同，如果相同返回true
        if (this == o) return true;

        //判断参数是否为null
        //判断两个对象是否来自同一个类
        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;
    }
}

4.Arrays

4.1 Arrays类概述

该类包含用于操作数组的各种方法（如排序和搜索）。该类还包含一个静态工厂，可以将数组视为列表。

4.2 Arrays类常用方法

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

工具类设计思想：

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

package com.advanced.apimethods;

import java.util.Arrays;

//Arrays类常用方法
public class ArraysDemo {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {12,23,75,10,56};

        System.out.println("排序前："+ Arrays.toString(arr));//排序前：[12, 23, 75, 10, 56]

        //对数组进行排序
        Arrays.sort(arr);

        System.out.println("排序后："+ Arrays.toString(arr));//排序后：[10, 12, 23, 56, 75]

    }
}

5.基本类型包装类

5.1 概述

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

常用的操作之一：用于基本数据类型于字符串之间的转换

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

5.2 Integer类

Integer：包装一个对象中的原始类型int的值。类型为Integer的对象包含一个单一字段，其类型为int 。

方法名	说明
public Integer(int value)	根据int值创建Integer对象，已过时
public Integer(String s)	根据String值创建Integer对象，已过时
public static Integer valueOf(int i)	返回表示指定的int值得Integer实例
public static Integer valueOf(String s)	返回一个保存指定值得Integer对象String

package com.advanced.apimethods;

/*
    构造方法：
        public Integer(int value) 根据int值创建Integer对象（过时）
        public Integer(String s) 根据String值创建Integer对象（过时）
    静态方法获取对象：
        public static Integer valueOf(int i) 返回指定int值的Integer实例
        public static Integer valueOf(String s) 返回一个保存指定值的Integer对象String
*/
public class IntegerDemo {
    public static void main(String[] args) {
        //Integer(int value)
        Integer integer1 = new Integer(100);
        System.out.println(integer1);//100

        //Integer(String s)
        Integer integer2 = new Integer("123");
        //Integer integer2 = new Integer("abc");//NumberFormatException
        System.out.println(integer2);//123

        //valueOf(int i)
        Integer i1 = Integer.valueOf(12);
        System.out.println(i1);//12

        //valueOf(String s)
        Integer i2 = Integer.valueOf("123");
        System.out.println(i2);//123

    }
}

5.3 int和String转换

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

int转换为String

public static String valueOf(int i)：返回int参数的字符串表示形式。该方法是String类中的方法

String转换为int

public static int parseInt(String s)：将字符串解析为int类型。该方法是Integer类中的方法

package com.advanced.apimethods;

//int与String相互转换
public class IntAndString {
    public static void main(String[] args) {
        //int转为String
        int num = 100;
        //方式一
        String s = "" +num;
        System.out.println(s);//100

        //方式二
        s = String.valueOf(num);
        System.out.println(s);//100

        //String转为int
        String s1 = "123";
        //方式1
        //String - Integer - int
        Integer i1 = Integer.valueOf(s1);
        System.out.println(i1.intValue());//123

        //方式2
        int x = Integer.parseInt(s1);
        System.out.println(x);//123
    }
}

5.4 案例

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

package com.advanced.apimethods;

import java.util.Arrays;

public class ExampleTest01 {
    public static void main(String[] args) {
        //定义字符串
        String s = "91 27 46 38 50";
        //取字符串中数字
        String[] split = s.split(" ");

//        for (String s1 : split) {
//            System.out.println(s1);
//        }
        //创建一个int[]存放数据
        int[] arr = new int[split.length];
        //将String[] split中元素赋值给int[] arr元素
        for (int i = 0; i < arr.length; i++) {
            arr[i] = Integer.parseInt(split[i]);
        }
//        for (int i : arr) {
//            System.out.println(i);
//        }
        //排序
        Arrays.sort(arr);

        //打印,将数组元素拼接成字符串，需要使用StrigBuilder来实现
        StringBuilder builder = new StringBuilder();
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length-1){
                builder.append(arr[i]);
            }else{
                builder.append(arr[i]).append(" ");
            }
        }
        String result = builder.toString();
        System.out.println("结果："+result);//结果：27 38 46 50 91
    }
}

5.5 自动装箱和拆箱

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

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

package com.advanced.apimethods;

//装箱与拆箱
public class InAndOutBox {
    public static void main(String[] args) {
        //装箱：把基本数据类型转换为对应的包装类类型
        Integer integer = Integer.valueOf(100);//手动装箱
        Integer i1 = 100;//自动装箱

        //拆箱：把包装类类型转换为对应的基本数据类型
        i1 = i1.intValue() + 100;//手动拆箱，然后再自动装箱
        i1 += 100;//自动拆箱，再自动装箱
        System.out.println(i1);

        //引用类型最好先判断是否为null再使用
        Integer i2 = null;
        if (i2 != null) {
            i2 += 100;//NullPointerException
        }
        System.out.println(i2);
    }
}

6.日期类

6.1 概述

Date代表了一个特定的时间，以毫秒为单位

6.2 构造方法

方法名	说明
public Date()	分配一个Date对象，并初始化，以便它代表它被分配的时间，精确到毫秒
public Date(long date)	分配一个Date对象，并将其初始化为表示从标准基准时间起指定的毫秒数

package com.advanced.apimethods;

import java.util.Date;

//Date类构造方法
public class DateDemo01 {
    public static void main(String[] args) {
        //public Date():分配一个Date对象，并初始化，以便它代表它被分配的时间，精确到毫秒
        Date date1 = new Date();
        System.out.println(date1);//Sun Jan 24 12:24:48 CST 2021

        //public Date(long date)：分配一个Date对象，并将其初始化为表示从标准基准时间起指定的毫秒数
        Date date2 = new Date(1000*60*60*24);
        System.out.println(date2);//Fri Jan 02 08:00:00 CST 1970
    }
}

6.3 常用方法

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

package com.advanced.apimethods;

import java.util.Date;

//Date常用方法
public class DateDemo02 {
    public static void main(String[] args) {
        //创建日期对象
        Date date1 = new Date();

        //public long getTime() 获取的是日期对象从1970年1月1日00：00：00到现在的毫秒值
        long time1 = date1.getTime();
        System.out.println(time1+"ms");//1611463625105ms
        System.out.println(time1*1.0/1000/60/60/24/365+"年");

        //public void setTime(long time) 设置时间，给的是毫秒值
        date1.setTime(1000*60*60*24);
        System.out.println(date1);//Fri Jan 02 08:00:00 CST 1970
        long time2 = System.currentTimeMillis();
        date1.setTime(time2);
        System.out.println(date1);//Sun Jan 24 12:56:25 CST 2021
    }
}

6.4 SimpleDateFormat类

SimpleDateFormat是一个具体类，用于以区域设置敏感的方式格式化和解析日期。我们重点学习格式化和解析日期

日期和时间格式由日期和时间模式字符串指定，在日期和时间模式字符串中，从‘A’到‘Z’以及从‘a’到‘z’引号的字母被解释为表示日期或时间字符串shi的组件的模式字母

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

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)：从给定的字符串开始解析文本以生成日期

package com.advanced.apimethods;

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

//SimpleDateFormat类
public class SimpleDateFormatDemo01 {
    public static void main(String[] args) throws ParseException {
        //public SimpleDateFormat() 构造一个SimpleDateFormat，使用默认模式和日期格式
        //使用SimpleDateFormat无参构造创建对象
        SimpleDateFormat sdf1 = new SimpleDateFormat();
        //创建日期对象
        Date date1 = new Date();
        //将日期转换为字符串
        String s1 = sdf1.format(date1);
        System.out.println(s1);//21-1-24 下午2:50

        //public SimpleDateFormat(String pattern)构造一个SimpleDateFormat使用给定的模式和默认日期格式
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        //格式化 public final String format(Date date)：将日期格式化成日期/时间字符串
        s1 = sdf2.format(date1);
        System.out.println(s1);//2021年01月24日 14:56:18

        //解析 public Date parse(String source)：从给定的字符串开始解析文本以生成日期
        String s2 = "2021-01-24 15:00:00";
        SimpleDateFormat sdf3 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date2 = sdf3.parse(s2);//ParseException解析异常
        System.out.println(date2);//Sun Jan 24 15:00:00 CST 2021
    }
}

6.5 案例

需求：定义一个日期工具类（DateUtils），包含两个方法：把日期转换为指定格式的字符串；把字符串解析为指定格式的日期，然后定义一个测试类（DateDemo），测试日期工具类的方法

package com.advanced.apimethods;

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

//测试类
public class DateDemo {
    public static void main(String[] args) throws ParseException {

        String s = "2021-1-24 15:35:00";
        Date date1 = DateUtils.stringToDate(s, "yyyy-MM-dd HH:mm:ss");
        System.out.println(date1);//Sun Jan 24 15:35:00 CST 2021
        System.out.println("=================== 分 隔 符 ====================");

        //创建日期对象
        Date date2 = new Date();

        String s2 = DateUtils.dateToString(date2,"yyyy年MM月dd HH:mm:ss");
        System.out.println(s2);//2021年01月24 16:07:16

        String s3 = DateUtils.dateToString(date2,"yyyy年MM月dd");
        System.out.println(s3);//2021年01月24

        String s4 = DateUtils.dateToString(date2,"HH:mm:ss");
        System.out.println(s4);//16:07:16
    }
}

/*
    工具类
        构造方法私有
        成员方法静态
*/
class DateUtils{

    private DateUtils() {
    }

    //时间转换为字符串
    public static String dateToString(Date d, String format){
        SimpleDateFormat sdf1 = new SimpleDateFormat(format);
        return sdf1.format(d);
    }

    //字符串解析为时间
    public static Date stringToDate(String s, String format) throws ParseException {
        SimpleDateFormat sdf2 = new SimpleDateFormat(format);
        return sdf2.parse(s);
    }
}

6.6 Calendar类

Calendar为某一时刻和一组日历字段之间的转换提供了一些方法，并为操作日历字段提供了一些方法

Calendar提供了一个类方法getInstance用于获取Calendar对象，其日历字段已使用当前日期和时间初始化：

Calendar rightNow = Calendar.getInstance();

常用方法

方法名	说明
public int get(int field)	返回给定日历字段的值
public abstract void add(int field,int amount)	根据日历规则，将指定的时间量添加或减去给定的日历字段
public final void set(int year,int month,int date)	设置当前日历的年月日

package com.advanced.apimethods;

import java.util.Calendar;

//Calendar类
public class CalendarDemo01 {
    public static void main(String[] args) {
        //获取对象
        Calendar c1 = Calendar.getInstance();//多态的形式
        //System.out.println(c1);

        //public int get(int field)获取字段内容
//        int year = c1.get(Calendar.YEAR);
//        int month = c1.get(Calendar.MONTH) + 1;//月份从0开始，需要加1
//        int date = c1.get(Calendar.DATE);
//        System.out.println(year + "年" + month + "月" + date + "日");//2021年1月24日

        //需求1：3年前的今天
        //add()方法，给指定字段加上或减去相应时间量
//        c1.add(Calendar.YEAR,-3);
//        int year = c1.get(Calendar.YEAR);
//        int month = c1.get(Calendar.MONTH) + 1;//月份从0开始，需要加1
//        int date = c1.get(Calendar.DATE);
//        System.out.println(year + "年" + month + "月" + date + "日");//2018年1月24日

        //需求2：10年后的5天前
//        c1.add(Calendar.YEAR,10);
//        c1.add(Calendar.DATE,-5);
//
//        int year = c1.get(Calendar.YEAR);
//        int month = c1.get(Calendar.MONTH) + 1;//月份从0开始，需要加1
//        int date = c1.get(Calendar.DATE);
//        System.out.println(year + "年" + month + "月" + date + "日");//2031年1月19日

        //set()方法，给日历设置指定的年月日
        c1.set(2022,11,12);//注意：月份设置值比实际值要小1，即设置11，实为12月
        int year = c1.get(Calendar.YEAR);
        int month = c1.get(Calendar.MONTH) + 1;//月份从0开始，需要加1
        int date = c1.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");//2022年12月12日
    }
}

6.7 案例：二月天

需求：获取任意一年二月份天数

package com.advanced.apimethods;

import java.util.Calendar;
import java.util.Scanner;

//需求：获取任意一年二月份天数
public class CalendarFebCount {
    public static void main(String[] args) {
        //创建日历对象
        Calendar c1 = Calendar.getInstance();

        //提示输入年份
        System.out.println("请输入年份：如2021，区间1900-2100");

        //创建扫描对象
        Scanner sc = new Scanner(System.in);
        int year = 1970;
        while (true) {
            year = sc.nextInt();
            System.out.println();
            if (year < 1900 || year >= 2100) {
                System.out.println("输入的年份数不合法，请重新输入！！！");
                continue;
            }
            break;
        }
        sc.close();

        //设置日历时间：3月1日
        c1.set(year,2,1);

        //3月1日往前推一天，就是2月最后一天
        c1.add(Calendar.DATE, -1);

        //获取这一天输出即可
        int date = c1.get(Calendar.DATE);
        System.out.println(year + "年：二月份天数" + date + "天");
    }
}