JavaSE-06-常见类的使用

特例：当用 equals()方法进行比较时，对类 File、String、Date 及包装类来说，是比较类型及内容而不考虑引用的是否是同一个实例；
用“ ==” 进行比较时，符号两边的数据类型必须一致(可自动转换的数据类型除外)，否则编译出错，而用 equals 方法比较的两个数据只要都是引用类型即可。

1.2：hashCode方法

hashCode 是按照一定的算法得到的一个数值，是对象的散列码值。主要用来在集合（后面
会学到）中实现快速查找等操作，也可以用于对象的比较。

如果两个对象相同，那么它们的 hashCode 值一定要相同；如果两个对象的hashCode 相同，它们并不一定相同

1.3：toString方法

toString()方法是 Object 类中定义的另一个重要方法，是对象的字符串表现形式

方法的返回值是 String 类型，用于描述当前对象的有关信息。Object 类中实现的toString() 方法是返回当前对象的类型和内存地址信息，但在一些子类（如 String, Date等）中进行了重写，也可以根据需要在用户自定义类型中重写 toString()方法，以返回更适用的信息。

对象类定义缺省的 toString()方法，它返回类名称和它的引用的地址（通常情况下不是很有用）。

2：Objects类

Object 是 Java 中所有类的基类，位于 java.lang 包。
Objects 是 Object 的工具类，位于 java.util 包。它从 jdk1.7 开始才出现，被final 修饰不能被继承，拥有私有的构造函数。

2.1：public static boolean equals(Object a,Object b)

Objects.equals 方法中已经做了非空判断，所以不会抛出空指针异常，它是null-save 空指针安全的，而且也可以简化代码。

2.2：public static int hashCode(Object o)

返回一个整型数值，表示该对象的哈希码值。若参数对象为空，则返回整数 0；若不为空，则直接调用了 Object.hashCode 方法。

2.3：public static String toString(Object o)

返回指定对象的字符串表示形式。如果参数为空对象 null，则返回字符串“null”。

2.4：public static String toString(Object o,String nullDefault)

返回指定对象的字符串表示形式。如果参数为空对象null，则返回第二个参数nullDefault所指定的对象。

2.5：public static boolean isNull(Object obj)

判空方法，如果参数为空则返回 true。

3：String类

3.1：String 的声明和创建

双引号括起来的字符序列就是 String 的直接量。实例:"John" 或"111222333"字符串赋值，可以在声明时赋值：

String color = "blue";

color 是 String 类型的引用。
"blue" 存在 String 常量池中，一旦定义值就不能改变，如果更改其值，只能是让变量指向新的内存空间。比如：

color = "red";

如果采用 new 的方法定义 String，那么是需要分配堆内存空间的，如下：
String str = new String("Hello");

String 的还有两个常用的构造方法：
String(byte[] arr) 使用一个字节数组 arr 创建一个字符串对象。
String(char[] arr) 使用一个字符数组 arr 创建一个字符串对象。

char[] arr={'H','e','l','l','o'};
String str = new String(arr);
//相当于
String str = new String("Hello")

String(char[] arr,int startIndex,int count) 提取字符数组 a 中的一部分
字符创建一个字符串对象，参数 startIndex 和 count 分别指定在 a 中提取字符的起始位置和从该位置开始截取的字符个数，例如：
char[] arr={'H','e','l','l','o'};
String str = new String(arr,1,3);
//相当于
String str = new String("ell");

3.2：String常用方法

3.2.1：public int length()

返回 String 的长度，是按照 char 返回的长度

3.2.2：public boolean equals(Object s)

【比较是否相等】比较两个 String 对象的实体是否相等，这个是区分大小写的。实际上就是依次比较其所包含的字符的数值大小。

3.3.3：public boolean equalsIgnoreCase(String s)

【忽略大小写比较是否相等】比较两个 String 对象的值是否相等，忽略大小写

