目录

  • API 概述
  • Scanner 类（键盘录入字符串）
  • Math 类
  • System 类
  • Object 类
  • toString 方法
  • equals 方法
  • hashCode 方法
  • Objects 类
  • BigDecimal 类
  • 包装类
  • 基本数据类型的包装类
  • 自动拆箱和自动装箱
  • 包装类的比较
  • 工具类的设计思想
  • 日期时间类
  • Date 类
  • SimpleDateFormat 类
  • JDK8 日期时间类
  • LocalDateTime 类
  • LocalDateTime 创建方法
  • LocalDateTime 获取方法
  • LocalDateTime 转换方法
  • LocalDateTime 格式化和解析
  • LocalDateTime 增加时间的方法
  • LocalDateTime 减少时间的方法
  • LocalDateTime 修改方法
  • Period 类
  • Duration 类


API 概述

API（Application Programming Interface）：应用程序编程接口

Java 中的 API：指的就是 JDK 中提供的各种功能的 Java 类。这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要知道这些类如何使用即可。我们可以通过 API 帮助文档来学习这些 API 如何使用。

API 在线官方文档

如何使用 API 帮助文档 :

  1. 打开帮助文档
  2. 找到索引选项卡中的输入框
  3. 在输入框中输入 API，如 Random
  4. 看类在哪个包下
  5. 看类的描述
  6. 看构造方法
  7. 看成员方法

Scanner 类（键盘录入字符串）

常用方法：

  • nextInt()：仅接收整数数据，其结束标记：回车换行符
  • next()：接收数据不限类型，其结束标记：空格、tab 键
  • nextLine()：接收数据不限类型，其结束标记：回车换行符
import java.util.Scanner;

public class DemoScanner {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入整数：");
        int num = sc.nextInt();
        System.out.println("请输入字符串：");
        String s = sc.nextLine();

        System.out.println(num);
        System.out.println(s);
    }
}


Math 类

Math 类包含了执行基本数字运算的方法。

Math 类中无构造方法，但内部的方法都是静态的，因此可以通过类名.静态方法进行调用。

Math 类的常用方法：

方法名

说明

public static int abs(int a)

返回参数的绝对值

public static double ceil(double a)

向上取整，返回 double 类型

public static double floor(double a)

向下取整，返回 double 类型

public static int 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)


System 类

System 类的常用方法：

方法名

说明

public static void exit(int status)

终止当前运行的 JVM，非零参数表示异常终止

public static long currentTimeMillis()

返回当前时间（以毫秒为单位）

public static int identityHashCode(Object o)

返回对象 o 的内存地址，不管该对象的类是否重写了 hashCode() 方法

示例代码：在控制台输出 1-10000，计算这段代码执行了多少毫秒。

public class SystemDemo {
    public static void main(String[] args) {
        // 获取开始的时间节点
        long start = System.currentTimeMillis();
        for (int i = 1; i <= 10000; i++) {
            System.out.println(i);
        }
        // 获取代码运行结束后的时间节点
        long end = System.currentTimeMillis();
        System.out.println("共耗时：" + (end - start) + "毫秒");
    }
}


Object 类

Object 概述：Object 是类的层次结构的根，每个类都可以将 Object 作为超类，即所有类都直接或者间接的继承自该类。换句话说，该类所具备的方法，所有类都会有一份。

查看方法源码的方式：选中方法，按下Ctrl + B

常用方法：

方法名

说明

public String toString()

返回对象的字符串表示形式。建议所有子类重写该方法。（IDEA 可自动生成打印所有成员变量的重写方法）

public boolean equals(Object)

比较对象地址是否相同。默认比较地址，重写可以比较内容。（IDEA 可自动生成比较内容的重写方法）

public static int hasCode(Object)

该方法返回对象的哈希码。但是 hashCode() 可以重写，所以 hashCode() 不同不一定就代表内存地址不同。

而 System.identityHashCode(对象) 方法可以返回对象的内存地址，不管该对象的类是否重写了 hashCode() 方法


toString 方法

toString 方法的作用：返回对象的字符串表示形式。

