Java学习day_15之API（时间，包装类）

一、JDK7时间类

Date类

常用构造方法

//Date()：创建一个表示当前时间的Date对象。
Date now = new Date(); // 表示当前系统时间
//Date(long milliseconds)：根据指定的毫秒数创建Date对象。
Date past = new Date(1000L); // 表示1970-01-01 00:00:01

常用方法

import java.util.Date;

public class DateDemo1 {
    public static void main(String[] args) {
        //1.创建对象表示一个时间
        Date d = new Date();
        System.out.println(d);

        //2.创建对象表示一个指定时间
        Date d1 = new Date(0);
        System.out.println(d1);

        //3.setTime 修改时间
        //1000毫秒 = 1秒
        d1.setTime(1000);
        System.out.println(d1);

        //4.getTime获取当前时间的毫秒值
        long time = d.getTime();
        System.out.println(time);
    }
}

SimpleDateFormat类

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

public class SimpleDateFormatDemo1 {
    public static void main(String[] args) throws ParseException {
        format();
        parse();
    }

    private static void parse() throws ParseException {
        //1.定义一个字符串表示时间
        String str = "2023-11-11 11:11:11";
        //2.创建SimpleDateFormat对象，格式要与字符串格式一致
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = sdf.parse(str);
        System.out.println(date);
    }

    private static void format() {
        //1.利用空参构造创建SimpleDateFormate对象，默认格式
        SimpleDateFormat sdf = new SimpleDateFormat();
        Date d1 = new Date(0L);
        System.out.println(sdf.format(d1));
        //2.利用带参构造创建SimpleDateFormat对象，指定格式
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy年MM月dd日 HH::mm:ss");
        System.out.println(sdf1.format(d1));
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日 HH::mm:ss EE");
        System.out.println(sdf2.format(d1));
    }
}

Calendar类

java.util.Calendar 是处理日期和时间的核心类，用于替代早期的 java.util.Date（Date 仅存储时间戳，无日期时间计算能力）。它提供了日期字段（年、月、日、时、分、秒等）的获取、设置、加减运算，以及时区、历法（如公历）的支持。

import java.util.Calendar;
import java.util.Date;

public class CalendarDemo {
    public static void main(String[] args) {
        /*
        1.获取日历对象
        细节1：Calendar是一个抽象类，不能直接new，而是通过一个静态方法获取到子类对象
        底层原理：
        会根据系统的不同时区来获取不同的日历对象，默认表示当前时间
        会把时间中的纪元、年、月、日、时、分、秒、星期，等等都放到一个数组当中
        细节2：
        月份：范围0~11，如果获取出来的是0，实际上是1月
        星期：周日是第一天
         */
        Calendar c = Calendar.getInstance();
        System.out.println(c);

        //2.修改一下日历代表的时间
        Date d = new Date(0L);
        c.setTime(d);
        System.out.println(c);

        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH) + 1;
        int date = c.get(Calendar.DAY_OF_MONTH);
        int week = c.get(Calendar.DAY_OF_WEEK);
        System.out.println(year + ", " + month + ", " + date + ", " +  getWeek(week));

        c.set(Calendar.YEAR,2025);
        c.set(Calendar.MONTH,8);
        c.set(Calendar.DAY_OF_MONTH,10);

        c.add(Calendar.MONTH,1);
        int year1 = c.get(Calendar.YEAR);
        int month1 = c.get(Calendar.MONTH) + 1;
        int date1 = c.get(Calendar.DAY_OF_MONTH);
        int week1 = c.get(Calendar.DAY_OF_WEEK);
        System.out.println(year1 + ", " + month1 + ", " + date1 + ", " +  getWeek(week1));
    }

    public static String getWeek(int index){
        String[] arr = {"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
        return arr[index];
    }
}

二、JDK8时间类

