常用API&日期类

yfs1024

已于 2023-12-22 16:03:20 修改

阅读量352

点赞数 2

文章标签： java

于 2023-02-28 23:34:36 首次发布

本文链接：https://blog.csdn.net/qq_47910339/article/details/129272498

版权

1，常用API

String类型每次操作新的对象，而StringBuilder是在原有的基础基础进行修改，所以如果对于不常修改的变量可以设为String类型，而假如是易修改的数据尽量使用StringBuilder类型

1，StringBuilder

StringBuilder代表可变字符串对象，相当于是一个容器，它里面装的字符串是可以改变的，就是用来操作字符串的。
好处： StringBuilder比String更适合做字符串的修改操作，效率会更高，代码也会更简洁。

构造器	说明
public StringBuilder()	创建一个空白的可变的字符串对象，不包含任何内容
public StringBuilder(String str)	创建一个指定字符串内容的可变字符串对象

方法名称	说明
public StringBuilder append(任意类型)	添加数据并返回StringBuilder对象本身
public StringBuilder reverse()	将对象的内容反转
public int length()	返回对象内容长度
public String toString()	通过toString()就可以实现把StringBuilder转换为String

对于字符串相关的操作，如频繁的拼接、修改等，建议用StringBuidler，效率更高!

注意：如果操作字符串较少，或者不需要操作，以及定义字符串变量，还是建议用String。

2，StringJoiner

StringJoiner需要对字符串中的内容有规律的操作时，可以使用这个类，极大的简化了自己拼接的代码。

有这样的一个需求： 控制台输入一些字符串，需要将其中的字符有规律的进行拼接，比如：

[ 字符串1，字符串2，字符串3]

如果自己进行拼接自己就需要考虑中间的符号，以及开头和结尾的符号，但是如果交给StringJoiner，就很简便。只需要自己指定中间的间隔符号，和开头以及结尾的内容即可

构造器	说明
public StringJoiner (间隔符号)	创建一个StringJoiner对象，指定拼接时的间隔符号
public StringJoiner (间隔符号，开始符号，结束符号)	创建一个StringJoiner对象，指定拼接时的间隔符号、开始符号、结束符号

方法名称	说明
public StringJoiner add (添加的内容)	添加数据，并返回对象本身
public int length()	返回长度 ( 字符出现的个数)
public String toString()	返回一个字符串（该字符串就是拼接之后的结果）

2，Math，System，Runtime

第二类方法只需要记住方法名称即可：

1，Math ：代表数学，是一个工具类，里面提供的都是对数据进行操作的一些静态方法。

常用方法：

方法名	说明
public static int abs(int a)	获取参数绝对值
public static double ceil(double a)	向上取整
public static double floor(double a)	向下取整
public static int round(float a)	四舍五入
public static int max(int a,int b)	获取两个int值中的较大值
public static double pow(double a,double b)	返回a的b次幂的值
public static double random()	返回值为double的随机值，范围[0.0,1.0)

  System.out.println(Math.abs(-12)); // 12
        System.out.println(Math.abs(123)); // 123
        System.out.println(Math.abs(-3.14)); // 3.14

        // 2、public static double ceil(double a): 向上取整
        System.out.println(Math.ceil(4.0000001)); // 5.0
        System.out.println(Math.ceil(4.0)); // 4.0

        // 3、public static double floor(double a): 向下取整
        System.out.println(Math.floor(4.999999)); // 4.0
        System.out.println(Math.floor(4.0)); // 4.0

        // 4、public static long round(double a)：四舍五入
        System.out.println(Math.round(3.4999)); // 3
        System.out.println(Math.round(3.50001)); // 4

        // 5、public static int max(int a, int b)：取较大值
        //   public static int min(int a, int b)：取较小值
        System.out.println(Math.max(10, 20)); // 20
        System.out.println(Math.min(10, 20)); // 10

        // 6、 public static double pow(double a, double b)：取次方
        System.out.println(Math.pow(2, 3)); // 2的3次方   8.0
        System.out.println(Math.pow(3, 2)); // 3的2次方   9.0