3.3.4：public boolean startsWith(Stirng prefix)

【前缀开始】测试此字符串是否以指定的前缀开始。

3.3.5：public boolean startsWith(String prefix,int toffset)

【前缀开始】测试此字符串从指定索引开始的子字符串是否以指定前缀开始。

3.3.6：public boolean endsWith(String suffix)

【后缀结束】测试此字符串是否以指定的后缀结束。

3.3.7：public char charAt(int index)

【指定位置字符】获得字符串指定位置的字符。

3.3.8：public int indexOf(int ch)

【出现的索引】返回指定字符 ch /字符串 str在此字符串中第一次出现处的索引。

3.3.9：public int indexOf(int ch,int fromIndex)

【出现的索引】从指定的索引开始搜索，返回在此字符串中第一次出现指定字符处的索引，如果没有找到，则返回-1。

3.3.10：public int lastIndexOf(String str)

【最后出现的索引】返回指定子字符串在此字符串中最右边出现处的索引。laseIndexOf 有四中重载方法，用法和 indexOf 相似。

3.3.11：public String substring(int beginIndex)

【子字符串】返回新的字符串，它是当前字符串的子串。该子串从指定的位置开始，并一直到当前字符串结束为止。

3.3.12：public String substring(int beginIndex,int endIndex)

【子字符串】返回新的字符串，它是当前字符串的子串。该子串从指定的位置(beginIndex )开始，到指定的位置(endIndex - 1)结束。

3.3.13：public String trim()

【截去两边空格】返回新字符串，截去了源字符串最前面和最后面的的空白符；

3.3.14：public String replace(String target, String replacement)

【替换】返回一个新的字符串，它是将字符串中的所有 oldChar 替换成 newChar–源字符串没有发生变化

3.3.15：public String replaceAll(String regex, String replacement)

【替换】使用给定的 replacement 替换此字符串中所有匹配给定的正则表达式的子字符串。–源字符串没有发生变化

String s="java35java36java37";
//将数字全部换成 *号
String s2=s.replaceAll("\\d","*");// \\d 在正则表达式中表示数字
System.out.println(s2);//输出java**java**java**

3.3.16：public String toUpperCase( )

【转大写】返回对应的新字符串，所有小写字母都变为大写的，其它的不变。

3.3.17：public String toLowerCase （）

【转小写】返回对应的新字符串，所有大写字母都变为小写的，其它的不变。

3.3.18：public byte[] getBytes()

【转字节数组】使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。

3.3.19：public String[] split(String regex)

【拆分】根据给定正则表达式的匹配拆分此字符串，得到拆分好的字符串数组

3.3.20：public static String valueOf （参数列表）

【转字符串】将参数的值转化成相应的字符串。

4：正则表达式和String类

4.1：什么是正则表达式

正则表达式就是记录文本规则的代码。也是一个字符串的匹配表达式

4.2：Java中的正则表达式

在 Java 中的 String 类中有好几个方法都跟正则表达式有关，最典型的就是
public boolean matches(String regex)
判断此字符是否匹配给定的正则表达式。

使用这个方法来测试和运行上面学到的正则表达式，示例如下：

public class TestMain {

    public static void main(String[] args) {
        String str = "010-62972039";
        System.out.println("str是一个正确的电话号码？答案是：" +str.matches("0\\d{2}-\\d{8}"));
    }
}

运行结果：str 是一个正确的电话号码？答案是：true
注意：由于在 Java 里面“\”需要转义，应该变成“\\”。

4.2.1：java.util.regex.Pattern

Pattern 类是正则表达式的编译表示形式。
指定为字符串的正则表达式必须首先被编译为此类的实例。然后，可将得到的模式用于创建Matcher 对象，依照正则表达式，该对象可以与任意字符序列匹配。执行匹配所涉及的所有状态都驻留在匹配器中，所以多个匹配器可以共享同一模式

常见方法如下：
1：static Pattern compile(String expression)