JDK 8 引入了全新的日期时间 API（位于 java.time 包下），相较于 JDK 7 及之前的 java.util.Date、java.util.Calendar 等时间类，有了根本性的改进，主要变化和优势如下：

1. 不可变性 JDK 7 问题：Date、Calendar 是可变类（例如 setTime()、add() 方法会修改对象本身），在多线程环境下存在线程安全问题。 JDK 8 改进：java.time 包下的类（如 LocalDate、Instant、ZonedDateTime 等）都是不可变的，任何修改操作都会返回一个新对象，天然线程安全。
2. 清晰的类职责划分 JDK 7 问题：Date 既包含日期又包含时间，Calendar 职责混乱（既是日期时间载体，又负责日期计算），且月份从 0 开始（不合理）。 JDK 8 改进：按功能拆分出多个类，职责明确

Date类

ZoneId：时区

import java.time.ZoneId;
import java.util.Set;

public class ZoneIdDemo1 {
    public static void main(String[] args) {
        //1.获取所有的时区名称
        Set<String> zoneIds = ZoneId.getAvailableZoneIds();
        System.out.println(zoneIds.size());
        System.out.println(zoneIds);

        //2.获取当前系统的默认时区
        ZoneId zoneId = ZoneId.systemDefault();
        System.out.println(zoneId);

        //3.获取指定时区
        ZoneId zoneId1 = ZoneId.of("Asia/Aqtau");
        System.out.println(zoneId1);
    }
}

Instant：时间戳

import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;

public class InstantDemo {
    public static void main(String[] args) {
        //1.获取当前时间的Instant对象（标准时间）
        Instant now = Instant.now();
        System.out.println(now);//+8为本地时间

        //2.根据（秒/毫秒/纳秒）获取Instant对象
        Instant instant1 = Instant.ofEpochMilli(0L);
        System.out.println(instant1);//毫秒 1970-01-01T00:00:00Z

        Instant instant2 = Instant.ofEpochSecond(1L);
        System.out.println(instant2);//秒  1970-01-01T00:00:01Z

        Instant instant3 = Instant.ofEpochSecond(1L, 2000000000L);
        System.out.println(instant3);//秒+纳秒  1970-01-01T00:00:03Z

        //3.指定时区
        ZonedDateTime time = Instant.now().atZone(ZoneId.of("Asia/Shanghai"));
        System.out.println(time);//2025-09-16T17:17:36.948975100+08:00[Asia/Shanghai]

        //4.isXxx 判断
        //用于时间的判断 isBefore/isAfter 判断调用者代表的时间是否在参数表示的时间的前/后面
        Instant instant4 = Instant.ofEpochMilli(0L);
        Instant instant5 = Instant.ofEpochMilli(1L);
        boolean result1 = instant4.isBefore(instant5);
        boolean result2 = instant4.isAfter(instant5);
        System.out.println(result1);//true
        System.out.println(result2);//false

        //5.减少时间的系列方法
        Instant instant7 = Instant.ofEpochSecond(3L);
        Instant instant8 = instant7.minusSeconds(1);
        System.out.println(instant8);//1970-01-01T00:00:02Z
    }
}

ZoneDateTime：带时区的时间

import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;