自动重写 toString 方法的方式：

  • Alt + Insert 选择 toString
  • 在类的空白区域，右键 -> Generate -> 选择 toString

代码示例：

class Student extends Object {
    private String name;
    private int age;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

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

public class ObjectDemo {
    public static void main(String[] args) {
        Student s = new Student();
        s.setName("林青霞");
        s.setAge(30);
        System.out.println(s);  // Student{name='林青霞', age=30}
        System.out.println(s.toString());  // Student{name='林青霞', age=30}
    }
}


equals 方法

equals 方法的作用：比较对象地址是否相同。默认比较地址，重写可以比较内容。

equals 与 == 的区别：

  • ==：比较基本数据类型时，比较的是具体的值；比较引用数据类型时，比较的是对象地址。
  • 字符串对象的equals(String s)：比较两个字符串的内容是否一致。

Java开发api接口实例 java实现api接口_字符串

  • == 比较的是变量（栈）内存中存放的对象的（堆）内存地址，用来判断两个对象的地址是否相同，即是否是指相同一个对象，比较的是真正意义上的指针操作；而 equals() 常用来比较两个字符串对象的内容是否一致。
  • 由于所有的类都是继承自 java.lang.Object 类的，所以适用于所有对象，如果没有对该方法进行覆盖的话，调用的仍然是 Object 类中的方法，而 Object 中的 equals 方法返回的却是 == 的判断。
  • String s = "abcd" 是一种非常特殊的形式，和 new 有本质的区别。它是 java 中唯一不需要 new 就可以产生对象的途径。
  • 以 String s="abcd" 形式的赋值在 java 中叫直接量，它是在常量池中而不是像 new 一样放在堆中。这种形式的字符串，会在 JVM 内部发生字符串拘留，即当声明这样的一个字符串后，JVM 会在常量池中先查找有没有一个值为 "abcd" 的对象，如果有，就会把它赋给当前引用，即原来那个引用和现在这个引用指点向了同一对象；如果没有，则在常量池中新创建一个"abcd"，下一次如果有 String s1 = "abcd" 又会将 s1 指向 "abcd" 这个对象。
  • 即以这形式声明的字符串，只要值相等，任何多个引用都指向同一对象。
  • 而 String s = new String("abcd") 和其它任何对象一样，每调用一次就产生一个对象，只要它们调用。
  • 也可以这么理解: String str = "hello" 会先在内存中找是不是有 "hello" 这个对象，如果有，就让 str 指向那个 "hello" ；如果内存里没有 "hello" ，就创建一个新的对象保存 "hello" 。
  • 而 String str=new String ("hello") 就是不管内存里是不是已经有 "hello" 这个对象，都新建一个对象保存 "hello" 。

自动重写 equals 方法的方式：

  • 方式一：alt + insert 选择 equals() and hashCode()，IntelliJ Default，一路 next，finish 即可。
  • 方式二：在类的空白区域，右键 -> Generate -> 选择 equals() and hashCode()，后面的同上。

自动重写完 equals 方法后，即可比较字符串内容。

示例：

class Student {

    private String name;
    private int age;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    @Override
    public boolean equals(Object o) {
        // this -- s1
        // o -- s2
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;  // student -- s2

        if (age != student.age) return false;
        return name != null ? name.equals(student.name) : student.name == null;
    }
}

public class ObjectDemo {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("林青霞");
        s1.setAge(30);

        Student s2 = new Student();
        s2.setName("林青霞");
        s2.setAge(30);

        // 需求：比较两个对象的内容是否相同
        System.out.println(s1.equals(s2));
    }
}

思考题：

public class Test {
    public static void main(String[] args) {
        String s1 = "abc";
        StringBuilder sb = new StringBuilder("abc");

        // 调用的是 String 类中的 equals 方法，其首先会判断传入的对象是否是字符串类型
        // sb 需要先转成 String 类，否则还没有比较内容就直接返回 false
        System.out.println(s1.equals(sb));  // false

        // StringBuilder 类中也没有重写 equals 方法，用的是 Object 类的，故比较的是对象地址
        System.out.println(sb.equals(s1));  // false
    }
}


