JAVA常用类

一、System类

概述：包含一些有用的类字段和方法。它不能被实例化
常用方法：

		//获取从1970年1月1日到现在系统时间所有的毫秒数
        long begin = System.currentTimeMillis();
            //获取系统版本
            System.out.println(System.getProperty("os.name"));
            //获取系统用户名
            System.out.println(System.getProperty("user.name"));
            //获取jdk安装目录
            System.out.println(System.getProperty("java.home"));
            //获取jdk版本
            System.out.println(System.getProperty("java.version"));
        long end = System.currentTimeMillis();
        //这样可以计算中间这些代码运行了多长时间
        System.out.println(end - begin);

二、Math类

		//返回所有数值类型的绝对值
        System.out.println(Math.abs(-1.1));

        //执行四舍五入操作
        System.out.println(Math.round(10.4));
        System.out.println(Math.round(10.5));

        //返回一个double类型的随机小数，范围[0,1)
        System.out.println(Math.random());

        //返回一个小于或等于参数的最大浮点数
        System.out.println(Math.floor(2.6));
        System.out.println(Math.floor(-2.6));

        //返回一个大于或等于参数的最小浮点数
        System.out.println(Math.ceil(2.6));
        System.out.println(Math.ceil(-2.6));

        //返回两个参数中的最大值
        System.out.println(Math.max(10,20));

        //返回两个参数中的最小值
        System.out.println(Math.min(10,20));

三、日期类

3.1 jdk1.8之前

1. java.util.Date
   1）概述：表示特定的某个瞬时时刻。精确到毫秒。该类支持日期时间格式，也可以将字符串解析为日期
   2）构造方法：
   Date();
   Dare(long date);
   3）常用方法：

//实例化方式1--调用无参构造(底层实现依旧传递了currentTimeMillis)
Date d1 = new Date();
//实例化方式2--调用带参构造
Date d2 = new Date(System.currentTimeMillis());
Date d3 = new Date();
//已经弃用
d3.setYear(2022);
d3.setMonth(6);
d3.setDate(23);

System.out.println(d1);
System.out.println(d2);
System.out.println(d3);

//after():测试日期是否在指定日期之后
System.out.println(d1.after(d3));
//before()：测试日期是否在指定日期之前
System.out.println(d1.before(d3));

//toString():将日期对象转为字符串对象
System.out.println(d1.toString());
//toLocalString():返回本地格式的日期对象字符串
System.out.println(d1.toLocaleString());
//toInstant():返回一个Instant对象(Jdk1.8中新增)
Instant instant = d1.toInstant();

2. java.sql.Date
   1）概述：它是util.Date的子类，可以完成两者之间的自由转换
   2）构造方法：

   Dare(long date);

Date d = new Date(1000000000);
System.out.println(d);
//通过给定的毫秒数实例化一个日期对象
Date d1 = new Date(System.currentTimeMillis());
//1、valueOf():将特定格式的日期字符串转为Date对象
Date d2 = Date.valueOf("2022-02-21");

d1.setTime(System.currentTimeMillis());

//2、toString():将日期转为字符串对象
System.out.println(d1.toString());
System.out.println(d2);
System.out.println(d2);
        
Date d3 = new Date(System.currentTimeMillis());
System.out.println(d3);

3. Calendar
   1)概述：Calendar是一个抽象类，提供了相关的日期转换方法
   关系图：快捷键：Ctrl+h 查看继承关系
   2)它的子类是：GregorianCalendar，所以可以通过多态调用Calendar里的日期转换方法
   3)常量字段：

//实例化Calendar对象
Calendar calendar = new GregorianCalendar();
System.out.println(calendar);