public class ZoneDateTimeDemo {
    public static void main(String[] args) {
        //1.获取当前时间对象（带时区）
        ZonedDateTime now =  ZonedDateTime.now();
        System.out.println(now);//2025-09-16T17:22:55.420667200+08:00[GMT+08:00]

        //2.获取指定的时间对象（带时区）
        ZonedDateTime time1 = ZonedDateTime.of(2025,9,7,11,12,12,0, ZoneId.of("Asia/Shanghai"));
        System.out.println(time1);//2025-09-07T11:12:12+08:00[Asia/Shanghai]

        //通过Instant + 时区的方式指定获取时间对象
        Instant instant = Instant.ofEpochMilli(0L);
        ZoneId zoneId = ZoneId.of("Asia/Shanghai");
        ZonedDateTime time2 = ZonedDateTime.ofInstant(instant, zoneId);
        System.out.println(time2);//1970-01-01T08:00+08:00[Asia/Shanghai]

        //3.withXxx 修改时间的系列方法
        ZonedDateTime time3 = time2.withYear(2025);
        System.out.println(time3);//2025-01-01T08:00+08:00[Asia/Shanghai]

        //4.减少时间的系列方法
        ZonedDateTime time4 = time3.minusYears(1);
        System.out.println(time4);//2024-01-01T08:00+08:00[Asia/Shanghai]
        //5.增加时间的系列方法
        ZonedDateTime time5 = time4.plusYears(1);
        System.out.println(time5);//2025-01-01T08:00+08:00[Asia/Shanghai]


        //JDK8的时间对象不可变
    }
}

DateTimeFormatter类

用于时间的格式化和解析

import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;

public class DateTimeFormatterDemo {
    public static void main(String[] args) {
        //获取时间对象

        ZonedDateTime time1 = Instant.now().atZone(ZoneId.of("Asia/Shanghai"));
        //等价于ZonedDateTime time = ZonedDateTime.now();

        //解析/格式化器
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss EE a");
        //格式化
        System.out.println(dtf.format(time1));
    }
}

日历类

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;

public class LocalDateTimeDemo {
    public static void main(String[] args) {
        // 当前时间的的日历对象(包含年月日时分秒)
        LocalDateTime nowDateTime = LocalDateTime.now();

        System.out.println("今天是:" + nowDateTime);//今天是：2025-09-18T16:23:31.636172900
        System.out.println(nowDateTime.getYear());//年 2025
        System.out.println(nowDateTime.getMonthValue());//月 9
        System.out.println(nowDateTime.getDayOfMonth());//日 18
        System.out.println(nowDateTime.getHour());//时  16
        System.out.println(nowDateTime.getMinute());//分 23
        System.out.println(nowDateTime.getSecond());//秒 31
        System.out.println(nowDateTime.getNano());//纳秒 636172900
        // 日:当年的第几天
        System.out.println("dayOfYear:" + nowDateTime.getDayOfYear());//261
        //星期
        System.out.println(nowDateTime.getDayOfWeek()); // THURSDAY
        System.out.println(nowDateTime.getDayOfWeek().getValue()); //4
        //月份
        System.out.println(nowDateTime.getMonth()); //SEPTEMBER
        System.out.println(nowDateTime.getMonth().getValue()); //9

        LocalDate ld = nowDateTime.toLocalDate();
        System.out.println(ld);

        LocalTime lt = nowDateTime.toLocalTime();
        System.out.println(lt.getHour());
        System.out.println(lt.getMinute());
        System.out.println(lt.getSecond());
    }

}

工具类

也可看做周期与间隔工具类,用于计算日期时间之间的差值，替代传统的手动计算方式。
Period（日期间隔，年月日级）
  计算两个 LocalDate 之间的差值（年、月、日）
Duration（时间间隔，时分秒级）
  计算两个时间对象（如 LocalTime、Instant）之间的差值（时、分、秒）

ChronoUnit 是 JDK 8 中 java.time.temporal 包下的一个枚举类，它表示时间单位（如年、月、日、时等），主要用于日期时间的计算和比较。它是 java.time 日期时间 API 的重要组成部分，提供了统一的时间单位操作接口。
ChronoUnit 的主要作用是：

• 在日期时间对象之间计算差值（如两个日期相差多少天）
• 对日期时间对象进行加减操作（如给日期加 3 个月）
• 作为时间单位的标准化表示，替代传统的 Calendar 常量

import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;