hashCode 方法

hashCode() 的作用是获取哈希码，也称为散列码。它实际上是返回一个 int 整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。

hashCode() 定义在 JDK 的 Object.java 中，这就意味着 Java 中的任何类都包含有 hashCode() 函数。虽然每个 Java 类都包含 hashCode() 函数。但是仅当创建某个“类”的散列表时，该类的 hashCode() 才有用。

更通俗地说就是创建包含该类的 HashMap、Hashtable、HashSet 集合时， hashCode() 才有用，因为 HashMap、Hashtable、HashSet 才是散列表集合。

在散列表中，hashCode() 作用是确定该类的每一个对象在散列表中的位置，其它情况下类的 hashCode() 没有作用。

Java 中的规范：一般重写了一个类的 equals 方法后，都会重写它的 hashCode 方法。

综合示例：

class Person{

     int id;
     String name;

     public Person(int id, String name){
          this.id = id;
          this.name = name;
     }

     public Person(){
     }

     //toString():
     //目前需要直接输出一个对象的时候，输出的格式为：编号：... 姓名：...
     //目前Object的toString方法无法满足子类的需求，因此需要重写子类的toString方法。
     public String toString(){
          return "编号："+this.id+" 姓名："+this.name;
     }

     //equals():     
     //Object的equals方法默认是比较两个对象的内存地址，目前需要比较的是两个对象的ID，所以需要重写Object的equals方法。
     public boolean equals(Object obj){ //多态，指向的是Person对象
          Person p = (Person) obj;  //id是Person子类独有的成员，因此需要强制类型转换
          return this.id == p.id; //调用对象的id与实参id的比较
          // 等于：return this.id == ((Person)obj).id;
     }

     //hashCode():
     //java中的规范：一般重写了一个类的equals方法后，都会重写它的hashCode方法。
     public int hashCode(){
          return this.id;
     }
}

public class Test {

     public static void main(String[] args) {

     Person p = new Person(110,"狗娃");
     System.out.println(p); //本来输出完整类名+@+对象的哈希码
                            //重写后现输出 编号：110 姓名：狗娃

     Person p1 = new Person(110,"狗娃");
     Person p2 = new Person(110,"陈大富");
     //需求：在现实中只要两个人的身份证一致，那么就是同一个人
     System.out.println("P1与P2是同一个人吗？"+p1.equals(p2));  //重写equals后比较的是id，true

     System.out.println("P1的哈希码:"+p1.hashCode());  //本来为不同的哈希码
     System.out.println("P2的哈希码:"+p2.hashCode());  //重写后为相同的哈希码
     }
}


Objects 类

常用方法：

方法名

说明

public static String toString(对象)

返回参数中对象的字符串表示形式

public static String toString(对象, 默认字符串)

返回对象的字符串表示形式。如果对象为空，则返回默认字符串

public static Boolean isNull(对象)

判断对象是否为空

public static Boolean nonNull(对象)

判断对象是否不为空


BigDecimal 类

作用：可以用来进行精确计算。

构造方法：

方法名

说明

BigDecimal(double val)

参数为 double

BigDecimal(String val)

参数为 String

常用方法：

方法名

说明

public BigDecimal add(另一个 BigDecimal 对象)

加法

public BigDecimal subtract(另一个 BigDecimal 对象)

减法

public BigDecimal multiply(另一个 BigDecimal 对象)

乘法

public BigDecimal divide(另一个 BigDecimal 对象)

除法

public BigDecimal divide(另一个 BigDecimal 对象，精确几位，舍入模式)

除法

总结：

  • 创建 BigDecimal 的对象，构造方法使用参数类型为字符串的。
  • 四则运算中的除法，如果除不尽则使用 divide 的三个参数的方法。

BigDecimal divide = bd1.divide(参与运算的对象, 小数点后精确到多少位, 舍入模式);

  • 参数 1：表示参与运算的 BigDecimal 对象。
  • 参数 2：表示小数点后面精确到多少位。
  • 参数 3：舍入模式：
  • BigDecimal.ROUND_UP：进一法
  • BigDecimal.ROUND_FLOOR：去尾法
  • BigDecimal.ROUND_HALF_UP：四舍五入