编译正则表达，式字符串到 pattern 对象用以匹配的快速处理，参数:expression 正则表达式
flags 下列标志中的一个或多个：CASE_INSENSITIVE,UNICODE_CASE,MULTILINE,UNIX_LINES,DOTALL,and CANON_EQ

2：Matcher matcher(CharSequence input)
返回一个 matcher 对象，它可以用来在一个输入中定位模式匹配

3：String[] split(CharSequence input)
String[] split(CharSequence input, int limit)
将输入字符串分离成记号，并由 pattern 来指定分隔符的形式。返回记号数组。分隔符并不是记号的一部分。
参数:
input 分离成记号的字符串
limit 生成的最大字符串数。

4.2.2：java.util.regex.Matcher 类

Mathcer 类通过解释 Pattern 对字符序列执行匹配操作的引擎。常见方法如下：
1：boolean matches()：返回输入是否与模式匹配
2：boolean lookingAt()：如果输入的起始匹配模式则返回 True
3：boolean find()
4：boolean find(int start)：尝试查找下一个匹配，并在找到匹配时返回 True，参数:start 开始搜索的索引
5：int start()：返回当前匹配的起始位置位置
6：int end()：返回当前匹配的结尾后位置
7：String group()：返回当前匹配
8：int groupCount()：返回输入模式中的分组数
9：int start(int groupIndex)
10：int end(int groupIndex) 返回一个给定分组当前匹配中的起始位置和结尾后位置
参数:groupIndex 分组索引（从 1 开始），0 表示整个匹配
11：String group(int groupIndex)：返回匹配一个给定分组的字符串
参数:groupIndex 分组索引（从 1 开始），0 表示整个匹配

12：String replaceAll(String replacement) String replaceFirst(Stringreplacement)

返回从 matcher 输入得到的字符串，但已经用替换表达式替换所有或第一个匹配
参数:
replacement 替换字符串
Matcher reset()
Matcher reset(CharSequence input) 复位 mather 状态。

4.2.3：Java中的正则示例；

public class TestMain {

    public static void main(String[] args) {
        String str = "010-62972039";
        Pattern p = Pattern.compile("0\\d{2}-\\d{8}");
        Matcher m = p.matcher(str);
        boolean flag = m.matches();
        System.out.println("str是一个正确的电话号码？答案是：" + flag);
    }
}

4.3：元字符

代码	说明
.	匹配除换行符外任意字符
\w	匹配字符或数字或者下划线
\s	匹配任意空白字符
\d	匹配数字
\b	匹配字符串的开始或结束
^ $	匹配字符串的开始匹配字符串的结束

4.4：重复

代码	说明
*	重复零次或多次
+	重复一次或多次
？	重复零次或多次
{n}	重复n次
{n，}	重复n次或多次
{n，m}	重复n次到m次

[0-9]	代表0到9中的一个数字
[0 1 2 3 4]	0,1,2,3,4中的一个

4.5：常见的正则表达式

（1）检测是否 Email 地址