2，System类

System代表程序所在的系统，也是一个工具类

常用方法：

Status ：

0：正常退出

1：异常退出

方法名	说明
public static void exit(int status)	终止当前运行的Java虚拟机。
public static long currentTimeMillis()	返回当前系统的时间毫秒值形式

**时间毫秒值（规定）：**指的是从1970年1月1日 00:00:00走到此刻的总的毫秒数，应该是很大的。 1s = 1000ms。

3，Runtime （单例类）

代表程序所在的运行环境

常见方法：

方法名	说明
public static Runtime getRuntime()	返回与当前Java应用程序关联的运行时对象
public void exit(int status)	终止当前运行的虚拟机
public int availableProcessors()	返回Java虚拟机可用的处理器数。
public long totalMemory()	返回Java虚拟机中的内存总量
public long freeMemory()	返回Java虚拟机中的可用内存
public Process exec(String command)	启动某个程序，并返回代表该程序的对象

3，BigDecimal 🚥

这个类的出现就是为了解决精度丢失的问题：代码如下

   public static void main(String[] args) {
        double d1 = 0.1;
        double d2 = 0.2;

        System.out.println(d1+d2);   //  0.30000000000000004
    }

当需求中对精度有绝对的要求的时候，这样子肯定是不行的。所以就产生了BigDecimal这个类，来弥补这个问题：

BigDecima的常见构造器、常用方法

构造的时候要传String类型的值, 如果还是原类型好像没有效果, 示例: double + double 结果还是存在精度丢失

构造器	说明
public BigDecimal(String val)	把String转成BigDecimal

方法名	说明
public static BigDecimal valueOf(double val)	转换一个 double成 BigDecimal
public BigDecimal add(BigDecimal b)	加法
public BigDecimal subtract(BigDecimal b)	减法
public BigDecimal multiply(BigDecimal b)	乘法
public BigDecimal divide(BigDecimal b)	除法
public BigDecimal divide (另一个BigDecimal对象，精确几位，舍入模式)	除法、可以控制精确到小数几位
public double doubleValue()	将BigDecimal转换为double

使用BIgDecimal类来解决精度丢失的问题如下：

        BigDecimal bigDecimal1 = new BigDecimal("0.1");
        BigDecimal bigDecimal2 = new BigDecimal("0.2");

        BigDecimal res = bigDecimal1.add(bigDecimal2);
        System.out.println(res);   // 0.3

4，JDK8之前传统的日期、时间

Date 代表的是日期和时间。

构造器	说明
public Date()	创建一个Date对象，代表的是系统当前此刻日期时间。
public Date(long time)	把时间毫秒值转换成Date日期对象。

常见方法	说明
public long getTime()	返回从1970年1月1日 00:00:00走到此刻的总的毫秒数
public void setTime(long time)	设置日期对象的时间为当前时间毫秒值对应的时间

Date date = new Date();
System.out.println(date);   //输出结果： Tue Feb 28 22:30:51 CST 2023

// 如果传入的是Long类型，则会自动转为Date类型 测试代码如下：
Date date1 = new Date(1677514702260l);
System.out.println(date1);   // Tue Feb 28 00:18:22 CST 2023

但是会发现一个问题，就是Date对应输出的值，不符合我们的习惯，那么有没有一种方式来格式化一下日期的内容呢？当然有，那就是SimpleDateFormat类

SimpleDateFormat：代表简单日期格式化，可以用来把日期对象、时间毫秒值格式化成我们想要的形式。

常见构造器	说明
public SimpleDateFormat(String pattern)	创建简单日期格式化对象，并封装时间的格式

格式化时间的方法	说明
public final String format(Date date)	将日期格式化成日期/时间字符串
public final String format(Object time)	将时间毫秒值式化成日期/时间字符串