包装类

基本数据类型的包装类

基本数据类型包装类的作用：

  • 将基本数据类型封装成对象的好处在于，可以在对象中定义更多的功能方法操作该数据。
  • 常用的操作之一：用于基本数据类型与字符串之间的转换。

基本数据类型对应的包装类：

基本数据类型

包装类

byte

Byte

short

Short

int

Integer

long

Long

float

Float

double

Double

char

Character

boolean

Boolean

示例：

// 把字符串转换成int类型
    String str = "12";
    int a = Integer.parseInt(str);
    System.out.println(a);

    // 把数字转换成字符串
    System.out.println(Integer.toString(a));

    // 把整数转换成对应的进制形式
    System.out.println(Integer.toBinaryString(2));  // 转化为二进制
    System.out.println(Integer.toOctalString(10));  // 转化为八进制
    System.out.println(Integer.toHexString(10));    // 转化为十六进制

    // 可以把字符串当成对应的进制数据
    String data = "10";
    Integer.parseInt(data, 2);  // 把十进制的数据转化成二进制
    Integer.parseInt(data, 36);  // 最高能转化成36进制

示例：Integer 类缓冲数组

Integer 类内部维护了一个缓冲数组，该缓冲数组存储的 -128 到 127 这些数据在一个数组中。如果需要获取的数据在这个范围之内，那么就直接从该缓冲区中获取。

// 引用的数据类型
   Integer e = 129;
   Integer f = 129;
   System.out.println("a与b是同一个对象吗？"+(a==b));  // false
   // 若两者都在-127至128内，结果则为 true


自动拆箱和自动装箱

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

示例：

Integer i = 100;  // 自动装箱
    i += 200;  // i += 200 是自动拆箱；i = i + 200 是自动装箱

    // 集合只能存储对象类型，而 1、2、3 是基本数据类型，若在 JDK1.5 之前会报错
    ArrayList list = new ArrayList();
    list.add(1);
    list.add(2);
    list.add(3);
    // JDK1.5 之前需要写成 list.add(new Integer(1));

    // 自动拆箱
    Integer c = new Integer(3);  // 等价于 Integer c = Integer.valueOf(3);
    int b = c;  // 等价于 int b = c.intValue();
    // JDK1.5 之前需要写成 int b = c.intValue();


包装类的比较

包装类的 == 和 equals() 比较：

Integer i1 = 4000;
Integer i2 = new Integer(4000);

System.out.println(i1==i2);  // false
// 原因：
// Integer i1 = 40 这一行代码会发生装箱，也就是说这行代码等价于 Integer i1 = Integer.valueOf(40)
// 而 Integer i2 = new Integer(40) 会直接创建新的对象

System.out.println(i1.equals(i2));  // true
// 原因：equals()首先会比较类型，如果类型相同，则继续比较值，如果值也相同，返回true


工具类的设计思想

  • 构造方法用 private 修饰（无法 new 新对象）。
  • 成员用 public static 修饰（直接通过类名访问静态方法）。


日期时间类

Date 类

  • 计算机中时间原点：1970 年 1 月 1 日 00:00:00
  • Date 概述：Date 代表了一个特定时间（精确到毫秒）的对象。
  • Date 类构造方法：

方法名

说明

public Date()

当前时间

public Date(long time)

时间原点+传入的时间长度（毫秒）

import java.util.Date;

public class Test {

    public static void main(String[] args) {
        Date d1 = new Date();
        System.out.println(d1);  // Tue Sep 21 00:29:28 CST 2021
        
        long date = 1000*60*60;
        Date d2 = new Date(date);
        System.out.println(d2);  // Thu Jan 01 09:00:00 CST 1970
    }
}

Date 常用方法：

方法名

说明

public long getTime()

从 1970年1月1日 00:00:00 到现在的毫秒值

public void setTime(long time)

设置时间，给的是毫秒值