^([\\w-\\.]+)@((\\[[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.)|(([\\w-]+\\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\\]?)$

（2）判断输入的字符串只包含汉字

^[\u4e00-\u9fa5]+$

（3）匹配 3 位或 4 位区号的电话号码，其中区号可以用小括号括起来，也可以不用，区号与本地号间可以用连字号或空格间隔，也可以没有间隔

^\$0\\d{2}\$[-]?\\d{8}$|^0\\d{2}[-]?\\d{8}$|^\$0\\d{3}\$[-]?\\d{7}$|^0\\d{3}[-]?\\d{7}$

5：StringBuffer 类和 StringBuilder 类

StringBuffer 类的方法是多线程安全的（多线程的课程在后面会学习到），而StringBuilder 不是线程安全的，相比而言 StringBuilder 类会略微快一点。

5.1：StringBuffer 类（线程安全的）

String
–字符串(String)对象一旦创建，其内容不能再被修改 (read-only)
StringBuffer
–StringBuffer 对象的内容是可以被修改的
–除了字符的长度之外，还有容量的概念
–通过动态改变容量的大小，加速字符管理

5.1.1：StringBuffer的构造方法

StringBuffer buf1 = new StringBuffer();

创建空的 StringBuffer 对象，初始容量为 16 字符

StringBuffer buf2 = new StringBuffer( 容量 );
创建空的 StringBuffer 对象，指定容量大小。

StringBuffer buf3 = new StringBuffer( myString );
创建含有相应字符序列的 StringBuffer 对象，容量为 myString.length() +16

5.1.2：StringBuffer的常用方法

public int length()
【长度】返回 StringBuffer 的长度

public int capacity()
【容量】返回 StringBuffer 的容量

public char charAt(int index)
【指定位置字符】返回 StringBuffer 对象中指定位置的字符

public void setCharAt(int index, char ch)
【设置字符】设置 StringBuffer 对象中指定位置的字符

public void reverse()
将 StringBuffer 对象中的字符序列按逆序方式排列，可用作字符串倒序

public StringBuffer append(String str)
允许数值类型的值添加到 StringBuffer 对象中

public StringBuffer insert(int offset,String str)
允许将各种数据插到 StringBuffer 对象的指定位置

5.2：StringBuilder 类（线程不安全的）

StringBuilder 类是一个可变的字符序列。此类提供一个与 StringBuffer 兼容的API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。它的功能基本等同于 StringBuffer 类，就不再赘述了。

5.3:区别

既然 StringBuffer 是线程安全的，它的所有公开方法都是同步的，StringBuilder 是没有对方法加锁同步的，所以毫无疑问，StringBuilder 的性能要远大于 StringBuffer。

所以，StringBuffer 适用于用在多线程操作同一个 StringBuffer 的场景，如果是单线程场合 StringBuilder 更适合。

注：因为局部变量存在各自的帧栈中，所以局部变量是线程安全的，那么当全局变量使用时使用StringBuffer，当局部变量使用时就使用StringBuilder

6：Math类

Java 中的数学（Math）类是 final 类，不可继承。其中包含一组静态方法和两个常数

6.1：常数

PI ：double，圆周率
E ：double，自然对数

6.2：方法

public static double ceil(double d)
【天花板数】返回不小于 d 的最小整数

public static double floor(double d)
【地板数】返回不大于 d 的最大整数

public static long round(double d)
【四舍五入】返回四舍五入后的整数

public static double abs(double d)
返回绝对值

public static double min(double d1, double d2)
返回两个值中较小的值

public static double max(double d1, double d2)
返回两个值中较大的值

public static double log(double d)
自然对数

public static double exp(double d)
E 的指数

public static double random()
【随机数】返回随机数

7：日期相关的类

7.1：Date类

java.util 包里面的 Date 类，是 Java 里面进行日期操作常用类。Date 类用来表示特定的瞬间，精确到毫秒，以表示自从标准基准时间（称为“历元（epoch）“，即 1970 年 1 月 1 日00:00:00 格林威治时间）以来的指定毫秒数。

7.1.1：初始化Date

public Date( )

分配 Date 对象并初始化此对象，以表示分配它的时候的当前时间（精确到毫秒）。使用Date 类得到当前的时间。

public Date(long date)

分配 Date 对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch） “，即 1970年 1 月 1 日 00:00:00 格林威治时间）以来的指定毫秒数。

7.1.2：常用方法

public boolean after(Date when)：测试此日期是否在指定日期之后
public boolean before(Date when)：测试此日期是否在指定日期之前方法

getTime()返回自 1970年 1月1 日00:00:00 GMT以来此 Date 对象表示的毫秒数。

7.2：DateFormat 类和 SimpleDateFormat 类

DateFormat 是个抽象类，SimpleDateFormat 类是它的子类，所以下面就主要按照SimpleDateFormat 类来讲解。

7.2.1：初始化

SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");

7.2.2：日期和时间模式；

7.2.3：常用方法

public Date parse(String source)
【解析】从给定字符串的开始解析文本，以生成一个日期。

public String format(Date date)
【格式化】将一个 Date 格式化为日期/时间字符串。

7.3：Calendar 类---日历类

java.util 包中的 Calendar 类是 Java 里面另外一个常用的日期处理的类。Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法

7.3.1：初始化

Calendar 类是通过一个静态方法 getInstance()来获取 Calendar 实例。返回的Calendar 基于当前时间，使用了默认时区和默认语言环境如下：
Calendar c = Calendar.getInstance();

7.3.2：使用 Calendar 对日期部分进行解析

1：public int get(int field)
返回给定日历字段的值，例如年份、月份、小时、星期等信息，参数 field 的有效值由Calendar 得静态常量指定。

如：

public class TestMain {

    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();
        int year = calendar.get(Calendar.YEAR);
        System.out.println(""+year);
        int month = calendar.get(Calendar.MONTH);
        System.out.println(""+month);
        int day = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(""+day);
        int week = calendar.get(Calendar.DAY_OF_WEEK);
        System.out.println(""+week);
    }
}

7.3.3：使用 Calendar 进行日期运算

public void add(int field,int amount)
根据日历的规则，为给定的日历字段添加或减去指定的时间量。

如：

public class TestMain {

    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();
        int year = calendar.get(Calendar.YEAR);//2020
        calendar.add(1,Calendar.YEAR);
        int i = calendar.get(Calendar.YEAR);//2021
        System.out.println(""+i);
    }
}

7.3.4：Calendar和Date类的交互

public void setTime(Date date)
使用给定的 Date 设置此 Calendar 的当前时间。
public void setTimeInMillis(long millis)
用给定的 long 值设置此 Calendar 的当前时间值。

public class TestMain {

    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();
        //calendar向Date转换
        long timeInMillis = calendar.getTimeInMillis();
        Date date = new Date(timeInMillis);
        SimpleDateFormat sif = new SimpleDateFormat("yyyy-MM-dd");
        System.out.println(""+sif.format(date));
        //data向Calendar转换
        calendar.setTime(date);
        
    }
}