构造器中的时间格式常见的包括：

  y	年
  M	月
  d	日
  H	时
  m	分
  s	秒
  EEE      星期几
  a          上午/下午

有日期类到时间的字符串的格式，我们叫做 格式化，那么从字符串到日期类型我们叫做解析

通过下面的代码来具体的实现格式化和解析：

public static void main(String[] args) {
    SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    //   格式化
    String format = simpleDateFormat.format(new Date());
    System.out.println("自定义格式化之后的时间为：" + format);
    
    //   解析： 注意这里的解析传入的数据，必须要和格式化的形式一模一样，不然会报异常
    String dayOne ="2023-02-28 22:44:18";
    //   通过SimpleDateFormat中的parse方法将字符串解析为Date类型
    Date parse = simpleDateFormat.parse(dayOne);
    System.out.println(parse.getTime());
}

上面是JDK8之前处理时间的方式，下面我们来学习JDK8之后的API，在学之前我们先做一个对比，即和之前的比后面的API有什么好处？

jdk8之前：

1、设计不合理，使用不方便，很多都被淘汰了。

2、都是可变对象，修改后会丢失最开始的时间信息。

3、线程不安全。

4、只能精确到毫秒。

jdk8之后：

1、设计更合理，功能丰富，使用更方便。

2、都是不可变对象，修改后会返回新的时间对象，不会丢失最开始的时间。

3、线程安全。

4、能精确到毫秒、纳秒。

所以我们推荐JDk8之后的，但是之前的我们也要大致的了解一下，防止在开发中遇到：

小知识点：

1秒=1000毫秒；

1毫秒=1000微秒；

1微秒=1000纳秒；

5，JDK8之前传统的日期、时间

首先jdk8之后的api都在java.time包下，而且类中的方法都是静态的，具体类如下：

LocalDate：年、月、日

LocalTime：时、分、秒

LocalDateTime：年、月、日，时、分、秒

ZoneId：时区

ZonedDateTime：带时区的时间

Instant：时间戳/时间线

DateTimeFormatter：用于时间的格式化和解析

Duration:时间间隔（时、分、秒，纳秒）

Period:时间间隔（年，月，日）

这些类的构造器都私有化了，所以我们获取对象，就要通过其中的方法。

方法名	示例
public static Xxxx now(): 获取系统当前时间对应的该对象	LocaDate ld = LocalDate.now(); LocalTime lt = LocalTime.now(); LocalDateTime ldt = LocalDateTime.now();
public static Xxxx of(…)：获取指定时间的对象	LocalDate localDate1 = LocalDate.of(2099 , 11,11); LocalTime localTime1 = LocalTime.of(9, 8, 59); LocalDateTime localDateTime1 = LocalDateTime.of(2025, 11, 16, 14, 30, 01);

1，LocalDate的常用API(都是处理年、月、日、星期相关的)

方法名	说明
public int geYear()	获取年
public int getMonthValue()	获取月份（1-12）
public int getDayOfMonth()	获取日
public int getDayOfYear()	获取当前是一年中的第几天
Public DayOfWeek getDayOfWeek()	获取星期几：ld.getDayOfWeek().getValue()

方法名	说明
withYear、withMonth、withDayOfMonth、withDayOfYear	直接修改某个信息，返回新日期对象
plusYears、plusMonths、plusDays、plusWeeks	把某个信息加多少，返回新日期对象
minusYears、minusMonths、minusDays，minusWeeks	把某个信息减多少，返回新日期对象
equals isBefore isAfter	判断两个日期对象，是否相等，在前还是在后