import java.util.Date;

public class Test{
    public static void main(String[] args) {
        //创建日期对象
        Date d = new Date();

        // public long getTime():获取的是日期对象从 1970年1月1日 00:00:00 到现在的毫秒值
        System.out.println(d.getTime());  // 1632155655406

        // public void setTime(long time):设置时间，给的是毫秒值
        long time = System.currentTimeMillis();
        d.setTime(time);
        System.out.println(d);  // Tue Sep 21 00:34:15 CST 2021
    }
}


SimpleDateFormat 类

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

SimpleDateFormat 类的构造方法：

方法名

说明

public SimpleDateFormat()

构造一个 SimpleDateFormat，使用默认模式和日期格式

public SimpleDateFormat(String pattern)

构造一个 SimpleDateFormat，使用给定的模式和默认的日期格式

SimpleDateFormat 类的常用方法：

方法名

说明

public final String format(Date date)

将日期对象格式化成日期/时间格式的字符串对象

public Date parse(String source)

将日期/时间格式的字符串对象解析成日期对象

代码示例：

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

public class Test {

    public static void main(String[] args) throws ParseException {
        // 格式化：从 Date 到 String
        Date d = new Date();
        // SimpleDateFormat sdf = new SimpleDateFormat();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        String s = sdf.format(d);
        System.out.println(s);  // 2021年09月21日 00:41:33
        System.out.println("--------");

        // 从 String 到 Date
        String ss = "2048-08-09 11:11:11";
        // ParseException
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date dd = sdf2.parse(ss);
        System.out.println(dd);  // Sun Aug 09 11:11:11 CST 2048
    }
}


JDK8 日期时间类

JDK8 新增的日期时间类：

  • LocalDate：表示日期（年月日）
  • LocalTime：表示时间（时分秒）
  • LocalDateTime：表示时间+日期（年月日时分秒）

LocalDateTime 类

LocalDateTime 创建方法

方法名

说明

public static LocalDateTime now()

获取当前系统时间

public static LocalDateTime of (年, 月 , 日, 时, 分, 秒)

使用指定年月日和时分秒初始化一个 LocalDateTime 对象

代码示例：

import java.time.LocalDateTime;

public class Test {

    public static void main(String[] args) {
        LocalDateTime now = LocalDateTime.now();
        System.out.println(now);  // 2021-09-21T00:51:38.077

        LocalDateTime localDateTime = LocalDateTime.of(2020, 11, 11, 11, 11, 11);
        System.out.println(localDateTime);  // 2020-11-11T11:11:11
    }
}

LocalDateTime 获取方法

方法名

说明

public int getYear()

获取年

public int getMonthValue()

获取月份（1-12）

public int getDayOfMonth()

获取月份中的第几天（1-31）

public int getDayOfYear()

获取一年中的第几天（1-366）

public DayOfWeek getDayOfWeek()

获取星期

public int getMinute()

获取分钟

public int getHour()

获取小时

代码示例：

import java.time.DayOfWeek;
import java.time.LocalDateTime;
import java.time.Month;

public class Test {
    public static void main(String[] args) {
        LocalDateTime localDateTime = LocalDateTime.of(2020, 11, 11, 11, 11, 20);

        // public int getYear()：获取年
        int year = localDateTime.getYear();
        System.out.println("年为" +year);  // 2020

        // public int getMonthValue()：获取月份（1-12）
        int month = localDateTime.getMonthValue();
        System.out.println("月份为" + month);  // 11

        Month month1 = localDateTime.getMonth();
        System.out.println(month1);  // NOVEMBER

        // public int getDayOfMonth()：获取月份中的第几天（1-31）
        int day = localDateTime.getDayOfMonth();
        System.out.println("日期为" + day);  // 11

        // public int getDayOfYear()：获取一年中的第几天（1-366）
        int dayOfYear = localDateTime.getDayOfYear();
        System.out.println("这是一年中的第" + dayOfYear + "天");  // 316

        // public DayOfWeek getDayOfWeek()：获取星期
        DayOfWeek dayOfWeek = localDateTime.getDayOfWeek();
        System.out.println("星期为" + dayOfWeek);  // WEDNESDAY

        // public int getMinute()：获取分钟
        int minute = localDateTime.getMinute();
        System.out.println("分钟为" + minute);  // 11
        
        // public int getHour()：获取小时
        int hour = localDateTime.getHour();
        System.out.println("小时为" + hour);  // 11
    }
}

