Java进阶-常用API
本文章参考B站 Java入门基础视频教程，java零基础自学首选黑马程序员Java入门教程（含Java项目和Java真题），仅供个人学习使用，部分内容为本人自己见解，与黑马程序员无关。
1、常用 API
什么是API
- API(Application Programming interface) 应用程序编程接口。
- 简单来说：就是Java帮我们已经写好的一些方法，我们直接拿过来用就可以了。
1.1、Object
Object类的作用
- Object类的方法是一切子类对象都可以直接使用的，所以我们要学习Object类的方法。
- 一个类要么默认继承了Object类，要么间接继承了Object类，Object类是Java中的祖宗类。
Object类的常用方法
方法名
说明
public String toString()
默认是返回当前对象在堆内存中的地址信息:类的全限名@内存地址
public boolean equals(Object o)
默认是比较当前对象与另一个对象的地址是否相同，相同返回true，不同返回false
1.1.1、toString 方法
代码展示
import java.util.Objects;
public class Student { //extends Object{
private String name;
private char sex;
private int age;
public Student() {
}
public Student(String name, char sex, int age) {
this.name = name;
this.sex = sex;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
/**
目标：掌握Object类中toString方法的使用。
*/
public class Test1 {
public static void main(String[] args) {
Student s = new Student("周雄", '男', 19);
// String rs = s.toString();
// System.out.println(rs);
// System.out.println(s.toString());
// 直接输出对象变量，默认可以省略toString调用不写的
System.out.println(s);
}
}
输出结果
com.itheima.d9_api_object.Student@1b6d3586
问题引出
- 开发中直接输出对象，默认输出对象的地址其实是毫无意义的。
- 开发中输出对象变量，更多的时候是希望看到对象的内容数据而不是对象的地址信息。
toString() 存在的意义
-
toString 方法本身是无意义的
-
父类 toString 方法存在的意义就是为了被子类重写，以便返回对象的内容信息，而不是地址信息！！
代码改进
Student 类重写 toString 方法
@Override
public String toString() {
return "Student{" +
"name='" + name + ''' +
", sex=" + sex +
", age=" + age +
'}';
}
输出结果
Student{name='周雄', sex=男, age=19}
1.1.2、equals 方法
代码展示
/**
目标：掌握Object类中equals方法的使用。
*/
public class Test2 {
public static void main(String[] args) {
Student s1 = new Student("周雄", '男', 19);
Student s2 = new Student("周雄", '男', 19);
// equals默认是比较2个对象的地址是否相同，子类重写后会调用子类重写的来比较内容是否相同。
System.out.println(s1.equals(s2));
System.out.println(s1 == s2);
System.out.println(Objects.equals(s1, s2));
}
}
输出结果
false
false
false
问题思考
- 直接比较两个对象的地址是否相同完全可以用 “==” 替代 equals。
equals 存在的意义
父类 equals 方法存在的意义就是为了被子类重写，以便子类自己来定制比较规则。
代码改进
Student 类中重写 equals 方法
/**
定制相等规则。
两个对象的内容一样就认为是相等的
s1.equals(s2)
比较者：s1 == this
被比较者： s2 ==> o
*/
@Override
public boolean equals(Object o) {
// 1、判断是否是同一个对象比较，如果是返回true。
if (this == o) return true;
// 2、如果o是null返回false 如果o不是学生类型返回false ...Student != ..Pig
if (o == null || this.getClass() != o.getClass()) return false;
// 3、说明o一定是学生类型而且不为null
Student student = (Student) o;
return sex == student.sex && age == student.age && Objects.equals(name, student.name);
}
输出结果
true
false
true
1.2、Objects
概述
- Objects 是一个工具类，提供了一些方法去完成一些功能。
常见方法
方法名
说明
public static boolean equals(Object a, Object b)
比较两个对象的，底层会先进行非空判断，从而可以避免空指针异常。再进行equals比较
public static boolean isNull(Object obj)
判断变量是否为null ,为null返回true ,反之
Object.equals 方法缺陷
- 空值用 equals 比较会出 Exception in thread “main” java.lang.NullPointerException
代码演示
import java.util.Objects;
/**
目标：掌握objects类的常用方法:equals
*/
public class Test {
public static void main(String[] args) {
String s1 = null;
String s2 = new String("itheima");
// System.out.println(s1.equals(s2)); // 留下了隐患，可能出现空指针异常。
System.out.println(Objects.equals(s1, s2)); // 更安全，结果也是对的！
/**
Objects：
public static boolean equals(Object a, Object b) {
return (a == b) || (a != null && a.equals(b));
}
*/
System.out.println(Objects.isNull(s1)); // true
System.out.println(s1 == null); // true
System.out.println(Objects.isNull(s2)); // false
System.out.println(s2 == null); // false
}
}
输出结果
false
true
true
false
false
对象进行内容比较的时候建议使用什么？为什么？
- 建议使用Objects提供的equals方法。
- 比较的结果是一样的，但是更安全。
源码分析
public static boolean equals(Object a, Object b) {
return (a == b) || (a != null && a.equals(b));
}
可以发现 equals 方法已经做了非空判断。
1.3、StringBuilder
StringBuilder 概述
- StringBuilder是一个可变的字符串类，我们可以把它看成是一个对象容器。
- 作用：提高字符串的操作效率，如拼接、修改等。
StringBuilder 构造器
名称
说明
public StringBuilder()
创建一个空白的可变的字符串对象，不包含任何内容
public StringBuilder(String str)
创建一个指定字符串内容的可变字符串对象
StringBuilder常用方法
方法名称
说明
public StringBuilder append(任意类型)
添加数据并返回StringBuilder对象本身
public StringBuilder reverse()
将对象的内容反转
public int length()
返回对象内容长度
public String toString()
通过toString()就可以实现把StringBuilder转换为String
代码展示
/**
目标：学会使用StringBuilder操作字符串,最终还需要知道它性能好的原因
*/
public class StringBuilderDemo1 {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder(); // ""
sb.append("a");
sb.append("b");
sb.append("c");
sb.append(1);
sb.append(false);
sb.append(3.3);
sb.append("abc");
System.out.println(sb);
StringBuilder sb1 = new StringBuilder();
// 支持链式编程
sb1.append("a").append("b").append("c").append("我爱你中国");
System.out.println(sb1);
// 反转
sb1.reverse().append("110");
System.out.println(sb1);
System.out.println(sb1.length());
// 注意：StringBuilder只是拼接字符串的手段：效率好。
// 最终的目的还是要恢复成String类型。
StringBuilder sb2 = new StringBuilder();
sb2.append("123").append("456");
// 恢复成String类型
String rs = sb2.toString();
check(rs);
}
public static void check(String data){
System.out.println(data);
}
}
输出结果
abc1false3.3abc
abc我爱你中国
国中你爱我cba110
11
123456
为什么拼接、反转字符串建议使用 StringBuilder
- String ：内容是不可变的、拼接字符串性能差。
- StringBuilder：内容是可变的、拼接字符串性能好、代码优雅。
- 定义字符串使用 String
- 拼接、修改等操作字符串使用 StringBuilder
原理展示
案例：打印整型数组内容
需求：
- 设计一个方法用于输出任意整型数组的内容，要求输出成如下格式：“该数组内容为：[11, 22, 33, 44, 55]”
分析：
- 定义一个方法，要求该方法能够接收数组，并输出数组内容。 —> 需要参数吗？需要返回值类型申明吗？
- 定义一个静态初始化的数组，调用该方法，并传入该数组。
代码展示
public class StringBuilderTest2 {
public static void main(String[] args) {
int[] arr1 = null;
System.out.println(toString(arr1));
int[] arr2 = {10, 88, 99};
System.out.println(toString(arr2));
int[] arr3 = {};
System.out.println(toString(arr3));
}
/**
1、定义方法接收任意整型数组，返回数组内容格式
*/
public static String toString(int[] arr){
if(arr != null){
// 2、开始拼接内容。
StringBuilder sb = new StringBuilder("[");
for (int i = 0; i < arr.length; i++) {
sb.append(arr[i] ).append(i == arr.length - 1 ? "" : ", ");
}
sb.append("]");
return sb.toString();
}else {
return null;
}
}
}
输出结果
null
[10, 88, 99]
[]
1.4、Math
Math类
- 包含执行基本数字运算的方法，Math类没有提供公开的构造器。
- 类的成员是否都是静态的，通过类名就可以直接调用。
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)
代码展示
/**
目标：Math类的使用。
Math用于做数学运算。
Math类中的方法全部是静态方法，直接用类名调用即可。
方法：
方法名 说明
public static int abs(int a) 获取参数a的绝对值：
public static double ceil(double a) 向上取整
public static double floor(double a) 向下取整
public static double pow(double a, double b) 获取a的b次幂
public static long round(double a) 四舍五入取整
小结：
记住。
*/
public class MathDemo {
public static void main(String[] args) {
// 1.取绝对值:返回正数
System.out.println(Math.abs(10)); // 10
System.out.println(Math.abs(-10.3)); // 10.3
// 2.向上取整: 5
System.out.println(Math.ceil(4.00000001)); // 5.0
System.out.println(Math.ceil(4.0)); // 4.0
// 3.向下取整：4
System.out.println(Math.floor(4.99999999)); // 4.0
System.out.println(Math.floor(4.0)); // 4.0
// 4.求指数次方
System.out.println(Math.pow(2 , 3)); // 2^3 = 8.0
// 5.四舍五入 10
System.out.println(Math.round(4.49999)); // 4
System.out.println(Math.round(4.500001)); // 5
System.out.println(Math.random()); // 0.0 - 1.0 （包前不包后）
// 拓展： 3 - 9 之间的随机数 （0 - 6） + 3
// [0 - 6] + 3
int data = (int)(Math.random() * 7) + 3;
System.out.println(data);
}
}
输出结果
10
10.3
5.0
4.0
4.0
4.0
8.0
4
5
0.7219171930691749
3
1.5、System
System 类概述
- System也是一个工具类，代表了当前系统，提供了一些与系统相关的方法。
System 类的常用方法
方法名
说明
public static void exit(int status)
终止当前运行的 Java 虚拟机，非零表示异常终止
public static long currentTimeMillis()
返回当前系统的时间毫秒值形式
public static void arraycopy(数据源数组, 起始索引, 目的地数组, 起始索引, 拷贝个数)
数组拷贝
时间毫秒值
- 计算机认为时间是有起点的，起始时间： 1970年1月1日 00:00:00
- 时间毫秒值：指的是从1970年1月1日 00:00:00走到此刻的总的毫秒数，应该是很大的。 1s = 1000ms。
原因
- 1969年8月，贝尔实验室的程序员肯汤普逊利用妻儿离开一个月的机会，开始着手创造一个全新的革命性的操作系统，他使用B编译语言在老旧的PDP-7机器上开发出了Unix的一个版本。
- 随后，汤普逊和同事丹尼斯里奇改进了B语言，开发出了C语言，重写了UNIX。
- 1970年1月1日 算C语言的生日
代码展示
import java.util.Arrays;
/**
目标：System系统类的使用。
System代表当前系统。（虚拟机系统）
静态方法：
1.public static void exit(int status):终止JVM虚拟机，非0是异常终止。
2.public static long currentTimeMillis():获取当前系统此刻时间毫秒值。(重点)
3.可以做数组的拷贝。
arraycopy(Object var0, int var1, Object var2, int var3, int var4);
* 参数一：原数组
* 参数二：从原数组的哪个位置开始赋值。
* 参数三：目标数组
* 参数四：赋值到目标数组的哪个位置
* 参数五：赋值几个。
*/
public class SystemDemo {
public static void main(String[] args) {
System.out.println("程序开始。。。");
// System.exit(0); // JVM终止！
// 2、计算机认为时间有起源：返回1970-1-1 00：00：00 走到此刻的总的毫秒值：时间毫秒值。
long time = System.currentTimeMillis();
System.out.println(time);
long startTime = System.currentTimeMillis();
// 进行时间的计算：性能分析
for (int i = 0; i < 100000; i++) {
System.out.println("输出：" + i);
}
long endTime = System.currentTimeMillis();
System.out.println((endTime - startTime)/1000.0 + "s");
// 3、做数组拷贝（了解）
/**
arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length)
参数一：被拷贝的数组
参数二：从哪个索引位置开始拷贝
参数三：复制的目标数组
参数四：粘贴位置
参数五：拷贝元素的个数
*/
int[] arr1 = {10, 20, 30, 40, 50, 60, 70};
int[] arr2 = new int[6]; // [0, 0, 0, 0, 0, 0] ==> [0, 0, 40, 50, 60, 0]
System.arraycopy(arr1, 3, arr2, 2, 3);
System.out.println(Arrays.toString(arr2));
System.out.println("-------------------");
double i = 10.0;
double j = 3.0;
//
// System.out.println(k1);
System.out.println("程序结束。。。。");
}
}
1.6、BigDecimal
BigDecimal 作用
- 用于解决浮点型运算精度失真的问题
使用步骤
-
创建对象BigDecimal封装浮点型数据（最好的方式是调用方法）
public static BigDecimal valueOf(double val); // 包装浮点数成为BigDecimal对象。
valueOf 源码还是调用了 toString
BigDecima常用API
方法名
说明
public BigDecimal add(BigDecimal b)
加法
public BigDecimal subtract(BigDecimal b)
减法
public BigDecimal multiply(BigDecimal b)
乘法
public BigDecimal divide(BigDecimal b)
除法
public BigDecimal divide (另一个BigDecimal对象，精确几位，舍入模式)
除法
代码展示
import java.math.BigDecimal;
import java.math.RoundingMode;
/**
目标：BigDecimal大数据类。
引入：
浮点型运算的时候直接+ * / 可能会出现数据失真（精度问题）。
BigDecimal可以解决浮点型运算数据失真的问题。
BigDicimal类：
包：java.math.
创建对象的方式（最好的方式：）
public static BigDecimal valueOf(double val) :包装浮点数成为大数据对象。
方法声明
public BigDecimal add(BigDecimal value) 加法运算
public BigDecimal subtract(BigDecimal value) 减法运算
public BigDecimal multiply(BigDecimal value) 乘法运算
public BigDecimal divide(BigDecimal value) 除法运算
public double doubleValue(): 把BigDecimal转换成double类型。
*/
public class BigDecimalDemo {
public static void main(String[] args) {
// 浮点型运算的时候直接+ * / 可能会出现数据失真（精度问题）。
System.out.println(0.09 + 0.01);
System.out.println(1.0 - 0.32);
System.out.println(1.015 * 100);
System.out.println(1.301 / 100);
System.out.println("-------------------------");
double a = 0.1;
double b = 0.2;
double c = a + b;
System.out.println(c);
System.out.println("--------------------------");
// 包装浮点型数据成为大数据对象 BigDeciaml
BigDecimal a1 = BigDecimal.valueOf(a);
BigDecimal b1 = BigDecimal.valueOf(b);
BigDecimal c1 = a1.add(b1);
// BigDecimal c1 = a1.subtract(b1);
// BigDecimal c1 = a1.multiply(b1);
// BigDecimal c1 = a1.divide(b1);
System.out.println(c1);
// 目的：double
double rs = c1.doubleValue();
System.out.println(rs);
// 注意事项：BigDecimal是一定要精度运算的
BigDecimal a11 = BigDecimal.valueOf(10.0);
BigDecimal b11 = BigDecimal.valueOf(3.0);
/**
参数一：除数 参数二：保留小数位数 参数三：舍入模式
*/
BigDecimal c11 = a11.divide(b11, 2, RoundingMode.HALF_UP); // 3.3333333333
System.out.println(c11);
System.out.println("-------------------");
}
}
输出结果
0.09999999999999999
0.6799999999999999
101.49999999999999
0.013009999999999999
-------------------------
0.30000000000000004
--------------------------
0.3
0.3
3.33
-------------------
除法问题
-
除法可能会导致结果为无限循环或无限不循环小数，故需要指定小数点精确到多少位，选择什么样的舍入模式
BigDecimal divide = bd1.divide(参与运算的对象, 小数点后精确到多少位, 舍入模式);
参数1 ，表示参与运算的 BigDecimal 对象。
参数2 ，表示小数点后面精确到多少位
参数3 ，舍入模式：
BigDecimal.ROUND_UP 进一法 BigDecimal.ROUND_FLOOR 去尾法 BigDecimal.ROUND_HALF_UP 四舍五入
2、日期与时间
2.1、Date 类
Date 类概述
- Date类代表当前所在系统的日期时间信息。
Date的构造器
名称
说明
public Date()
创建一个Date对象，代表的是系统当前此刻日期时间。
public Date(long time)
把时间毫秒值转换成Date日期对象。
Date的常用方法
名称
说明
public long getTime()
返回从1970年1月1日 00:00:00走到此刻的总的毫秒数
public void setTime(long time)
设置日期对象的时间为当前时间毫秒值对应的时间
代码展示
import java.util.Date;
/**
目标：学会使用Date类处理时间，获取时间的信息
*/
public class DateDemo1 {
public static void main(String[] args) {
// 1、创建一个Date类的对象：代表系统此刻日期时间对象
Date d = new Date();
System.out.println(d);
// 2、获取时间毫秒值
long time = d.getTime();
System.out.println(time);
// long time1 = System.currentTimeMillis();
// System.out.println(time1);
System.out.println("----------------------------");
// 1、得到当前时间
Date d1 = new Date();
System.out.println(d1);
// 2、当前时间往后走 1小时 121s
long time2 = System.currentTimeMillis();
time2 += (60 * 60 + 121) * 1000;
// 3、把时间毫秒值转换成对应的日期对象。
// Date d2 = new Date(time2);
// System.out.println(d2);
Date d3 = new Date();
d3.setTime(time2);
System.out.println(d3);
}
}
输出结果
Sat Apr 02 21:43:24 CST 2022
1648907004470
----------------------------
Sat Apr 02 21:43:24 CST 2022
Sat Apr 02 22:45:25 CST 2022
2.2、SimpleDateFormat
SimpleDateFormat 类作用
- 可以去完成日期时间的格式化操作
构造器
构造器
说明
public SimpleDateFormat(String pattern)
构造一个SimpleDateFormat，使用指定的格式
格式化方法
格式化方法
说明
public final String format(Date date)
将日期格式化成日期/时间字符串
public final String format(Object time)
将时间毫秒值式化成日期/时间字符串
格式化的时间形式的常用的模式对应关系
代码展示
import java.text.SimpleDateFormat;
import java.util.Date;
/**
目标：SimpleDateFormat简单日期格式化类的使用
格式化时间
解析时间
*/
public class SimpleDateFormatDemo01 {
public static void main(String[] args) {
// 1、日期对象
Date d = new Date();
System.out.println(d);
// 2、格式化这个日期对象 (指定最终格式化的形式)
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss EEE a");
// 3、开始格式化日期对象成为喜欢的字符串形式
String rs = sdf.format(d);
System.out.println(rs);
System.out.println("----------------------------");
// 4、格式化时间毫秒值
// 需求：请问121秒后的时间是多少
long time1 = System.currentTimeMillis() + 121 * 1000;
String rs2 = sdf.format(time1);
System.out.println(rs2);
System.out.println("------------解析字符串时间，下个代码---------------");
}
}
输出结果
Sat Apr 02 21:48:06 CST 2022
2022年04月02日 21:48:06 星期六 下午
----------------------------
2022年04月02日 21:50:07 星期六 下午
------------解析字符串时间，下个代码---------------
解析字符串时间成为日期对象
解析方法
说明
public Date parse(String source)
从给定字符串的开始解析文本以生成日期
案例
- 请计算出 2021年08月06日11点11分11秒，往后走2天14小时49分06秒后的时间是多少？
代码展示
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class SimpleDateFormatDemo2 {
public static void main(String[] args) throws ParseException {
// 目标: 学会使用SimpleDateFormat解析字符串时间成为日期对象。
// 有一个时间 2021年08月06日 11:11:11 往后 2天 14小时 49分 06秒后的时间是多少。
// 1、把字符串时间拿到程序中来
String dateStr = "2021年08月06日 11:11:11";
// 2、把字符串时间解析成日期对象（本节的重点）:形式必须与被解析时间的形式完全一样，否则运行时解析报错！
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
Date d = sdf.parse(dateStr);
// 3、往后走2天 14小时 49分 06秒
long time = d.getTime() + (2L*24*60*60 + 14*60*60 + 49*60 + 6) * 1000;
// 4、格式化这个时间毫秒值就是结果
System.out.println(sdf.format(time));
}
}
输出结果
2021年08月09日 02:00:17
案例：秒杀活动
需求：
-
某购物网站举办秒杀活动，开始时间和结束时间如左图所示，当前活动结束后，系统记录到2位用户的付款时间分别如下：
-
小贾下单并付款的时间为：2020年11月11日 0:03:47
-
小皮下单并付款的时间为：2020年11月11日 0:10:11
-
规则：顾客的付款时间必须在秒杀时间之内，请判断出两位顾客是否秒杀成功。
分析：
- 把4个字符串形式的时间解析成日期对象。
- 判断小贾和小皮的时间是否在秒杀时间范围之内，并给出相应的提示。
代码展示
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class SimpleDateFormatTest3 {
public static void main(String[] args) throws ParseException {
// 1、开始 和 结束时间
String startTime = "2021-11-11 00:00:00";
String endTime = "2021-11-11 00:10:00";
// 2、小贾 小皮
String xiaoJia = "2021-11-11 00:03:47";
String xiaoPi = "2021-11-11 00:10:11";
// 3、解析他们的时间
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date d1 = sdf.parse(startTime);
Date d2 = sdf.parse(endTime);
Date d3 = sdf.parse(xiaoJia);
Date d4 = sdf.parse(xiaoPi);
if(d3.after(d1) && d3.before(d2)){
System.out.println("小贾秒杀成功，可以发货了！");
}else {
System.out.println("小贾秒杀失败！");
}
if(d4.after(d1) && d4.before(d2)){
System.out.println("小皮秒杀成功，可以发货了！");
}else {
System.out.println("小皮秒杀失败！");
}
}
}
输出结果
小贾秒杀成功，可以发货了！
小皮秒杀失败！
2.3、Calendar
Calendar概述
- Calendar代表了系统此刻日期对应的日历对象。
- Calendar是一个抽象类，不能直接创建对象。
Calendar日历类创建日历对象的方法：
方法名
说明
public static Calendar getInstance()
获取当前日历对象
Calendar常用方法
方法名
说明
public int get(int field)
取日期中的某个字段信息。
public void set(int field,int value)
修改日历的某个字段信息。
public void add(int field,int amount)
为某个字段增加/减少指定的值
public final Date getTime()
拿到此刻日期对象。
public long getTimeInMillis()
拿到此刻时间毫秒值
注意
- calendar是可变日期对象，一旦修改后其对象本身表示的时间将产生变化。
- 使用 JDK8 新增日期类可以解决这个问题，后面介绍
代码展示
import java.util.Calendar;
import java.util.Date;
/**
目标：日历类Calendar的使用,可以得到更加丰富的信息。
Calendar代表了系统此刻日期对应的日历对象。
Calendar是一个抽象类，不能直接创建对象。
Calendar日历类创建日历对象的语法：
Calendar rightNow = Calendar.getInstance();
Calendar的方法：
1.public static Calendar getInstance(): 返回一个日历类的对象。
2.public int get(int field)：取日期中的某个字段信息。
3.public void set(int field,int value)：修改日历的某个字段信息。
4.public void add(int field,int amount)：为某个字段增加/减少指定的值
5.public final Date getTime(): 拿到此刻日期对象。
6.public long getTimeInMillis(): 拿到此刻时间毫秒值
小结：
记住。
*/
public class CalendarDemo{
public static void main(String[] args) {
// 1、拿到系统此刻日历对象
Calendar cal = Calendar.getInstance();
System.out.println(cal);
// 2、获取日历的信息:public int get(int field)：取日期中的某个字段信息。
int year = cal.get(Calendar.YEAR);
System.out.println(year);
int mm = cal.get(Calendar.MONTH) + 1;
System.out.println(mm);
int days = cal.get(Calendar.DAY_OF_YEAR) ;
System.out.println(days);
// 3、public void set(int field,int value)：修改日历的某个字段信息。
// cal.set(Calendar.HOUR , 12);
// System.out.println(cal);
// 4.public void add(int field,int amount)：为某个字段增加/减少指定的值
// 请问64天后是什么时间
cal.add(Calendar.DAY_OF_YEAR , 64);
cal.add(Calendar.MINUTE , 59);
// 5.public final Date getTime(): 拿到此刻日期对象。
Date d = cal.getTime();
System.out.println(d);
// 6.public long getTimeInMillis(): 拿到此刻时间毫秒值
long time = cal.getTimeInMillis();
System.out.println(time);
}
}
输出结果
java.util.GregorianCalendar[time=1648908569874,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=31,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2022,MONTH=3,WEEK_OF_YEAR=14,WEEK_OF_MONTH=1,DAY_OF_MONTH=2,DAY_OF_YEAR=92,DAY_OF_WEEK=7,DAY_OF_WEEK_IN_MONTH=1,AM_PM=1,HOUR=10,HOUR_OF_DAY=22,MINUTE=9,SECOND=29,MILLISECOND=874,ZONE_OFFSET=28800000,DST_OFFSET=0]
2022
4
92
Sun Jun 05 23:08:29 CST 2022
1654441709874
2.4、JDK8 新增日期类
概述
- 从Java 8开始，java.time包提供了新的日期和时间API，主要涉及的类型有：
- 新增的API严格区分了时刻、本地日期、本地时间，并且，对日期和时间进行运算更加方便。
- 其次，新API的类型几乎全部是不变类型（和String的使用类似），可以放心使用不必担心被修改。
2.4.1、LocalDate、LocalTime、LocalDateTime
- 他们 分别表示日期，时间，日期时间对象，他们的类的实例是不可变的对象。
- 他们三者构建对象和API都是通用的
构建对象的方式
LocalDate、LocalTime、LocalDateTime 获取信息的方法
方法名
说明
public int geYear()
获取年
public int getMonthValue()
获取月份（1-12）
Public int getDayOfMonth()
获取月中第几天乘法
Public int getDayOfYear()
获取年中第几天
Public DayOfWeek getDayOfWeek()
获取星期
转换相关的API
修改相关的API
- LocalDateTime 综合了 LocalDate 和 LocalTime 里面的方法，所以下面只用 LocalDate 和 LocalTime 来举例。
- 这些方法返回的是一个新的实例引用，因为LocalDateTime 、LocalDate 、LocalTime 都是不可变的。
方法名
说明
plusDays, plusWeeks, plusMonths, plusYears
向当前 LocalDate 对象添加几天、 几周、几个月、几年
minusDays, minusWeeks, minusMonths, minusYears
从当前 LocalDate 对象减去几天、 几周、几个月、几年
withDayOfMonth, withDayOfYear, withMonth, withYear
将月份天数、年份天数、月份、年 份 修 改 为 指 定 的 值 并 返 回 新 的 LocalDate 对象
isBefore, isAfter
比较两个 LocalDate
代码展示
LocalDate
import java.time.LocalDate;
import java.time.Month;
public class Demo01LocalDate {
public static void main(String[] args) {
// 1、获取本地日期对象。
LocalDate nowDate = LocalDate.now();
System.out.println("今天的日期：" + nowDate);//今天的日期：
int year = nowDate.getYear();
System.out.println("year：" + year);
int month = nowDate.getMonthValue();
System.out.println("month：" + month);
int day = nowDate.getDayOfMonth();
System.out.println("day：" + day);
//当年的第几天
int dayOfYear = nowDate.getDayOfYear();
System.out.println("dayOfYear：" + dayOfYear);
//星期
System.out.println(nowDate.getDayOfWeek());
System.out.println(nowDate.getDayOfWeek().getValue());
//月份
System.out.println(nowDate.g