代码演示：

    // 0、获取本地日期对象(不可变对象)
    LocalDate ld = LocalDate.now(); // 年 月 日
    System.out.println(ld);

    // 1、获取日期对象中的信息
    int year = ld.getYear(); // 年
    int month = ld.getMonthValue(); // 月(1-12)
    int day = ld.getDayOfMonth(); // 日
    int dayOfYear = ld.getDayOfYear();  // 一年中的第几天
    int dayOfWeek = ld.getDayOfWeek().getValue(); // 星期几
    System.out.println(year);
    System.out.println(day);
    System.out.println(dayOfWeek);

    // 2、直接修改某个信息: withYear、withMonth、withDayOfMonth、withDayOfYear
    LocalDate ld2 = ld.withYear(2099);
    LocalDate ld3 = ld.withMonth(12);
    System.out.println(ld2);
    System.out.println(ld3);
    System.out.println(ld);

    // 3、把某个信息加多少: plusYears、plusMonths、plusDays、plusWeeks
    LocalDate ld4 = ld.plusYears(2);
    LocalDate ld5 = ld.plusMonths(2);

    // 4、把某个信息减多少：minusYears、minusMonths、minusDays、minusWeeks
    LocalDate ld6 = ld.minusYears(2);
    LocalDate ld7 = ld.minusMonths(2);

    // 5、获取指定日期的LocalDate对象： public static LocalDate of(int year, int month, int dayOfMonth)
    LocalDate ld8 = LocalDate.of(2099, 12, 12);
    LocalDate ld9 = LocalDate.of(2099, 12, 12);

    // 6、判断2个日期对象，是否相等，在前还是在后： equals isBefore isAfter
    System.out.println(ld8.equals(ld9));// true
    System.out.println(ld8.isAfter(ld)); // true
    System.out.println(ld8.isBefore(ld)); // false

2，LocalTime类的基本使用

     // 0、获取本地时间对象
    LocalTime lt = LocalTime.now(); // 时 分 秒 纳秒 不可变的
    System.out.println(lt);    
	// 1、获取时间中的信息
    int hour = lt.getHour(); //时
    int minute = lt.getMinute(); //分
    int second = lt.getSecond(); //秒
    int nano = lt.getNano(); //纳秒

    // 2、修改时间：withHour、withMinute、withSecond、withNano
    LocalTime lt3 = lt.withHour(10);
    LocalTime lt4 = lt.withMinute(10);
    LocalTime lt5 = lt.withSecond(10);
    LocalTime lt6 = lt.withNano(10);

    // 3、加多少：plusHours、plusMinutes、plusSeconds、plusNanos
    LocalTime lt7 = lt.plusHours(10);
    LocalTime lt8 = lt.plusMinutes(10);
    LocalTime lt9 = lt.plusSeconds(10);
    LocalTime lt10 = lt.plusNanos(10);

    // 4、减多少：minusHours、minusMinutes、minusSeconds、minusNanos
    LocalTime lt11 = lt.minusHours(10);
    LocalTime lt12 = lt.minusMinutes(10);
    LocalTime lt13 = lt.minusSeconds(10);
    LocalTime lt14 = lt.minusNanos(10);

    // 5、获取指定时间的LocalTime对象：
    // public static LocalTime of(int hour, int minute, int second)
    LocalTime lt15 = LocalTime.of(12, 12, 12);
    LocalTime lt16 = LocalTime.of(12, 12, 12);

    // 6、判断2个时间对象，是否相等，在前还是在后： equals isBefore isAfter
    System.out.println(lt15.equals(lt16)); // true
    System.out.println(lt15.isAfter(lt)); // false
    System.out.println(lt15.isBefore(lt)); // true