LocalDateTime 转换方法

方法名

说明

public LocalDate toLocalDate()

转换成为一个 LocalDate 对象

public LocalTime toLocalTime()

转换成为一个 LocalTime 对象

代码示例：

import java.time.*;

public class Test {
    public static void main(String[] args) {
        LocalDateTime localDateTime = LocalDateTime.of(2020, 12, 12, 8, 10, 12);

        // public LocalDate toLocalDate()：转换成为一个 LocalDate 对象
        LocalDate localDate = localDateTime.toLocalDate();
        System.out.println(localDate);  // 2020-12-12

        // public LocalTime toLocalTime()：转换成为一个 LocalTime 对象
        LocalTime localTime = localDateTime.toLocalTime();
        System.out.println(localTime);  // 08:10:12

    }
}

LocalDateTime 格式化和解析

方法名

说明

public String format (指定格式)

把一个 LocalDateTime 格式化成为一个字符串

public LocalDateTime parse (准备解析的字符串, 解析格式)

把一个日期字符串解析成为一个 LocalDateTime 对象

public static DateTimeFormatter ofPattern(String pattern)

使用指定的日期模板获取一个日期格式化器 DateTimeFormatter 对象

代码示例：

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class Test {
    public static void main(String[] args) {
        method1();
        method2();
    }

    private static void method2() {
        //public static LocalDateTime parse (准备解析的字符串, 解析格式)：把一个日期字符串解析成为一个LocalDateTime对象
        String s = "2020年11月12日 13:14:15";
        DateTimeFormatter pattern = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");
        LocalDateTime parse = LocalDateTime.parse(s, pattern);
        System.out.println(parse);  // 2020-11-12T13:14:15
    }

    private static void method1() {
        LocalDateTime localDateTime = LocalDateTime.of(2020, 11, 12, 13, 14, 15);
        System.out.println(localDateTime);  // 2020-11-12T13:14:15
        //public String format (指定格式)：把一个LocalDateTime格式化成为一个字符串
        DateTimeFormatter pattern = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");
        String s = localDateTime.format(pattern);
        System.out.println(s);  // 2020年11月12日 13:14:15
    }
}

LocalDateTime 增加时间的方法

方法名

说明

public LocalDateTime plusYears (long years)

增加年

public LocalDateTime plusMonths(long months)

增加月

public LocalDateTime plusDays(long days)

增加日

public LocalDateTime plusHours(long hours)

增加时

public LocalDateTime plusMinutes(long minutes)

增加分

public LocalDateTime plusSeconds(long seconds)

增加秒

public LocalDateTime plusWeeks(long weeks)

增加周

代码示例：

import java.time.LocalDateTime;

public class Test {
    public static void main(String[] args) {
        LocalDateTime localDateTime = LocalDateTime.of(2020, 11, 11, 13, 14, 15);
        
        // public LocalDateTime plusYears (long years)：添加或者减去年
        LocalDateTime newLocalDateTime = localDateTime.plusYears(1);
        System.out.println(newLocalDateTime);  // 2021-11-11T13:14:15

        LocalDateTime newLocalDateTime2 = localDateTime.plusYears(-1);
        System.out.println(newLocalDateTime2);  // 2019-11-11T13:14:15
    }
}

LocalDateTime 减少时间的方法

方法名

说明

public LocalDateTime minusYears (long years)

减去年

public LocalDateTime minusMonths(long months)

减去月

public LocalDateTime minusDays(long days)

减去日

public LocalDateTime minusHours(long hours)

减去时

public LocalDateTime minusMinutes(long minutes)

减去分

public LocalDateTime minusSeconds(long seconds)

减去秒

public LocalDateTime minusWeeks(long weeks)