7.4：Java8的新日期类

java8 引入了一套全新的时间日期 API，java.time 包中的类是不可变且线程安全的。新的时间及日期 API 位于 java.time 中，下面是一些关键类:

7.4.1：Instant:表示时间戳

public static Instant now()
从系统时钟获得当前时刻一个 Instant 对象里有两个域：距离初始时间的秒钟数、在当前一秒内的第几纳秒，他们的组合表达了当前时间点。你可以通过以下两个方法得到它们的值：

public long getEpochSecond()
获取距1970-01-01 0:0:0的的秒数
public int getNano()
从当前一秒开始，从时间线上获取纳秒数。

关于计算

public Instant plusSeconds(long secondsToAdd)
返回此瞬间的副本，以指定的持续时间以秒为单位添加
public Instant minusSeconds(long secondsToSubtract)
返回此瞬间的副本，以秒为单位减去指定的持续时间

实例：

public class TestMain {

    public static void main(String[] args) {
        Instant instant = Instant.now();
        System.out.println(""+instant); //15:44:37.147
        Instant instant1 = instant.plusSeconds(2);
        System.out.println(""+instant1);//15:44:39.147

    }
}

7.4.2：LocalDateTime---当前时区的日期和时间

public static LocalDateTime now()
从默认时区中的系统时钟获取当前日期时间。

public class TestMain {

    public static void main(String[] args) {
        LocalDateTime dateTime = LocalDateTime.now();
        System.out.println(""+dateTime);//2020-06-08T23:47:09.834
    }
}