3，LocalDateTime类的基本使用

    // 0、获取本地日期和时间对象。
    LocalDateTime ldt = LocalDateTime.now(); // 年 月 日 时 分 秒 纳秒
    System.out.println(ldt);

    // 1、可以获取日期和时间的全部信息
    int year = ldt.getYear(); // 年
    int month = ldt.getMonthValue(); // 月
    int day = ldt.getDayOfMonth(); // 日
    int dayOfYear = ldt.getDayOfYear();  // 一年中的第几天
    int dayOfWeek = ldt.getDayOfWeek().getValue();  // 获取是周几
    int hour = ldt.getHour(); //时
    int minute = ldt.getMinute(); //分
    int second = ldt.getSecond(); //秒
    int nano = ldt.getNano(); //纳秒

    // 2、修改时间信息：
    // withYear withMonth withDayOfMonth withDayOfYear withHour
    // withMinute withSecond withNano
    LocalDateTime ldt2 = ldt.withYear(2029);
    LocalDateTime ldt3 = ldt.withMinute(59);

    // 3、加多少:
    // plusYears  plusMonths plusDays plusWeeks plusHours plusMinutes plusSeconds plusNanos
    LocalDateTime ldt4 = ldt.plusYears(2);
    LocalDateTime ldt5 = ldt.plusMinutes(3);

    // 4、减多少：
    // minusDays minusYears minusMonths minusWeeks minusHours minusMinutes minusSeconds minusNanos
    LocalDateTime ldt6 = ldt.minusYears(2);
    LocalDateTime ldt7 = ldt.minusMinutes(3);


    // 5、获取指定日期和时间的LocalDateTime对象：
    // public static LocalDateTime of(int year, Month month, int dayOfMonth, int hour,
    //                                  int minute, int second, int nanoOfSecond)
    LocalDateTime ldt8 = LocalDateTime.of(2029, 12, 12, 12, 12, 12, 1222);
    LocalDateTime ldt9 = LocalDateTime.of(2029, 12, 12, 12, 12, 12, 1222);

    // 6、 判断2个日期、时间对象，是否相等，在前还是在后： equals、isBefore、isAfter
    System.out.println(ldt9.equals(ldt8));
    System.out.println(ldt9.isAfter(ldt));
    System.out.println(ldt9.isBefore(ldt));

    // 7、可以把LocalDateTime转换成LocalDate和LocalTime
    // public LocalDate toLocalDate()
    // public LocalTime toLocalTime()
    // public static LocalDateTime of(LocalDate date, LocalTime time)
    LocalDate ld = ldt.toLocalDate();
    LocalTime lt = ldt.toLocalTime();
    LocalDateTime ldt10 = LocalDateTime.of(ld, lt);

接着，我们学习代表时区的两个类。由于世界各个国家与地区的经度不同，各地区的时间也有所不同，因此会划分为不同的时区。每一个时区的时间也不太一样。

4，ZoneId 时区

方法名	说明
public static Set getAvailableZoneIds()	获取Java中支持的所有时区
public static ZoneId systemDefault()	获取系统默认时区
public static ZoneId of(String zoneId)	获取一个指定时区

5，ZonedDateTime 带时区时间的常用方法：

方法名	说明
public static ZonedDateTime now()	获取当前时区的ZonedDateTime对象
public static ZonedDateTime now(ZoneId zone)	获取指定时区的ZonedDateTime对象
getYear、getMonthValue、getDayOfMonth、getDayOfYeargetDayOfWeek、 getHour、getMinute、getSecond、getNano	获取年月日、时分秒、纳秒等
public ZonedDateTime withXxx(时间)	修改时间系列的方法
public ZonedDateTime minusXxx(时间)	减少时间系列的方法
public ZonedDateTime plusXxx(时间)	增加时间系列的方法

 // 目标：了解时区和带时区的时间。
        // 1、ZoneId的常见方法：
        // public static ZoneId systemDefault(): 获取系统默认的时区
        ZoneId zoneId = ZoneId.systemDefault();
        System.out.println(zoneId.getId());
        System.out.println(zoneId);

        // public static Set<String> getAvailableZoneIds(): 获取Java支持的全部时区Id
        System.out.println(ZoneId.getAvailableZoneIds());

        // public static ZoneId of(String zoneId) : 把某个时区id封装成ZoneId对象。
        ZoneId zoneId1 = ZoneId.of("America/New_York");

        // 2、ZonedDateTime：带时区的时间。
        // public static ZonedDateTime now(ZoneId zone): 获取某个时区的ZonedDateTime对象。
        ZonedDateTime now = ZonedDateTime.now(zoneId1);
        System.out.println(now);

        // 世界标准时间了
        ZonedDateTime now1 = ZonedDateTime.now(Clock.systemUTC());
        System.out.println(now1);

        // public static ZonedDateTime now()：获取系统默认时区的ZonedDateTime对象
        ZonedDateTime now2 = ZonedDateTime.now();
        System.out.println(now2);

        // Calendar instance = Calendar.getInstance(TimeZone.getTimeZone(zoneId1));

