Java 面向对象（九）
常用类之Random
Random类位于 java.util 包中，主要用于生成伪随机数
Random类将种子数作为随机算法的起源数字，计算生成伪随机数，其与生成的随机数字的区间无关
创建Random实例时，若没有指定种子数，则会以当前时间作为种子数，来计算生成伪随机数
拥有相同种子的Random实例，在相同次数下，生成的伪随机数完全相同
构造器
// 创建一个新的随机数生成器。
Random()
// 使用单个 long 种子创建一个新的随机数生成器。
Random(long seed)
// 相同种子生成的随机数是一样的
常用方法
// 返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值
int nextInt()
// 返回一个伪随机数，它是取自此随机数生成器序列的、在 [0,n) 之间均匀分布的 int 值。
int nextInt(int n)
// 返回下一个伪随机数，它是取自此随机数生成器序列的、在 0.0 和 1.0 之间均匀分布的 double 值
double nextDouble()
// 返回下一个伪随机数，它是取自此随机数生成器序列的、在 0.0 和 1.0 之间均匀分布的 float 值
float nextFloat()
// 返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的 boolean 值
boolean nextBoolean()
// 生成随机字节并将其置于用户提供的 byte 数组中
void nextBytes(byte[] bytes)
// 返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的 long 值
long nextLong()
// 使用单个 long 种子设置此随机数生成器的种子
void setSeed(long seed)
例子1：
Random r = new Random();
System.out.println(r.nextDouble());
System.out.println(r.nextBoolean());
System.out.println("-> " + r.nextInt());
System.out.println("---------------");
// 相同的种子，生成的随机数是一样
Random r2 = new Random(10);
Random r3 = new Random(10);
System.out.println("-> " + r2.nextInt()); // -1157793070
System.out.println("-> " + r3.nextInt()); // -1157793070
// 生成34到179之间的随机数 ： 34 + [0 145)
System.out.println(r.nextInt(145) + 34);
例子2：UUID
// UUID：通用唯一识别符
// 在一台机器 上生成 的数字
// 当前的时间，跟当前电脑网卡 生成一段字符
String uuid = UUID.randomUUID().toString();
System.out.println(uuid);
例子3：验证码
// 生成验证码
// 5位的随机数 UUID生成的是16进制
String res = UUID.randomUUID().toString();
System.out.println(res);
res = res.substring(0, 5);
System.out.println(res);
System.out.println("--------------------");
String str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
str = str + str.toLowerCase();
str += "0123456789";
System.out.println(str);
System.out.println(str.length());
// 从所有的字符当中随机生成5个出来
// 随机取5个出来
// 每取出一个结果，在原来的基础 上面进行拼接
StringBuilder sb = new StringBuilder(5);
for (int i = 0; i < 5; i++) {
// 角标要随机的值 （0 62：字符串的长度）
int index = new Random().nextInt(str.length());
char ch = str.charAt(index);
sb.append(ch);
}
System.out.println(sb);
常用类之Date
之前，我们定义员工年龄和入职日期是用 int 和 String 来定义的。
class Employee {
int age;
String hireDate;
}
这样每过一年，都要修改年龄；或者要计算员工的工龄不方便。java当中专门提供了日期类型。
构造器
// 使用当前日期和时间来初始化对象（精确到毫秒）。
Date()
// 第二个构造函数接收一个参数，该参数是从1970年1月1日 00:00:00 起的毫秒数。
Date(long date)
e.g. 获取当前日期时间
// 创建 一个日期对象
Date date = new Date();
System.out.println(date);
// 获取当前时间的毫秒数
long curTime = System.currentTimeMillis();
// 把一个毫秒值 转成日期类型
Date date2 = new Date(curTime);
System.out.println(date2);
以上两个两段代码其实是一样的，看下Data()的源码，本质就是用系统当前时间的毫秒数来创建Date对象
public Date() {
this(System.currentTimeMillis());
}
e.g. Java 休眠(sleep)
try {
System.out.println(new Date() + "\n");
Thread.sleep(1000 * 3); // 休眠3秒
System.out.println(new Date() + "\n");
} catch (Exception e) {
System.out.println("出现异常!");
}
日期比较
// 测试此日期是否在指定日期之后
boolean after(Date when)
// 测试此日期是否在指定日期之前
boolean before(Date when)
// 比较两个日期的顺序
int compareTo(Date anotherDate)
// 比较两个日期的相等性
boolean equals(Object obj)
e.g.
// 创建 一个日期对象
Date date = new Date(1564387266239L); // 毫秒数大 时间迟
Date date2 = new Date(1564211606445L); // 毫秒数小 时间早
System.out.println(date); // Mon Jul 29 16:01:06 GMT+08:00 2019
System.out.println(date2); // Sat Jul 27 15:13:26 GMT+08:00 2019
System.out.println(date.before(date2)); // false
System.out.println(date.after(date2)); // true
System.out.println(date.compareTo(date2)); // 1
System.out.println(date.equals(date2)); // false
获取和设置时间毫秒值：Date和毫秒值转化
long getTime()
void setTime(long time)
e.g.
// 创建 一个日期对象
Date date = new Date();
Date date2 = new Date();
long time = date.getTime();
System.out.println(time);
date2.setTime(1564387266239L);
// 输出的字符串不符合中文习惯
System.out.println(date2);
// toLocaleString 已经过时了，不建议使用，这里暂时使用
System.out.println(date2.toLocaleString());
日期格式化 DateFormat
创建日期格式化对象：
// 获取日期和时间使用 SHORT 风格的默认日期/时间格式器
static DateFormat getInstance()
// 获取日期和时间使用 默认（DEFAULT） 风格的日期/时间格式器
static DateFormat getDateTimeInstance()
// 获取日期和时间使用 给定日期和时间格式化风格的日期/时间格式器
static DateFormat getDateTimeInstance(int dateStyle, int timeStyle)
// 获取使用 默认（DEFAULT） 风格的日期格式器
static DateFormat getDateInstance()
// 获取使用 给定格式化风格的日期格式器
static DateFormat getDateInstance(int style)
// 获取使用 默认（DEFAULT） 风格的时间格式器
static DateFormat getTimeInstance()
// 获取使用 给定格式化风格的时间格式器
static DateFormat getTimeInstance(int style)
e.g.
Date date = new Date();
System.out.println(date);
System.out.println(date.toLocaleString());
System.out.println("------------日期格式化------------");
// 获取为日期和时间使用 SHORT 风格的默认日期/时间格式器
DateFormat df1 = DateFormat.getInstance();
// 相当于 ： DateFormat df1 = DateFormat.getDateTimeInstance
// (DateFormat.SHORT, DateFormat.SHORT);
// 对指定的日期进行格式化： Date -> String
String time = df1.format(date);
System.out.println("SHORT 风格: " + time);
// 获取为日期和时间使用 默认（DEFAULT） 风格的日期/时间格式器
DateFormat df2 = DateFormat.getDateTimeInstance();
// 相当于 ： DateFormat df2 = DateFormat.getDateTimeInstance
// (DateFormat.DEFAULT, DateFormat.DEFAULT);
System.out.println("DEFAULT 风格: " + df2.format(date));
DateFormat df3 = DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.MEDIUM);
System.out.println("MEDIUM 风格: " + df3.format(date));
DateFormat df4 = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG);
System.out.println("LONG 风格: " + df4.format(date));
DateFormat df5 = DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.FULL);
System.out.println("FULL 风格: " + df5.format(date));
输出结果：
Mon Jul 29 17:16:05 GMT+08:00 2019
2019-7-29 17:16:05
------------日期格式化------------
SHORT 风格: 19-7-29 下午5:16
DEFAULT 风格: 2019-7-29 17:16:05
MEDIUM 风格: 2019-7-29 17:16:05
LONG 风格: 2019年7月29日 下午05时16分05秒
FULL 风格: 2019年7月29日 星期一 下午05时16分05秒 GMT+08:00
日期和String的转换
（1）Date -> String : format 格式化
Date date = new Date();
DateFormat df = DateFormat.getInstance();
String format = df.format(date);
System.out.println(format);
（2）String -> Date : parse 解析
DateFormat df = DateFormat.getInstance();
String source = "19-7-29 下午5:23";
try {
Date parse = df.parse(source);
System.out.println(parse);
} catch (ParseException e) {
System.out.println("日期字符串格式错误！");
e.printStackTrace();
}
自定义日期格式化 SimpleDateFormat
模式字母：
| 字母 | 日期或时间元素 | 表示 |
|---|---|---|
| y | 年 | Year |
| M | 年中的月份 | Month |
| w | 年中的周数 | Number |
| W | 月份中的周数 | Number |
| D | 年中的天数 | Number |
| d | 月份中的天数 | Number |
| F | 月份中的星期 | Number |
| E | 星期中的天数 | Text |
| a | Am/pm 标记 | Text |
| H | 一天中的小时数（0-23） | Number |
| k | 一天中的小时数（1-24） | Number |
| K | am/pm 中的小时数（0-11） | Number |
| h | am/pm 中的小时数（1-12） | Number |
| m | 小时中的分钟数 | Number |
| s | 分钟中的秒数 | Number |
| S | 毫秒数 | Number |
| z | 时区 | General time zone |
| Z | 时区 | RFC 822 time zone |
构造器
常用的两个：
// 用默认的模式和默认语言环境的日期格式符号构造
SimpleDateFormat()
// 用给定的模式和默认语言环境的日期格式符号构造
SimpleDateFormat(String pattern)
常用方法
// 将给定模式字符串应用于此日期格式
void applyPattern(String pattern)
// 返回描述此日期格式的模式字符串
String toPattern()
e.g.
Date date = new Date();
// 自定义日期格式化
SimpleDateFormat sdf = new SimpleDateFormat();
// 获得默认的模式
System.out.println(sdf.toPattern()); // yy-M-d ah:mm
// 用默认的模式格式化
System.out.println(sdf.format(date)); // 19-7-29 下午8:19
// 定义自己想要什么 样的模式
String pattern = "yyyy-MM-dd HH:mm:ss E";
sdf.applyPattern(pattern);
// 以指定的模式格式化哪个日期
String res = sdf.format(date);
System.out.println(res); // 2019-07-29 20:19:37 星期一
// 自定义日期格式化
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss E");
System.out.println(sdf2.toPattern()); // yyyy-MM-dd HH:mm:ss E
System.out.println(sdf2.format(date)); // 2019-07-29 20:19:37 星期一
日期格式化 格式化字符串输出
标准的
| 转 换 符 | 说 明 | 示 例 |
|---|---|---|
| c | 包括全部日期和时间信息 | 星期一 七月 29 21:54:44 GMT+08:00 2019 |
| F | "年-月-日"格式 | 2019-07-29 |
| D | "月/日/年"格式 | 07/29/19 |
| r | "HH:MM:SS PM"格式（12时制） | 09:54:44 下午 |
| T | "HH:MM:SS"格式（24时制） | 21:54:44 |
| R | "HH:MM"格式（24时制） | 21:54 |
e.g.
Date date = new Date();
System.out.println(String.format("%tc", date)); // 星期一 七月 29 21:57:57 GMT+08:00 2019
System.out.println(String.format("%tF", date)); // 2019-07-29
System.out.println(String.format("%tD", date)); // 07/29/19
System.out.println(String.format("%tr", date)); // 09:57:57 下午
System.out.println(String.format("%tT", date)); // 21:57:57
System.out.println(String.format("%tR", date)); // 21:57
/*
* 组合：
* （1）可以利用一个格式化字符串指出要被格式化的参数的索引。
* 索引必须紧跟在%后面，而且必须以$结束。
* 或者
* （2）你可以使用 < 标志。它表明先前被格式化的参数要被再次使用
*/
System.out.println(String.format("%1$s %2$tF %2$tT", "Due date:", date)); // Due date: 2019-07-29 21:57:57
System.out.println(String.format("%tF %<tT", date)); // 2019-07-29 21:57:57
自定义
日期：
| 转 换 符 | 说 明 |
|---|---|
| y | 日期的二位数的年份(如99) |
| m | 日期的月份 |
| d | 日期的日号 |
| Y | 日期的四位数的年份(如1999) |
| B | 日期的月份的完整名 |
| b | 日期的月份的简称 |
e.g.
Date date = new Date();
System.out.println(String.format("%ty", date)); // 19
System.out.println(String.format("%tm", date)); // 07
System.out.println(String.format("%td", date)); // 29
System.out.println(String.format("%tY", date)); // 2019
System.out.println(String.format(Locale.US, "%tB", date)); // July
System.out.println(String.format(Locale.US, "%tb", date)); // Jul
System.out.println(String.format("%tB %<tb", date)); // 七月 七月
时间：
| 转 换 符 | 说 明 |
|---|---|
| H | 时间的时(24进制) |
| I | 时间的时(12进制) |
| M | 时间的分 |
| S | 时间的秒 |
| L | 时间的秒中的毫秒数 |
| p | 时间是上午还是下午 |
e.g.
Date date = new Date();
System.out.println(String.format("%tH:%<tM:%<tS; %<tI:%<tM:%<tS", date)); // 22:27:47; 10:27:47
System.out.println(String.format("%tH:%<tM:%<tS.%<tL %<tp", date)); // 22:27:47.274 下午
星期：
| 转 换 符 | 说 明 |
|---|---|
| A | 日期的星期全称 |
| a | 日期的星期简称 |
e.g.
Date date = new Date();
System.out.println(String.format("%tH:%<tM:%<tS %<tA", date)); // 22:31:41 星期一
System.out.println(String.format("%tH:%<tM:%<tS %<ta", date)); // 22:31:41 星期一
System.out.println(String.format(Locale.US, "%tH:%<tM:%<tS %<tA", date)); // 22:31:41 Monday
System.out.println(String.format(Locale.US, "%tH:%<tM:%<tS %<ta", date)); // 22:31:41 Mon
日历类
使用Calendar类 可以设置和获取日期数据的特定部分，比如说小时，日，或者分钟。
我们也可以在日期的这些部分加上或者减去值（日期的加减）
创建日历类对象：
// 使用默认时区和语言环境获得一个日历
static Calendar getInstance()
常用方法
// 返回给定日历字段的值
int get(int field)
// 将给定的日历字段设置为给定值
void set(int field, int value)
// 返回一个表示此 Calendar 时间值的 Date 对象
Date getTime()
// 使用给定的 Date 设置此 Calendar 的时间
void setTime(Date date)
// 返回此 Calendar 的时间值，以毫秒为单位
long getTimeInMillis()
// 用给定的 long 值设置此 Calendar 的当前时间值
void setTimeInMillis(long millis)
// 设置日历字段 YEAR、MONTH 和 DAY_OF_MONTH 的值
void set(int year, int month, int date)
// 设置日历字段 YEAR、MONTH、DAY_OF_MONTH、HOUR_OF_DAY 和 MINUTE 的值
void set(int year, int month, int date, int hourOfDay, int minute)
// 设置字段 YEAR、MONTH、DAY_OF_MONTH、HOUR、MINUTE 和 SECOND 的值
void set(int year, int month, int date, int hourOfDay, int minute, int second)
// 根据日历的规则，为给定的日历字段添加或减去指定的时间量
abstract void add(int field, int amount)
// 比较两个 Calendar 对象表示的时间值
int compareTo(Calendar anotherCalendar)
e.g.
Calendar c = Calendar.getInstance();
System.out.println(String.format("%tF %<tT %<ta",c.getTime()));
System.out.println("-----------");
System.out.println("年= " + c.get(Calendar.YEAR));
System.out.println("月= " + (c.get(Calendar.MONTH) + 1)); // 获取是从0开始，所以加1
System.out.println("日= " + c.get(Calendar.DAY_OF_MONTH));
System.out.println("时= " + c.get(Calendar.HOUR_OF_DAY));
System.out.println("分= " + c.get(Calendar.MINUTE));
System.out.println("秒= " + c.get(Calendar.SECOND));
System.out.println("星期= " + (c.get(Calendar.DAY_OF_WEEK) - 1));
System.out.println("-----------");
// 加上3天 （正：3天之后；负：3天之前）
c.add(Calendar.DAY_OF_MONTH, 3);
System.out.println(String.format("%tF %<tT %<ta",c.getTime()));
日期类型转换小结
String Long Date Calendar
（1）String <——> Date
// String -> Date 解析parse
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
String source = "2019-7-29";
try {
Date parse = sdf1.parse(source);
System.out.println(parse);
} catch (ParseException e) {
System.out.println("日期字符串格式错误！");
e.printStackTrace();
}
// Date -> String 格式化format
Date date = new Date();
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss E");
String format = sdf2.format(date);
System.out.println(format);
// Date -> String 格式化String
Date date2 = new Date();
System.out.println(String.format("%tF %<tT %<tA", date2));
（2）String <——> Calendar
// String -> Calendar （String -> Date -> Calendar）
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
String source = "2019-7-29";
try {
Date parse = sdf1.parse(source);
Calendar c1 = Calendar.getInstance();
c1.setTime(parse);
System.out.print(c1.get(Calendar.YEAR) + "-" + (c1.get(Calendar.MONTH) + 1) + "-" + c1.get(Calendar.DAY_OF_MONTH));
System.out.println(" " + c1.get(Calendar.HOUR_OF_DAY) + ":" + c1.get(Calendar.MINUTE) + ":" + c1.get(Calendar.SECOND));
} catch (ParseException e) {
System.out.println("日期字符串格式错误！");
e.printStackTrace();
}
// Calendar -> String （Calendar -> Date -> String）
Calendar c2 = Calendar.getInstance();
Date date = c2.getTime();
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss E");
String format = sdf2.format(date);
System.out.println(format);
（3）Long <——> Date
// Date -> Long
Date date1 = new Date();
long time1 = date1.getTime();
System.out.println(time1);
// Long -> Date
long time2 = 1564414169841L;
Date date2 = new Date(time2);
System.out.println(date2);
（4）Long <——> Calendar
// Long -> Calendar
long time1 = 1564414169841L;
Calendar c1 = Calendar.getInstance();
c1.setTimeInMillis(time1);
System.out.println(String.format("%tF %<tT %<ta", c1.getTime()));
// Calendar -> Long
Calendar c2 = Calendar.getInstance();
long time2 = c2.getTimeInMillis();
System.out.println(time2);
（5）Date <——> Calendar
// Date <——> Calendar
// Date -> Calendar
Date date1 = new Date();
Calendar c1 = Calendar.getInstance();
c1.setTime(date1);
System.out.println(String.format("%tF %<tT %<ta", c1.getTime()));
// Calendar -> Date
Calendar c2 = Calendar.getInstance();
Date date2 = c2.getTime();
System.out.println(date2);
LocalDate 日期时间（Java 8）
在旧版的 Java 中，日期时间 API 存在诸多问题，其中有：
（1）非线程安全
java.util.Date 是非线程安全的，所有的日期类都是可变的，这是Java日期类最大的问题之一。
（2）设计很差
Java的日期/时间类的定义并不一致，在java.util和java.sql的包中都有日期类，此外用于格式化和解析的类在java.text包中定义。java.util.Date同时包含日期和时间，而java.sql.Date仅包含日期，将其纳入java.sql包并不合理。另外这两个类都有相同的名字，这本身就是一个非常糟糕的设计。
（3）时区处理麻烦
日期类并不提供国际化，没有时区支持，因此Java引入了java.util.Calendar和java.util.TimeZone类，但他们同样存在上述所有的问题。
Java 8 在 java.time 包下提供了很多新的 API。以下为两个比较重要的 API：
Local(本地) ： 简化了日期时间的处理，没有时区的问题。
Zoned(时区) ： 通过制定的时区处理日期时间。
Calendar c = Calendar.getInstance();
c.set(2019, 5, 20);
System.out.println(String.format("%tF",c.getTime())); // 2019-06-20
LocalDate date = LocalDate.of(2019, 5, 20);
System.out.println(date); // 2019-05-20
可以看到旧版计算结果面向机器，对人不够友好。
创建 LocalDateTime/LocalDate/LocalTime 对象
// of : 根据指定的日期和时间创建对象
LocalDateTime dateTime = LocalDateTime.of(2019, 7, 30, 9, 30, 0);
LocalDate date = LocalDate.of(2019, 7, 30);
LocalTime time = LocalTime.of(9, 30, 0);
// now : 根据当前的日期和时间创建对象
LocalDateTime dateTime2 = LocalDateTime.now();
LocalDate date2 = LocalDate.now();
LocalTime time2 = LocalTime.now();
LocalDateTime类包含了LocalDate类和LocalTime类。
LocalDateTime localDateTime = LocalDateTime.now();
LocalDate localDate = localDateTime.toLocalDate();
LocalTime localTime = localDateTime.toLocalTime();
System.out.println(localDateTime);
System.out.println(localDate);
System.out.println(localTime);
运行结果
2019-07-31T12:40:00.134
2019-07-31
12:40:00.134
获取日期的年月日周时分秒
LocalDateTime dateTime = LocalDateTime.now();
int dayOfYear = dateTime.getDayOfYear();
int dayOfMonth = dateTime.getDayOfMonth();
DayOfWeek dayOfWeek = dateTime.getDayOfWeek();
System.out.println("今天是" + dateTime);
System.out.println("本年当中第" + dayOfYear + "天");
System.out.println("本月当中第" + dayOfMonth + "天");
System.out.println("本周中星期" + dayOfWeek.getValue() + "--即" + dayOfWeek);
// 获取当天时间的年月日时分秒
int year = dateTime.getYear();
Month month = dateTime.getMonth();
int day = dateTime.getDayOfMonth();
int hour = dateTime.getHour();
int minute = dateTime.getMinute();
int second = dateTime.getSecond();
System.out.println("今天是" + dateTime);
System.out.println("年 ： " + year);
System.out.println("月 ： " + month.getValue() + "--即 " + month);
System.out.println("日 ： " + day);
System.out.println("时 ： " + hour);
System.out.println("分 ： " + minute);
System.out.println("秒 ： " + second);
运行结果
今天是2019-07-30T18:00:36.022
本年当中第211天
本月当中第30天
本周中星期2--即TUESDAY
今天是2019-07-30T18:00:36.022
年 ： 2019
月 ： 7--即 JULY
日 ： 30
时 ： 18
分 ： 0
秒 ： 36
将年、月、日等修改为指定的值，并返回新的日期（时间）对象
如今天是2019-07-13，要想变为2019-07-20有两种方式
a. 相加指定的天数
b. 直接指定到哪一天
e.g.
LocalDate localDate = LocalDate.now();
LocalDate withDayOfMonthResult = localDate.withDayOfMonth(20);
LocalDate plusDays = localDate.plusDays(-10L);
System.out.println("当前时间是 : " + localDate);
System.out.println("相加指定的天数：" + plusDays);
System.out.println("直接指定到哪一天： " + withDayOfMonthResult);
运行结果
当前时间是 : 2019-07-30
相加指定的天数：2019-07-20
直接指定到哪一天： 2019-07-20
e.g.
LocalDate localDate = LocalDate.now();
// 当前时间基础上，指定本年当中的第几天，取值范围为1-365,366
LocalDate withDayOfYearResult = localDate.withDayOfYear(200);
// 当前时间基础上，指定本月当中的第几天，取值范围为1-29,30,31
LocalDate withDayOfMonthResult = localDate.withDayOfMonth(5);
// 当前时间基础上，直接指定年份
LocalDate withYearResult = localDate.withYear(2017);
// 当前时间基础上，直接指定月份
LocalDate withMonthResult = localDate.withMonth(5);
System.out.println("当前时间是 : " + localDate);
System.out.println("指定本年当中的第200天 : " + withDayOfYearResult);
System.out.println("指定本月当中的第5天 : " + withDayOfMonthResult);
System.out.println("直接指定年份为2017 : " + withYearResult);
System.out.println("直接指定月份为5月 : " + withMonthResult);
运行结果
当前时间是 : 2019-07-30
指定本年当中的第200天 : 2019-07-19
指定本月当中的第5天 : 2019-07-05
直接指定年份为2017 : 2017-07-30
直接指定月份为5月 : 2019-05-30
日期时间的加减
对于LocalDate，只有精度大于或等于日的加减，如年、月、日；
对于LocalTime，只有精度小于或等于时的加减，如时、分、秒、纳秒；
对于LocalDateTime，则可以进行任意精度的时间相加减；
相加：
(1) plus(正数);
(2) minus(负数);
LocalDateTime localDateTime = LocalDateTime.now();
// 以下方法的参数都是long型，返回值都是LocalDateTime
LocalDateTime plusYearsResult = localDateTime.plusYears(2L);
LocalDateTime plusMonthsResult = localDateTime.plusMonths(3L);
LocalDateTime plusDaysResult = localDateTime.plusDays(7L);
LocalDateTime plusHoursResult = localDateTime.plusHours(2L);
LocalDateTime plusMinutesResult = localDateTime.plusMinutes(10L);
LocalDateTime plusSecondsResult = localDateTime.plusSeconds(10L);
System.out.println("当前时间是 : " + localDateTime);
System.out.println("当前时间加2年后为 : " + plusYearsResult);
System.out.println("当前时间加3个月后为 : " + plusMonthsResult);
System.out.println("当前时间加7日后为 : " + plusDaysResult);
System.out.println("当前时间加2小时后为 : " + plusHoursResult);
System.out.println("当前时间加10分钟后为 : " + plusMinutesResult);
System.out.println("当前时间加10秒后为 : " + plusSecondsResult);
// 也可以以另一种方式来相加减日期，即plus(long amountToAdd, TemporalUnit unit)
// 参数1 ： 相加的数量， 参数2 ： 相加的单位
LocalDateTime nextMonth = localDateTime.plus(1, ChronoUnit.MONTHS);
LocalDateTime nextYear = localDateTime.plus(1, ChronoUnit.YEARS);
LocalDateTime nextWeek = localDateTime.plus(1, ChronoUnit.WEEKS);
System.out.println("now : " + localDateTime);
System.out.println("nextYear : " + nextYear);
System.out.println("nextMonth : " + nextMonth);
System.out.println("nextWeek :" + nextWeek);
运行结果
当前时间是 : 2019-07-31T11:23:57.546
当前时间加2年后为 : 2021-07-31T11:23:57.546
当前时间加3个月后为 : 2019-10-31T11:23:57.546
当前时间加7日后为 : 2019-08-07T11:23:57.546
当前时间加2小时后为 : 2019-07-31T13:23:57.546
当前时间加10分钟后为 : 2019-07-31T11:33:57.546
当前时间加10秒后为 : 2019-07-31T11:24:07.546
now : 2019-07-31T11:23:57.546
nextYear : 2020-07-31T11:23:57.546
nextMonth : 2019-08-31T11:23:57.546
nextWeek :2019-08-07T11:23:57.546
相减：
(1) minus(正数);
(2) plus(负数);
LocalDateTime localDateTime = LocalDateTime.now();
// 以下方法的参数都是long型，返回值都是LocalDateTime
LocalDateTime minusYearsResult = localDateTime.minusYears(2L);
LocalDateTime minusMonthsResult = localDateTime.minusMonths(3L);
LocalDateTime minusDaysResult = localDateTime.minusDays(7L);
LocalDateTime minusHoursResult = localDateTime.minusHours(2L);
LocalDateTime minusMinutesResult = localDateTime.minusMinutes(10L);
LocalDateTime minusSecondsResult = localDateTime.minusSeconds(10L);
System.out.println("当前时间是 : " + localDateTime);
System.out.println("当前时间加2年前为 : " + minusYearsResult);
System.out.println("当前时间加3个月前为 : " + minusMonthsResult);
System.out.println("当前时间加7日前为 : " + minusDaysResult);
System.out.println("当前时间加2小时前为 : " + minusHoursResult);
System.out.println("当前时间加10分钟前为 : " + minusMinutesResult);
System.out.println("当前时间加10秒前为 : " + minusSecondsResult);
// 也可以以另一种方式来相加减日期，即minus(long amountToAdd, TemporalUnit unit)
// 参数1 ： 相减的数量， 参数2 ： 相减的单位
LocalDateTime lastMonth = localDateTime.minus(1, ChronoUnit.MONTHS);
LocalDateTime lastYear = localDateTime.minus(1, ChronoUnit.YEARS);
LocalDateTime lastWeek = localDateTime.minus(1, ChronoUnit.WEEKS);
System.out.println("now : " + localDateTime);
System.out.println("lastYear : " + lastYear);
System.out.println("lastMonth : " + lastMonth);
System.out.println("lastWeek :" + lastWeek);
运行结果
当前时间是 : 2019-07-31T12:33:36.843
当前时间加2年前为 : 2017-07-31T12:33:36.843
当前时间加3个月前为 : 2019-04-30T12:33:36.843
当前时间加7日前为 : 2019-07-24T12:33:36.843
当前时间加2小时前为 : 2019-07-31T10:33:36.843
当前时间加10分钟前为 : 2019-07-31T12:23:36.843
当前时间加10秒前为 : 2019-07-31T12:33:26.843
now : 2019-07-31T12:33:36.843
lastYear : 2018-07-31T12:33:36.843
lastMonth : 2019-06-30T12:33:36.843
lastWeek :2019-07-24T12:33:36.843
时间日期的格式化
（1）使用jdk自身配置好的日期格式
// 使用jdk自身配置好的日期格式
DateTimeFormatter dtf = DateTimeFormatter.ISO_DATE_TIME;
LocalDateTime date = LocalDateTime.now();
System.out.println(date);
String format1 = dtf.format(date);
// 反过来调用也可以
String format2 = date.format(dtf);
System.out.println(format1);
System.out.println(format2);
运行结果
2019-07-31T11:34:01.899
2019-07-31T11:34:01.899
2019-07-31T11:34:01.899
（2）使用自定义格式
LocalDateTime date = LocalDateTime.now();
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");
String format = dtf.format(date);
System.out.println(date);
System.out.println(format);
运行结果
2019-07-31T11:37:12.673
2019年07月31日 11:37:12
注：自定义转化的格式一定要与日期类型对应
-
LocalDate只能设置仅含年月日的格式
-
LocalTime只能设置仅含时分秒的格式
-
LocalDateTime可以设置含年月日时分秒的格式
将时间字符串形式转化为日期对象
String datetime = "2018-01-13 21:27:30";
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
LocalDateTime ldt = LocalDateTime.parse(datetime, dtf);
System.out.println(ldt);
运行结果
2018-01-13T21:27:30
注：格式的写法必须与字符串的形式一样，否则会报运行时异常！
-
2018-01-13 21:27:30 对应 yyyy-MM-dd HH:mm:ss
-
20180113213328 对应 yyyyMMddHHmmss
时间日期前后的比较与判断
// 判断两个时间点的前后
LocalDate date1 = LocalDate.of(2017, 8, 8);
LocalDate date2 = LocalDate.of(2018, 8, 8);
boolean before = date1.isBefore(date2);
boolean after = date1.isAfter(date2);
System.out.println(before); // true
System.out.println(after); // false
判断是否为闰年，该年/该月有多少天
LocalDate date = LocalDate.of(2000, 2, 21);
System.out.println("date : " + date);
System.out.println("is leap year ? " + date.isLeapYear());
System.out.println("There are " + date.lengthOfYear() + " days in the current year");
System.out.println("There are " + date.lengthOfMonth() + " days in the current month.");
运行结果
date : 2000-02-21
is leap year ? true
There are 366 days in the current year
There are 29 days in the current month.
时间戳
事实上Instant就是java8以前的Date，可以使用以下两个类中的方法在这两个类型之间进行转换。
比如Date.from(Instant)就是用来把Instant转换成java.util.date的，而new Date().toInstant()就是将Date转换成Instant的
Instant instant = Instant.now();
System.out.println(instant);
Date date = Date.from(instant);
System.out.println(date);
Instant instant2 = date.toInstant();
System.out.println(instant2);
运行结果
2019-07-31T04:02:09.942Z
Wed Jul 31 12:02:09 GMT+08:00 2019
2019-07-31T04:02:09.942Z
LocalDateTime和Date的转换
// Date转换为LocalDateTime
Date date = new Date();
System.out.println(date);
Instant instant = date.toInstant();
System.out.println(instant);
LocalDateTime dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
System.out.println(dateTime);
// 链式
System.out.println(LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault()));
System.out.println("--------------------");
// LocalDateTime转换为Date
LocalDateTime now = LocalDateTime.now();
System.out.println(now);
ZonedDateTime atZone = now.atZone(ZoneId.systemDefault());
System.out.println(atZone);
Instant instant2 = atZone.toInstant();
System.out.println(instant2);
Date date2 = Date.from(instant2);
System.out.println(date2);
// 链式
System.out.println(Date.from(now.atZone(ZoneId.systemDefault()).toInstant()));
运行结果
Wed Jul 31 12:15:57 GMT+08:00 2019
2019-07-31T04:15:57.060Z
2019-07-31T12:15:57.060
2019-07-31T12:15:57.060
--------------------
2019-07-31T12:15:57.140
2019-07-31T12:15:57.140+08:00[GMT+08:00]
2019-07-31T04:15:57.140Z
Wed Jul 31 12:15:57 GMT+08:00 2019
Wed Jul 31 12:15:57 GMT+08:00 2019
计算时间、日期间隔
Duration：用于计算两个“时间”间隔
Period：用于计算两个“日期”间隔
// 计算两个日期的日期间隔-年月日
LocalDate date1 = LocalDate.of(2018, 2, 13);
LocalDate date2 = LocalDate.of(2017, 3, 12);
// 内部是用date2-date1，所以得到的结果是负数
Period period = Period.between(date1, date2);
System.out.println("相差年数 ： " + period.getYears());
System.out.println("相差月数 ： " + period.getMonths());
System.out.println("相差日数 ： " + period.getDays());
// 还可以这样获取相差的年月日
System.out.println("-------------------------------");
long years = period.get(ChronoUnit.YEARS);
long months = period.get(ChronoUnit.MONTHS);
long days = period.get(ChronoUnit.DAYS);
System.out.println("相差的年月日分别为 ： " + years + ", " + months + ", " + days);
// 注意，当获取两个日期的间隔时，并不是单纯的年月日对应的数字相加减，而是会先算出具体差多少天，在折算成相差几年几月几日的
// 计算两个时间的间隔
System.out.println("-------------------------------");
LocalDateTime date3 = LocalDateTime.now();
LocalDateTime date4 = LocalDateTime.of(2018, 1, 13, 22, 30, 10);
Duration duration = Duration.between(date3, date4);
System.out.println(date3 + " 与 " + date4 + " 间隔 " + "\n" + " 天 :" + duration.toDays() + "\n" + " 时 :"
+ duration.toHours() + "\n" + " 分 :" + duration.toMinutes() + "\n" + " 毫秒 :" + duration.toMillis()
+ "\n" + " 纳秒 :" + duration.toNanos() + "\n");
// 注意，并没有获得秒差的，但既然可以获得毫秒，秒就可以自行获取了
运行结果
相差年数 ： 0
相差月数 ： -11
相差日数 ： -1
-------------------------------
相差的年月日分别为 ： 0, -11, -1
-------------------------------
2019-07-31T12:20:56.624 与 2018-01-13T22:30:10 间隔
天 :-563
时 :-13525
分 :-811550
毫秒 :-48693046624
纳秒 :-48693046624000000
当计算程序的运行时间时，应当使用时间戳Instant
Instant ins1 = Instant.now();
for (int i = 0; i < 10000000; i++) {
// 循环一百万次
}
Instant ins2 = Instant.now();
Duration duration = Duration.between(ins1, ins2);
System.out.println("程序运行耗时为 ： " + duration.toMillis() + "毫秒");
long毫秒值转换为日期
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
long timeMillis = System.currentTimeMillis();
Instant instant = Instant.ofEpochMilli(timeMillis);
LocalDateTime dateTime = LocalDateTime.ofInstant(instant, ZoneId.of("Asia/Shanghai"));
String format = dtf.format(dateTime);
System.out.println(format);