public static LocalDateTime of(int year, int month, int dayOfMonth, int hour, int minute, int second)
从年、月、日、时、分、秒获得LocalDateTime的实例。

default long toEpochSecond(ZoneOffset offset)
将此日期时间对象转换为自 1970-01-01T0:00:0Z 时代的秒数，参数为时区，如：ZoneOffset.of("+8")

使用 DateTimeFormatter 工具类将日期时间对象转换成字符串

public class TestMain {

    public static void main(String[] args) {
        LocalDateTime dateTime = LocalDateTime.now();
        System.out.println(""+dateTime);//2020-06-08T23:47:09.834
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String format = dateTimeFormatter.format(dateTime);
        System.out.println("转成String类型的格式："+format);//2020-06-08 23:52:00
    }
}

使用 DateTimeFormatter 工具类将字符串转换成日期时间对象

public class TestMain {

    public static void main(String[] args) {
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        LocalDateTime parse = LocalDateTime.parse("2020-06-08 08:08:08",dateTimeFormatter);
        System.out.println(""+parse);

    }
}

通过LocalDateTime 单独获取年，月，日

LocalDateTime localDateTime = LocalDateTime.now();
System.out.println(localDateTime.getHour());

7.4.3：LocalDate---不包含具体时间的日期，比如 2020-02-14

public static LocalDate now()
从默认时区的系统时钟获取当前日期。

//静态工厂方法now，获取当前日期
LocalDate today=LocalDate.now();
System.out.println("今天的日期是："+today);
//输出：今天的日期是：2020-06-06

public static LocalDate of(int year,int month,int dayOfMonth)
从某年，某月和某天获得 LocalDate 的实例。

LocalDate dateOfBirth=LocalDate.of(1998, 4, 24);
System.out.println("你的生日 "+dateOfBirth);
//输出：你的生日 1999-04-24

public int getYear()
获取年份字段。
public int getMonthValue()
将一个月作为int从1到12返回。
public int getDayOfYear()
获得日期字段。

public LocalDate plus(long amountToAdd,TemporalUnit unit)
public LocalDate plusYears(long yearsToAdd)
public LocalDate plusMonths(long monthsToAdd)
public LocalDate plusWeeks(long weeksToAdd)
public LocalDate plusDays(long daysToAdd)
返回此LocalDate的副本，并附加指定的数值

public class TestMain {

    public static void main(String[] args) {
        LocalDate localDate = LocalDate.now();
        LocalDate localDate1 = localDate.plusDays(3);//3天后
    }
}

7.4.4：LocalTime---不含日期的时间

public static LocalTime now()
public static LocalTime of(int hour,int minute)
public static LocalTime of(int hour,int minute,int second)
public static LocalTime from(TemporalAccessor temporal)

增加日期运算：

public LocalTime plusHours(long hoursToAdd)
public LocalTime plusMinutes(long minutesToAdd)
public LocalTime plusSeconds(long secondstoAdd)

基本和上述类型一样

7.4.5：ZonedDateTime---具有时区的日期时间的表示

//使用默认时区创建日期对象
ZonedDateTime zdt=ZonedDateTime.now();
//转换成美国纽约时区
ZonedDateTime zdt2 = zdt.withZoneSameInstant(ZoneId.of("America/New_York"));
System.out.println(zdt);
System.out.println(zdt2);

7.4.6:MonthDay---月和日组合的日期，不包含年份和具体时间。

public static MonthDay now()
public static MonthDay of(int month,int dayOfMonth)
public static MonthDay from(TemporalAccessor temporal) 获取一个MonthDay的实例

7.4.7:YearMonth---年和月组合的日期，不包含日和具体时间。

public static YearMonth now()
public static YearMonth of(int year,int month)
public static YearMonth from(TemporalAccessor temporal)
获取一个YearMonth的实例

7.5：新旧日期的换算；

7.5.1 Date-->LocalDateTime

public class TestMain {