public class ChronoUnitDemo {
    public static void main(String[] args) {
        //本地日期时间对象
        LocalDateTime today = LocalDateTime.now();
        System.out.println(today);

        //出生的日期时间对象
        LocalDateTime birthDate = LocalDateTime.of(2000,1,1,
                0,0,0);
        System.out.println(birthDate);


        System.out.println("相差的年数：" + ChronoUnit.YEARS.between(birthDate,today));
        System.out.println("相差的月数：" + ChronoUnit.MONTHS.between(birthDate,today));
        System.out.println("相差的周数：" + ChronoUnit.WEEKS.between(birthDate,today));
        System.out.println("相差的天数：" + ChronoUnit.DAYS.between(birthDate,today));
        System.out.println("相差的时数：" + ChronoUnit.HOURS.between(birthDate,today));
        System.out.println("相差的分数：" + ChronoUnit.MINUTES.between(birthDate,today));
        System.out.println("相差的秒数：" + ChronoUnit.SECONDS.between(birthDate,today));
        System.out.println("相差的毫秒数：" + ChronoUnit.MILLIS.between(birthDate,today));
        System.out.println("相差的微秒数：" + ChronoUnit.MICROS.between(birthDate,today));
        System.out.println("相差的纳秒数：" + ChronoUnit.NANOS.between(birthDate,today));
        System.out.println("相差的半天数：" + ChronoUnit.HALF_DAYS.between(birthDate,today));
        System.out.println("相差的十年数：" + ChronoUnit.DECADES.between(birthDate,today));
        System.out.println("相差的世纪数：" + ChronoUnit.CENTURIES.between(birthDate,today));
        System.out.println("相差的千年数：" + ChronoUnit.MILLENNIA.between(birthDate,today));
        System.out.println("相差的纪元数：" + ChronoUnit.ERAS.between(birthDate,today));

    }
}

三、包装类

在 Java 中，包装类是为了解决基本数据类型无法直接参与面向对象编程而设计的类。它们将基本数据类型 “包装” 成对象，使其具备对象的特性。

自动装箱与拆箱（Auto-Boxing/Unboxing）
JDK 5 引入的特性，允许基本数据类型与包装类之间自动转换，简化代码：

• 自动装箱：基本数据类型 → 包装类对象（如 int → Integer）
• 自动拆箱：包装类对象 → 基本数据类型（如 Integer → int）

public class IntegerDemo1 {
    public static void main(String[] args) {
//        //1.利用构造方法获取Integer的对象（JDK5以前的方式）
//        Integer i1 = new Integer(1);
//        Integer i2 = new Integer("1");
        //2.利用静态方法获取Integer的对象（JDK5以前的方式）
        Integer i3 = Integer.valueOf(123);
        Integer i4 = Integer.valueOf("123");
        Integer i5 = Integer.valueOf("123",8);
        System.out.println(i3);//123
        System.out.println(i4);//123
        System.out.println(i5);//83

        //-128~127 默认创建
        Integer i6 = Integer.valueOf(127);
        Integer i7 = Integer.valueOf(127);
        System.out.println(i6 == i7);//true

        Integer i8 = Integer.valueOf(128);
        Integer i9 = Integer.valueOf(128);
        System.out.println(i8 == i9);//false

        Integer i10 = 10;
        Integer i11 = i10 + 10;
        int i = i11;
        System.out.println(i);//20

    }
}

例：Integer成员方法

public class IntegerDemo2 {
    public static void main(String[] args) {
        //二进制
        String str1 = Integer.toBinaryString(100);
        System.out.println(str1);//1100100

        //八进制
        String str2 = Integer.toOctalString(100);
        System.out.println(str2);//144

        //十六进制
        String str3 = Integer.toHexString(100);
        System.out.println(str3);//64

        //将字符串转为整形 括号里只能是数字
        int i = Integer.parseInt("123");
        System.out.println(i + 12);//135

        //八种包装类，除了Character都有对于的parseXxx的方法进行类型转换
        String str = "true";
        boolean b = Boolean.parseBoolean(str);
        System.out.println(b);//true

    }
}