Hualiang's Blog

此处总结一些目前正在使用的常用类

java.time

这是 JDK 8 新增的处理时间的 API ，使用前需要导入，对于之前版本的时间处理方式，我们不多赘述。

创建时间对象

java.time 提供了两种实例化方式以及一些常用方法，如下：

import java.time.*;

public class Test {
    public static void main(String[] args) {
        // now(): 创建当前时间和日期的实例对象
        LocalDate localDate = LocalDate.now();
        LocalTime localTime = LocalTime.now();
        LocalDateTime localDateTime = LocalDateTime.now();
        System.out.println(localDate); // 2023-01-26
        System.out.println(localTime); // 14:23:25.428286700
        System.out.println(localDateTime); // 2023-01-26T14:23:25.428286700
        
        // of(): 创建指定时间和日期的实例对象
        LocalDateTime localDateTime1 = LocalDateTime.of(2003, 12, 18, 12, 00, 00);
        System.out.println(localDateTime1); // 2003-12-18T12:00
        
        // getXXX(): 获取时间点
        System.out.println(localDateTime.getDayOfMonth()); // 26 - 该月第几天
        System.out.println(localDateTime.getDayOfWeek());  // THURSDAY - 该周第几天
        System.out.println(localDateTime.getMonth());      // JANUARY - 当前月份
        System.out.println(localDateTime.getMonthValue()); // 1 - 当前月份的值
        System.out.println(localDateTime.getMinute());     // 23 - 当前分钟
        
        // withXXX(): 获取指定时间点，返回一个指定LocalDate对象
        LocalDate localDate1 = localDate.withDay0fMonth(22); // 指定该月第22天，原对象属性不变
        System.out.println(localDate1); // 2023-01-22
        
        // plusXXX() & minusXXX(): 给时间加减上某一时间段
        LocalDateTime localDateTime3 = localDateTime.plusMonths(3);
		LocalDateTime localDateTime4 = localDateTime.minusDays(3);
        System.out.print1n(localDateTime3); // 2023-04-26T14:23:25.428286700
        System.out.print1n(localDateTime4); // 2023-01-23T14:23:25.428286700
    }
}

瞬时对象

在处理时间时，机器则是使用时间戳，它是时间线上的一个瞬时点，表现为自1970年1月1日0时0分0秒(UTC)至今的秒数，java.time 提供了 Instant 类来处理，它可以精确至纳秒级

import java.time.*;

public class Test {
    public static void main(String[] args) {
        Instant instant = Instant.now(); // 以中时区为准，差8小时
        System.out.println(instant); // 2023-01-26T07:15:39.515749800Z

        offsetDateTime offsetDateTime = instant.atoffset(ZoneOffset.ofHours(8)); // 设置偏移量
        System.out.println(offsetDateTime); // 2023-01-26T15:19:24.224082+08:00

        long Milli = instant.toEpochMilli(); // 获取当前时间戳（毫秒级）
        System.out.println(Milli); // 1674717794320

        Instant instant1 = Instant. ofEpochMilli(1550475314878L); // 根据时间戳，获取Instant实例
        System.out.println(instant1); // 2019-02-18T07:35:14.878Z
    }
}

注意：Instant.now() 是以中时区为准，与东八区差8小时，使用时可根据需要添加偏移量

格式化日期时间

我们使用 java.time.format 中 DateTimeFormatter 类来格式化时间，该类提供了三种方法：