减去周

代码示例：

import java.time.LocalDateTime;

public class Test {
    public static void main(String[] args) {
        LocalDateTime localDateTime = LocalDateTime.of(2020, 11, 11, 13, 14, 15);

        // public LocalDateTime minusYears (long years)：减去年
        LocalDateTime newLocalDateTime = localDateTime.minusYears(1);
        System.out.println(newLocalDateTime);  // 2019-11-11T13:14:15

        LocalDateTime newLocalDateTime2 = localDateTime.minusYears(-1);
        System.out.println(newLocalDateTime2);  // 2021-11-11T13:14:15
    }
}

LocalDateTime 修改方法

方法名

说明

public LocalDateTime withYear(int year)

直接修改年

public LocalDateTime withMonth(int month)

直接修改月

public LocalDateTime withDayOfMonth(int dayofmonth)

直接修改日期（一个月中的第几天）

public LocalDateTime withDayOfYear(int dayOfYear)

直接修改日期（一年中的第几天）

public LocalDateTime withHour(int hour)

直接修改小时

public LocalDateTime withMinute(int minute)

直接修改分钟

public LocalDateTime withSecond(int second)

直接修改秒

代码示例：

import java.time.LocalDateTime;

public class Test {
    public static void main(String[] args) {

        LocalDateTime localDateTime = LocalDateTime.of(2020, 11, 11, 13, 14, 15);
        // 修改年
        LocalDateTime newLocalDateTime = localDateTime.withYear(2048);  // 2048-11-11T13:14:15
        System.out.println(newLocalDateTime);
        // 修改月
        LocalDateTime newLocalDateTime2 = localDateTime.withMonth(2);  // 2020-02-11T13:14:15
        System.out.println(newLocalDateTime2);

    }
}


Period 类

方法名

说明

public static Period between(开始时间, 结束时间)

计算两个“时间"的间隔

public int getYears()

获得这段时间的年数

public int getMonths()

获得此期间的总月数

public int getDays()

获得此期间的天数

public long toTotalMonths()

获取此期间的总月数

代码示例：

import java.time.LocalDate;
import java.time.Period;

public class Test {
    public static void main(String[] args) {

        LocalDate localDate1 = LocalDate.of(2020, 1, 1);
        LocalDate localDate2 = LocalDate.of(2048, 12, 12);
        
        // public static Period between(开始时间, 结束时间)：计算两个"时间"的间隔
        Period period = Period.between(localDate1, localDate2);
        System.out.println(period);  // P28Y11M11D 表示相差28年11个月11天

        //public int getYears()：获得这段时间的年数
        System.out.println(period.getYears());  // 28
        //public int getMonths()：获得此期间的月数
        System.out.println(period.getMonths());  // 11
        //public int getDays()：获得此期间的天数
        System.out.println(period.getDays());  // 11
        //public long toTotalMonths()：获取此期间的总月数
        System.out.println(period.toTotalMonths());  // 347

    }
}


Duration 类

方法名

说明

public static Durationbetween(开始时间, 结束时间)

计算两个“时间"的间隔

public long toSeconds()

获得此时间间隔的秒

public int toMillis()

获得此时间间隔的毫秒

public int toNanos()

获得此时间间隔的纳秒

代码示例：

import java.time.Duration;
import java.time.LocalDateTime;

public class Test {
    public static void main(String[] args) {

        LocalDateTime localDateTime1 = LocalDateTime.of(2020, 1, 1, 13, 14, 15);
        LocalDateTime localDateTime2 = LocalDateTime.of(2020, 1, 2, 11, 12, 13);

        // public static Duration between(开始时间,结束时间)  计算两个“时间”的间隔
        Duration duration = Duration.between(localDateTime1, localDateTime2);
        System.out.println(duration);  // PT21H57M58S

        // public int toMillis()：获得此时间间隔的毫秒
        System.out.println(duration.toMillis());  // 79078000
        // public int toNanos()：获得此时间间隔的纳秒
        System.out.println(duration.toNanos());  // 79078000000000

    }
}
~~