6，Instant 表示：时间线上的某个时刻/时间戳

方法名	说明
public static Instant now()	获取当前时间的Instant对象（标准时间）
public long getEpochSecond()	获取从1970-01-01T00：00：00开始记录的秒数。
public int getNano()	从时间线开始，获取从第二个开始的纳秒数
plusMillis plusSeconds plusNanos	判断系列的方法
minusMillis minusSeconds minusNanos	减少时间系列的方法
equals、isBefore、isAfter	增加时间系列的方法

7，DateTimeFormatter

方法名	说明
public static DateTimeFormatter ofPattern(时间格式)	获取格式化器对象
public String format(时间对象)	格式化时间

这个对时间的解析和格式化，需要通过LocalDateTime中的两个方法来实现，参数为格式化的对象

方法名	说明
public String format ( DateTimeFormatter formatter)	格式化时间
public static LocalDateTime parse (CharSequence text, DateTimeFormatter formatter)	解析时间

8，Period （一段时期，即时间间隔）

可以用于计算两个 LocalDate对象相差的年数、月数、天数。

方法名	说明
public static Period between(LocalDate start, LocalDate end)	传入2个日期对象，得到Period对象
public int getYears()	计算隔几年，并返回
public int getMonths()	计算隔几个月，年返回
public int getDays()	计算隔多少天，并返回

/**
 * 目标：掌握Period的作用：计算机两个日期相差的年数，月数、天数。
 */
public class Test7_Period {
    public static void main(String[] args) {
        LocalDate start = LocalDate.of(2029, 8, 10);
        LocalDate end = LocalDate.of(2029, 12, 15);

        // 1、创建Period对象，封装两个日期对象。
        Period period = Period.between(start, end);

        // 2、通过period对象获取两个日期对象相差的信息。
        System.out.println(period.getYears());
        System.out.println(period.getMonths());
        System.out.println(period.getDays());
    }
}

9，Duration类

可以用于计算两个时间对象相差的天数、小时数、分数、秒数、纳秒数；支持LocalTime、LocalDateTime、Instant等时间

方法名	说明
public static Duration between(开始时间对象1,截止时间对象2)	传入2个时间对象，得到Duration对象
public long toDays()	计算隔多少天，并返回
public long toHours()	计算隔多少小时，并返回
public long toMinutes()	计算隔多少分，并返回
public long toSeconds()	计算隔多少秒，并返回
public long toMillis()	计算隔多少毫秒，并返回
public long toNanos()	计算隔多少纳秒，并返回

public class Test8_Duration {
    public static void main(String[] args) {
        LocalDateTime start = LocalDateTime.of(2025, 11, 11, 11, 10, 10);
        LocalDateTime end = LocalDateTime.of(2025, 11, 11, 11, 11, 11);
        // 1、得到Duration对象
        Duration duration = Duration.between(start, end);

        // 2、获取两个时间对象间隔的信息
        System.out.println(duration.toDays());// 间隔多少天
        System.out.println(duration.toHours());// 间隔多少小时
        System.out.println(duration.toMinutes());// 间隔多少分
        System.out.println(duration.toSeconds());// 间隔多少秒
        System.out.println(duration.toMillis());// 间隔多少毫秒
        System.out.println(duration.toNanos());// 间隔多少纳秒
    }
}

yfs1024

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
常用API&日期类

String类型每次操作新的对象，而StringBuilder是在原有的基础基础进行修改，所以如果对于不常修改的变量可以设为String类型，而假如是易修改的数据尽量使用StringBuilder类型
复制链接

扫一扫