• 预定义的标准格式：ISO_LOCAL_DATE_TIME ，ISO_LOCAL_DATE ，ISO_LOCAL_TIME
• 本地化相关的格式：ofLocalizedDateTime() ，ofLocalizedDate()
• 自定义的格式：ofPattern(*yy-MM-dd hh:mm:ss E")

import java.time.*;
import java.time.format.*;
import java.time.temporal.TemporalAccessor;

public class Test {
    public static void main(String[] args) {
        LocalDateTime localDateTime = LocalDateTime.now();
        DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME; // 使用预定义格式
        DateTimeFormatter formatter1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT); // 使用本地化的格式，不止这一种
        DateTimeFormatter formatter2 = DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL); // 使用本地化的格式
        DateTimeFormatter formatter3 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss E"); // 使用自定义的格式，末尾的E代表星期
        
        // 格式化
        String str = formatter.format(localDateTime);
        String str1 = formatter1.format(localDateTime);
        String str2 = formatter2.format(localDateTime);
        String str3 = formatter3.format(localDateTime);
        System.out.println(str);  // 2023-01-26T16:12:58.8238423
        System.out.println(str1); // 2023/1/26 16:12
        System.out.println(str2); // 2023年1月26日星期四
        System.out.println(str3); // 2023-01-26 04:12:58 周四
        
        // 解析
        TemporalAccessor parse = formatter.parse("2023-01-26T15:49:50.052318");
        TemporalAccessor parse1 = formatter1.parse("2023/1/26 15:57");
        TemporalAccessor parse2 = formatter2.parse("2023年1月26日星期四");
        TemporalAccessor parse3 = formatter3.parse("2023-01-26 04:08:00 周四");
        System.out.println(parse);  // {},ISO resolved to 2023-01-26T15:49:50.052318
        System.out.println(parse1); // {},ISO resolved to 2023-01-26T15:57
        System.out.println(parse2); // {},ISO resolved to 2023-01-26
        System.out.println(parse3); // {MinuteOfHour=8, MicroOfSecond=0, MilliOfSecond=0, SecondOfMinute=0, HourOfAmPm=4, NanoOfSecond=0},ISO resolved to 2023-01-26
    }
}

其他 API

java 比较器

Java中的对象，正常情况下，只能进行 == 或 != 的比较，不能使用 > 或 < 的，但是在开发场景中，我们需要比较对象的大小。

因此 Java 提供了两个接口来实现此功能：Comparable & Comparator

Comparable 接口

Comparable 接口实现的是自然排序，默认为升序，像 String，包装类等都已经实现了 Comparable 接口。

public class Test implements Comparable { // 实现接口
    private int value;
    
    public Test(int value) {
        this.value = value;
    }
    
    @Override
    public int compareTo(Object o) { // 重写方法，只能返回 1 / -1 / 0
        if (o instanceof Test) {
            Test test = (Test)o;
            // 方式一
            if (this.value > test.value) {
                return 1;
            } else if (this.value < test.value) {
                return -1
            } else {
                return 0;
            }
            /* 方式二，更简单
            return Integer.compare(this.value, test.value); */
        } // 后续可以抛些异常啥的...
    }
}

实现规则（升序）：

• 如果当前对象 this 大于形参对象 obj ，则返回正整数,
• 如果当前对象 this 小于形参对象 obj ，则返回负整数,
• 如果当前对象 this 等于形参对象 obj ，则返回零。

Comparator 接口

Comparator 接口实现的是定制排序，当元素的类型没有实现 Comparable 接口而又不方便修改代码或者实现了接口的排序规则不适合当前的操作，那么可以考虑使用 Comparator 的对象来临时进行排序。

public class Test {
    public static void main(String[] args) {
        String[] arr = new String[]{"AA", "CC", "KK" , "MM", "GG","JJ", "DD"};
        Arrays.sort(arr, new Comparator() { // 此处使用匿名实现类
            @Override
            public int compare(0bject o1, object o2) {
                if(o1 instanceof String && o2 instanceof String) {
                    String s1 = (String) 01;
                    String s2 = (String) o2;
                    return -s1. compareTo(s2); // 倒序
            	}
             // return 0;
                throw new RuntimeException("输入的数据类型不一致");
            }
        });
    }
}

注：使用 Comparator 接口并未改变原有比较方式，而是在比较时使用传入的 Comparator 实现类所指定的规则来临时进行比较。

System 类

System 类代表系统， 系统级的很多属性和控制方法都放置在该类的内部。由于该类的构造器是 private 的， 所以无法创建该类的对象。其内部的成员变量和成员方法都是静态的，可直接调用。如下：

系统中常见的属性名以及属性的作用如下表所示：

Math 类

Math 类提供了一系列静态方法用于科学计算。其方法的参数和返回值类型一般为 double & long 型。

BigInteger & BigDecimal 类

java.math 包的 BigInteger 类可以表示不可变的任意精度的整数，而 BigDecimal 类可以表示不可变的任意精度的十进制定点数。两者均提供所有 Java 的基本整数操作符的对应物，并提供 Math的所有相关方法。另外，BigInteger 还提供模算术、GCD计算、质数测试、素数生成、位操作等一些其他操作。

BigInteger & BigDecimal 是通过传入字符串或数值来实例化对象，如下：

BigInteger a = new BigInteger("123456"); // 还能传入一个参数radix来指定该数据的进制类型，默认十进制
BigDecimal b = new BigDecimal(0.1);

下面是一些常用静态方法：