//get():获取指定时间部分的内容
//YEAR：返回日期中的年份信息
System.out.println(calendar.get(Calendar.YEAR));
//MONTH:返回日期中的月份信息(月份的取值为0~11)
System.out.println(calendar.get(Calendar.MONTH));
//DATE：返回日期中的日期信息
System.out.println(calendar.get(Calendar.DATE));
//HOUR：返回日期中的小时信息
System.out.println(calendar.get(Calendar.HOUR));
//MINUTE：返回日期中的分钟信息
System.out.println(calendar.get(Calendar.MINUTE));
//SECOND：返回日期中的秒信息
System.out.println(calendar.get(Calendar.SECOND));
//DAY_OF_YEAR：返回当前日期是一年的第N天
System.out.println(calendar.get(Calendar.DAY_OF_YEAR));
//DAY_OFMONTH：返回当前日期是一个月的第N天
System.out.println(calendar.get(Calendar.DAY_OF_MONTH));
//DAY_OF_WEEK:返回当前日期是一周的第N天(周日是第一天)
System.out.println(calendar.get(Calendar.DAY_OF_WEEK));
//DAY_OF_WEEK_INMONTH：当前日期是当前月的第N个星期
System.out.println(calendar.get(Calendar.DAY_OF_WEEK_IN_MONTH));

4 ）常用方法

Calendar calendar= new GregorianCalendar();

System.out.println(calendar);

//常用方法
//add():对指定日期字段加(减)相应的值
calendar.add(Calendar.YEAR,-2);
//getMaximum():返回日历中给定字段的最大值
System.out.println(calendar.getMaximum(Calendar.DAY_OF_MONTH));
//getTime():返回当前时间的Date形式
System.out.println("getTime="+calendar.getTime());
//getTimeInMillis():返回当前时间时间差(毫秒数)
System.out.println("getTimeInMillis=" + calendar.getTimeInMillis());

System.out.println(calendar);

四、比较化器

4.1 为什么用比较化器

1. 使用Arrays.sort()方法对数组对象的元素进行排序时，基本类型已经有了比较规则

   • 数值类型：按大小进行比较
   • 字符串类型：按字母顺序进行比较
   • 字符类型：按照字符的数值进行比较
   • 布尔类型：true大于false

2. 对于引用类型的比较，sort()方法不知道具体的比较规则，所以需要调用对象的compareTo()方法来制定比较规则

3. sort()方法的 比较时通过compareTo()来进行实现的

4.2 分类

1. 自然排序
2. 定制排序

4.3.1 自然排序

1. 实现步骤
   • 创建并实行按Comparable接口
   • 实现接 口方法
2. 示例

public static void main(String[] args) {
    User[] arr =  new User[3];
    arr[0] = new User(23);
    arr[1] = new User(34);
    arr[2] = new User(8);

    Arrays.sort(arr);

    for(User u : arr)
	  System.out.println(u);
}



/**
 * 自然排序
 *  步骤：
 *      创建类并实现实现接口
 *      实现接口方法
 */
class User implements Comparable<User>{
    private int age;

    public User(int age) {
        this.age = age;
    }

    /**
     * 定制比较规则
     */
    @Override
    public int compareTo(User o) {
        System.out.println("compareTo()方法被调用了............");
        return this.age-o.age;
    }

    @Override
    public String toString() {
        return "User{" +
                "age=" + age +
                '}';
    }
}

4.3.2 定制排序

1. 步骤
   • 以匿名内部类方式实现Comparataor接口
   • 实现接口方法
2. 示例

    public static void main(String[] args) {
        Student[] arr = new Student[3];
        arr[0] = new Student(20);
        arr[1] = new Student(22);
        arr[2] = new Student(14);

        //使用了定制方式显现了Comparator接口
        Arrays.sort(arr, new Comparator<Student>() {
            /**
             * 实现接口方法
             * @param o1
             * @param o2
             * @return
             */
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getAge()-o2.getAge();
            }
        });

        for(Student stu:arr)
            System.out.println(stu);
    }
}

class Student{
    private int age;

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

    public int getAge() {
        return age;
    }

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

4.3.3 自然排序与定制排序

1. 直接调用对象的compareTo()方法即可，因为在类的内部已经对方法进行实现，定制排序在方法发中以匿名内部类的方式对compareTo()方法进行实现
2. 自然排序具有更大的通用性，定制排序具有更大的灵活性