    public static void main(String[] args) {
        // 创建Date日期对象
        java.util.Date date = new java.util.Date();
        // 将Date日期对象转换成Instant时间戳
        Instant instant = date.toInstant();
        // 取得操作系统默认的时区
        ZoneId zone = ZoneId.systemDefault();
        // 通过时间戳和时区，生成LocalDateTime对象
        LocalDateTime localDateTime = LocalDateTime.ofInstant(instant, zone);
    }
}

7.5.2：Date-->LocalDate

public class TestMain {

    public static void main(String[] args) {
        // 创建Date日期对象
        java.util.Date date = new java.util.Date();
        // 将Date日期对象转换成Instant时间戳
        Instant instant = date.toInstant();
        // 取得操作系统默认的时区
        ZoneId zone = ZoneId.systemDefault();
        // 通过时间戳和时区，生成LocalDateTime对象
        LocalDateTime localDateTime = LocalDateTime.ofInstant(instant, zone);
        LocalDate localDate = localDateTime.toLocalDate();
    }
}

7.5.3：Date-->LocalTime

public class TestMain {

    public static void main(String[] args) {
        // 创建Date日期对象
        java.util.Date date = new java.util.Date();
        // 将Date日期对象转换成Instant时间戳
        Instant instant = date.toInstant();
        // 取得操作系统默认的时区
        ZoneId zone = ZoneId.systemDefault();
        // 通过时间戳和时区，生成LocalDateTime对象
        LocalDateTime localDateTime = LocalDateTime.ofInstant(instant, zone);
        LocalTime localTime = localDateTime.toLocalTime();
    }
}

7.5.4：LocalDateTime-->Date

public class TestMain {

    public static void main(String[] args) {
        // 创建LocalDateTime日期对象
        LocalDateTime localDateTime = LocalDateTime.now();
        // 取得操作系统默认的时区
        ZoneId zone = ZoneId.systemDefault();
        // 为LocalDateTime日期对象设置时区，再转换的时间戳Instant对象
        Instant instant = localDateTime.atZone(zone).toInstant();
        // 将时间戳Instant对象转换成Date对象
        Date from = Date.from(instant);
    }
}

7.5.5：LocalDate-->Date

public class TestMain {

    public static void main(String[] args) {
        // 创建LocalDate日期对象
        LocalDate localDate = LocalDate.now();
        // 取得操作系统默认的时区
        ZoneId zone = ZoneId.systemDefault();
        // 为LocalDateTime日期对象设置时区，再转换的时间戳Instant对象
        Instant instant = localDate.atStartOfDay().atZone(zone).toInstant();
        // 将时间戳Instant对象转换成Date对象
        Date from = Date.from(instant);
    }
}

7.5.6：LocalTime-->Date

public class TestMain {

    public static void main(String[] args) {
        // 创建LocalTime对象
        LocalTime localTime = LocalTime.now();
        // 创建LocalDate对象
        LocalDate localDate = LocalDate.now();
        // 将LocalDate对象和LocalTime对象生成LocalDateTime对象
        LocalDateTime localDateTime = LocalDateTime.of(localDate, localTime);
        // 取得操作系统默认的时区
        ZoneId zone = ZoneId.systemDefault();
        // 为LocalDateTime日期对象设置时区，再转换的时间戳Instant对象
        Instant instant = localDateTime.atZone(zone).toInstant();
        // 将时间戳Instant对象转换成Date对象
        java.util.Date date = Date.from(instant);
    }
}

7.5.7：总结

8：基本类型包装类

借助于非面向对象技术的做法有时也会带来不便，比如引用类型数据均继承了 Object类的特性，要转换为 String 类型（经常有这种需要）时只要简单调用 Object 类中定义的toString()即可，而基本数据类型转换为 String 类型则要麻烦得多。为解决此类问题，Java 语言引入了封装类的概念，在 JDK 中针对各种基本数据类型分别定义相应的引用类型，并称之为包装类（Wrapper Classes）。