Java常用类
Object和Objects类
toString()方法
用来返回当前对象本身的有关信息，默认的是返回对象所在的类名和哈希码的16进制表示。一般需要重写toString()方法获取该对象的字段名和值
equals()方法
equals()方法在没有重写时与 == 功能相当，比较的是引用数据类型里存放的地址
一般要对equals()方法进行重写，以便比较对象的内容
Java在对象进行内容比较时用Objects.equals()比直接使用对象的equals()方法比较更安全。
假设有以下情况：
String name = null;
System.out.println(name.equals("123")); // 会报空指针异常，不会检测name和被比较字符串（123）是否引用为空
System.out.println(Objects.equals(name, "123")); // 会先检测name是否为空再用Object类的equals进行比较
// Objects.equals源码：
public static boolean equals(Object a, Object b) {
return (a == b) || (a != null && a.equals(b));
// 利用多态调用重写后的equals方法
}
getClass()方法
返回一个名为Class的对象，该对象提供了调用getClass()方法的对象的类的相关信息。
返回结果示例：class com.common.Demo01
StringBuilder和StringBuffer类
一个字符串的内容需要被经常改变时就要使用StringBuilder或StringBuffer类
StringBuilder是处理字符串的手段，最后的目的是转换成String
支持链式编程
StringBuilder sb = new StringBuilder();
sb.append("123").reverse().append("123");// sb: "321123"
StringBuilder如何提高效率：
如上图所示，如果使用String用加号进行拼接操作，由于String是只读字符串，它并不是基本数据类型，而是一个对象。从底层源码来看是一个final类型的字符数组，所引用的字符串不能被改变，一经定义，无法再增删改。每次对String的操作都会生成新的String对象。
每次 + 操作都隐式地在堆上new了一个跟原字符串相同的StringBuilder对象，再调用append方法拼接加号后面的字符，最后需要新建四个对象才能完成拼接。而使用StringBuilder只需要一个对象就可以完成拼接，如下图所示：
StringBuffer和StringBuilder的区别
StringBuffer 对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder并没有对方法进行加同步锁，所以是非线程安全的。
Math类
Math类是数学工具类，提供了一系列的数学操作方法，包括求绝对值、三角函数等，Math类没有公开的构造方法，不能创建对象。在Math类中提供的一切方法都是静态方法，所以直接由类名称调用即可。
public static void main(String[] args) {
System.out.println("求绝对值: " + Math.abs(-1));
System.out.println("求平方根：" + Math.sqrt(9.0)) ;
System.out.println("求两数的最大值：" + Math.max(10,30)) ;
System.out.println("求两数的最小值：" + Math.min(10,30)) ;
System.out.println("2的3次方：" + Math.pow(2,3));
System.out.println("求大于参数的最小整数: " + Math.ceil(5.6));
System.out.println("求小于参数的最大整数: " + Math.floor(-4.2));
System.out.println("四舍五入：" + Math.round(33.6));
System.out.println("生成一个大于等于0.0小于1.0随机值: " + Math.random());
}
System类
System类是一个特殊类，它是一个公共最终类，不能被继承，也不能被实例化，即不能创建System类的对象。
System类的常用方法
public static long currentTimeMillis( )
//返回自从1970年1月1日午夜起到现在的时间，时间单位是毫秒。
public static void arraycopy(a1,int sourceStart,a2,int targetStart,int size)
//将数组a1从下标sourceStart开始，长度为size的元素依次复制到数组a2的以targetStart为起始的单元中。
public static void exit(int status)
//在用户的程序还未执行完之前，强制关闭Java虚拟机的方法，并把状态信息status 返回给运行虚拟机的操作系统。
大数操作类
在Java中提供了大数字操作类，java.math.BigInteger类与java.math.BigDecimal类，这两个类用于高精度计算，前者用于大整数的处理类，后者类用于大小数的处理类。
BigInteger类
BigInteger对象创建
可以使用BigInteger类的构造方创建一个十进制的BigInteger类对象，语法格式如下：
public BigInteger(String val)
其中val是十进制字符串。
BigInteger类的常用方法表
BigDecimal类
浮点型运算精度失真案例：
public static void main(String[] args) {
// 浮点型运算的时候直接 + - * / 可能会出现精度问题
System.out.println(0.09 + 0.01); // 0.09999999999999999
System.out.println(1.0 - 0.32); // 0.6799999999999999
System.out.println(1.015 * 100); // 101.49999999999999
System.out.println(1.301 / 100); // 0.013009999999999999
}
禁止使用构造方法 BigDecimal(double) 的方式把 double 值转化为 BigDecimal 对象。
说明：BigDecimal(double) 存在精度损失风险，在精确计算或值比较的场景中可能会导致业务逻辑异常。
如： BigDecimal g = new BigDecimal(0.1F)；实际的存储值为：0.100000001490116119384765625
要解决精度丢失问题，优先推荐入参为 String 的构造方法，或使用 BigDecimal 的 valueOf 方法，此方法内部其实执行了 Double 的 toString，而 Double 的 toString 按 double 的实际能表达的精度对尾数进行了截断。
BigDecimal recommend1 = BigDecimal.valueOf(0.1); // 推荐做法
BigDecimal recommend2 = new BigDecimal("0.1");
BigDecimal类的常用方法
BigDecimal类中的divide()方法有多种设置，用于返回商末位小数点的处理，这些模式的含义和名称如下表所示：
System.out.println(3.33+5.3);
System.out.println(BigDecimal.valueOf(3.33).add(BigDecimal.valueOf(5.3)).doubleValue());
日期与时间类
Date类
// 输出1小时121秒后的时间
public static void main(String[] args) {
/*
无参构造Date()：分配 Date 对象并初始化此对象，分配当前时间（精确到毫秒）
有参构造Date(long date)：分配 Date 对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。
*/
Date date = new Date();
Date date1 = new Date(System.currentTimeMillis());
System.out.println("当前时间为：" + date); // 调用Date类的toString()方法，输出： 当前时间为：Fri Jul 29 17:57:30 CST 2022
date.setTime(date.getTime() + 3721000L);
/* setTime()：设置date对象时间（时间毫秒值）
getTime()：获取date对象时间（时间毫秒值）
*/
System.out.println("1h 121s after: " + date);
// 输出：1h 121s after: Fri Jul 29 18:59:31 CST 2022
}
SimpleDateFormat类
作用：
1、对Date对象或时间毫秒值格式化成我们喜欢的时间形式
格式化时间毫秒值使用format()方法
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年M月dd日 HH:mm:ss", Locale.SIMPLIFIED_CHINESE);
/*
字母的数量可随意组合，如：yy年M月d日
Locale:设置不同地区
*/
System.out.println(sdf.format(new Date())); // 输出：2022年7月31日 01:02:41
2、把字符串的时间形式解析成日期对象
解析字符串使用parse()方法
date.setTime(sdf.parse("2021年8月6日 11:11:11").getTime());
System.out.println(sdf.format(date));
注意：被解析时间字符串的形式必须与初始化sdf对象的形式完全一样，否则会报错
3、比较两个时间的先后关系用before()和after()方法
Calendar类
Calendar类用于完成日期和时间字段的操作，它可以通过特定的方法设置和读取日期的特定部分，比如年、月、日、时、分和秒等。
Calendar类是一个抽象类，不可以被实例化，在程序中需要调用其静态方法getInstance()来取得一个Calender对象，然后调用其相应方法
Calendar rightNow = Calendar.getInstance();
作用：
1、利用Calender类获取日期和时间
使用get(int field)方法（field是常量）和getTimeInMillis()方法（时间毫秒值）
int year = rightNow.get(Calendar.YEAR); // 获取当前年份
int month = rightNow.get(Calendar.MONTH) + 1; // 获取当前月份
int date = rightNow.get(Calendar.DATE); // 获取当前日
int hour = rightNow.get(Calendar.HOUR_OF_DAY); // 获取时
int minute = rightNow.get(Calendar.MINUTE); // 获取分
int second = rightNow.get(Calendar.SECOND); // 获取秒
System.out.println("当前时间为:" + year + "年 " + month + "月 " + date + "日 "+ hour + "时 " + minute + "分 " + second + "秒");
2、设置及修改时间
使用set()和add()方法
add(int field, int amount)
set(int year, int month, int date, int hourOfDay, int minute, int second)
JDK8新增日期时间API
特性
- 不变性：新的日期/时间API中，所有的类都是不可变的，这对多线程很有好处。
- 关注点分离：借鉴了Joda库的一些优点，新的API将人可读的日期时间和机器时间（unix timestamp）明确分离，它为日期（Date）、时间（Time）、日期时间（DateTime）、时间戳（unix timestamp）以及时区定义了不同的类。
- 清晰：在所有的类中，方法都被明确定义用以完成相同的行为。例如要拿到当前实例我们可以使用now()方法，在所有的类中都定义了format()和parse()方法，而不是像以前那样专门有一个独立的类。为了更好的处理问题，所有的类都使用了工厂模式和策略模式，一旦你使用了其中某个类的方法，与其他类协同工作并不困难。
- 实用操作：所有新的日期/时间API类都实现了一系列方法用以完成通用的任务，如：加、减、格式化、解析、从日期/时间中提取单独部分，等等。
Java8日期时间的默认格式如下：yyyy-MM-dd HH-mm-ss.zzz
几个主要的核心类
- LocalDate：日期类，不带时间
- LocalTime：时间类，不带日期
- LocalDateTime：日期和时间类
- ZonedDateTime：时区日期时间类
- OffsetDateTime：按UTC时间偏移来得到日期时间
- Clock：获取某个时区下当前的瞬时时间，日期或者时间
- Instant：Unix时间，代表时间戳，比如
2018-01-14T02:20:13.592Z - Duration：两个时间之间，表示一个绝对的精确跨度，使用毫秒为单位
- Period：两个日期之间
- ZoneId：时区
- DateTimeFormatter：格式化输出
- TemporalAdjusters：获得指定日期时间等，如当月的第一天、今年的最后一天等等
下面看看这些类具体如何使用
LocalDate、LocalTime、LocalDateTime
LocalDate是不变的日期时间对象代表一个日期，往往被视为年月日。其他日期字段，如一年中的一天，一周和一周的一天，也可以访问。例如，“2007年10月2日”的值可以被存储在一个LocalDate。
LocalTime是不变的日期时间对象代表一个时间，往往被视为小时分钟秒。时间为代表的纳秒级精度。例如，值“13:45.30.123456789”可以存储在一个LocalTime。
LocalDateTime是不变的日期时间对象代表一个日期时间，往往被视为年、月、日、时、分、秒。其他日期和时间字段，如一年中的一天，一周和一周的一天，也可以访问。时间为代表的纳秒级精度。例如，值“2007年10月2日在13:45.30.123456789”可以存储在一个LocalDateTime。
//now()在默认时区中从系统时钟获取当前日期。
LocalDate today = LocalDate.now();
LocalDate nextWeek = today.plus(1, ChronoUnit.WEEKS); //等价于 today.plusWeeks(1)
//of(int year, int month, int dayOfMonth) 获得 LocalDate实例从一年、月、日。
LocalDate date = LocalDate.of(2019,5,31);
LocalTime time = LocalTime.of(20,31,20);
//of(LocalDate date, LocalTime time) 获得 LocalDateTime实例的日期和时间。
LocalDateTime dateTime = LocalDateTime.of(date,time);
System.out.println(dateTime);
//LocalDate结合LocalTime成一个LocalDateTime
LocalDateTime dateTime2 = date.atTime(time);
System.out.println(dateTime2); //2019-05-31T20:31:20
DateTimeFormatter
格式器用于解析日期字符串和格式化日期输出，创建格式器最简单的方法是通过 DateTimeFormatter 的静态工厂方法以及常量。创建格式器一般有如下三种方式：
- 常用 ISO 格式常量，如 ISO_LOCAL_DATE
- 字母模式，如 ofPattern("yyyy/MM/dd")
- 本地化样式，如 ofLocalizedDate(FormatStyle.MEDIUM)
和旧的 java.util.DateFormat 相比较，所有的 DateTimeFormatter 实例都是线程安全的。
使用DateTimeFormatter完成格式化
//获取默认时区中从系统时钟获取当前日期时间。
LocalDateTime localDateTime = LocalDateTime.now();
//创建一个格式化程序使用指定的模式。
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String formatDateTime = localDateTime.format(formatter);
System.out.println(formatDateTime);
//DateTimeFormatter提供了一些默认的格式化器，DateTimeFormatter.ISO_LOCAL_DATE_TIME 格式 yyyy-MM-ddTHH:mm:ss.SSS
String dateTime2 = localDateTime.format(DateTimeFormatter.ISO_LOCAL_DATE_TIME);
System.out.println(dateTime2);
使用DateTimeFormatter完成解析字符串
//获得 LocalDate实例,从使用特定格式的文本字符串解析，文字使用格式化程序解析，返回一个日期。
LocalDate localDate = LocalDate.parse("2018/11/11",DateTimeFormatter.ofPattern("yyyy/MM/dd"));
System.out.println(localDate); //2018-11-11
Instant
Instant 表示时间线上的一点（与 Date 类似），它只是简单地表示自 1970 年 1 月 1 日 0 时 0 分 0 秒（UTC）开始的秒数。
Instant 由两部分组成，一是从原点开始到指定时间点的秒数 s， 二是距离该秒数 s 的纳秒数。它以 Unix 时间戳的形式存储日期时间，不提供处理人类意义上的时间单位（年月日等）。
你可以通过Instant类的工厂方法创建一个Instant实例
//调用instant.now()来创建一个确切的表达当前时间的Instant对象.另外也有一些其它方法能创建Instant，具体请查阅Java官方文档。
Instant now = Instant.now();
Instant later = now.plusSeconds(3);
Instant earlier = now.minusSeconds(3);
//第一个参数是秒，第二个是纳秒参数，纳秒的存储范围是0至999,999,999
//2s之后的在加上100万纳秒（1s）
Instant instant = Instant.ofEpochSecond(2,1000000000);
System.out.println(instant); //1970-01-01T00:00:03Z
Instant instant1 = Instant.now();
System.out.println(instant1); //2019-05-31T16:19:28.719Z
Instant instant2 = Instant.parse("2018-11-11T10:12:35.342Z");
System.out.println(instant2); //2018-11-11T10:12:35.342Z
//java.util.Date与Instant可相互转换
Instant timestamp = new Date().toInstant();
Date.from(Instant.now());
//为了更好的显示，代码改写为
Date date = new Date();
Instant timestamp = date.toInstant();
System.out.println(date);
System.out.println(timestamp);
Instant now1 = Instant.now();
Date date1 = Date.from(now1);
System.out.println(now1);
System.out.println(date1);
//输出结果
Sat Jun 01 00:29:42 GMT+08:00 2019
2019-05-31T16:29:42.566Z
2019-05-31T16:29:42.588Z
Sat Jun 01 00:29:42 GMT+08:00 2019
Clock
Clock用于查找当前时刻，可以用来获取某个时区下当前的日期和时间，也可以用来代替旧的System.currentTimeMillis()方法和TimeZone.getDefault()方法。
//返回系统默认时间
Clock clock = Clock.systemDefaultZone();
System.out.println(clock.instant().toString());
//世界协调时UTC
Clock clock = Clock.systemUTC();
//通过Clock获取当前时刻
System.out.println("当前时刻为：" + clock.instant());
//获取clock对应的毫秒数，与System.currentTimeMillis()输出相同
System.out.println(clock.millis());
System.out.println(System.currentTimeMillis());
Duration
一个Duration实例是不可变的，当创建出对象后就不能改变它的值了。你只能通过Duration的计算方法，来创建出一个新的Durtaion对象。一个Duration对象表示两个Instant间的一段时间。
创建Duration实例，使用Duration类的工厂方法来创建一个Duration对象
Instant first = Instant.now();
// wait some time while something happens
Instant second = Instant.now();
Duration duration = Duration.between(first, second);
//获得Duration表示秒数，然后获得在此期间的分钟数、小时数、天数
Duration d = Duration.ofSeconds(6000);
System.out.println("6000秒相当于" + d.toMinutes() + "分");
System.out.println("6000秒相当于" + d.toHours() + "小时");
System.out.println("6000秒相当于" + d.toDays() + "天");
访问Duration的时间
一个Duration对象里有两个域：纳秒值（小于一秒的部分），秒钟值（一共有几秒），他们的组合表达了时间长度。注意与使用System.getCurrentTimeMillis()时不同，Duration不包含毫秒这个属性。
你可以通过以下两个方法得到它们的值：getSeconds()和getNano()
Period
Period 是以年月日来衡量一个时间段，用于计算两个日期间隔，所以 between() 方法只能接收 LocalDate 类型的参数。
LocalDate start = LocalDate.of(2018, Month.JANUARY, 1);
LocalDate end = LocalDate.of(2020, Month.NOVEMBER, 11);
System.out.println("相隔月数："+Period.between(start, end).getMonths());
System.out.println("相隔天数："+Period.between(start, end).getDays());
//输出结果
相隔月数：10
相隔天数：10
值得注意的是，Period 得到的是差值的绝对值（对应年月日直接计算数学上的差值），而并不表示真正的区间距离。
long distanceMonth = start.until(end, ChronoUnit.MONTHS);
long distanceDay= start.until(end, ChronoUnit.DAYS);
System.out.println("相隔月数"+distanceMonth);
System.out.println("相隔天数"+distanceDay);
//输出结果
相隔月数：34
相隔天数：1045
ZonedDateTime和ZonedId
ZonedDateTime类是Java 8中日期时间功能里，用于表示带时区的日期与时间信息的类。ZonedDateTime 类的值是不可变的，所以其计算方法会返回一个新的ZonedDateTime 实例。
Java 使用 ZoneId 来标识不同的时区，从基准 UTC 开始的一个固定偏移。
创建一个ZonedDateTime实例
//使用当前时间作为值新建对象
ZonedDateTime dateTime = ZonedDateTime.now();
//使用指定的年月日、时分、纳秒以及时区ID来新建对象
//时区是用ZoneId类表示的，可以使用ZoneId.now()或ZoneId.of(“xxx”)来实例化：
//传给of()方法的参数是时区的ID，如“UTC+1”指距离UTC（格林威治时间）有一小时的时差
ZoneId zoneId = ZoneId.of("UTC+1");
ZonedDateTime dateTime2 = ZonedDateTime.of(2019, 6, 1, 14, 40, 48, 1234, zoneId);
//也可以使用另一种方式表示zone id，即使用地区名字
ZoneId zoneId2 = ZoneId.of("Europe/Copenhagen");
//GregorianCalendar与ZonedDateTime相互转换
ZonedDateTime zonedDateTime = new GregorianCalendar().toZonedDateTime();
GregorianCalendar.from(zonedDateTime);
TemporalAdjusters
有的时候，你需要进行一些更加复杂的操作，比如，将日期调整到下个周日、下个工作日，或者是本月的最后一天。
简单应用例子
LocalDate localDate = LocalDate.now();
// 1. 本月第一天
LocalDate firstDayOfMonth = localDate.with(TemporalAdjusters.firstDayOfMonth());
// 2. 本月最后一天
LocalDate lastDayOfMonth = localDate.with(TemporalAdjusters.lastDayOfMonth());
// 3. 本年第一天
LocalDate firstDayOfYear = localDate.with(TemporalAdjusters.firstDayOfYear());
// 4. 下个月第一天
LocalDate firstDayOfNextMonth = localDate.with(TemporalAdjusters.firstDayOfNextMonth());
// 5. 本年度最后一天
LocalDate lastDayOfYear = localDate.with(TemporalAdjusters.lastDayOfYear());
System.out.println(firstDayOfMonth);
System.out.println(lastDayOfMonth);
System.out.println(firstDayOfYear);
System.out.println(firstDayOfNextMonth);
System.out.println(lastDayOfYear);
这时，你可以使用重载版本的with方法，向其传递一个提供了更多定制化选择的TemporalAdjuster对象,更加灵活地处理日期。TemporalAdjusters类通过静态方法提供了大量的常用的TemporalAdjuster的实现供我们使用。
/**
* 时间校正器TemporalAdjuster
*/
@Test
public void Test() {
LocalDateTime now1 = LocalDateTime.now();
//获取月中的第一天
now1.with(TemporalAdjusters.firstDayOfMonth());
//获取下一年的第一天
now1.with(TemporalAdjusters.firstDayOfNextYear());
//获取年中第一天
now1.with(TemporalAdjusters.lastDayOfYear());
//获取月中最后一天
now1.with(TemporalAdjusters.lastDayOfMonth());
//获取下个星期一
now1.with(TemporalAdjusters.next(DayOfWeek.MONDAY));
//自定时时间：下一个工作日，因为这里需要一个接口，所以完全可以自定义方法
now1.with((e) -> {
LocalDateTime now = (LocalDateTime)e;
DayOfWeek dow = now.getDayOfWeek();
if (dow.equals(DayOfWeek.FRIDAY))
return now.plusDays(3);
else if (dow.equals(DayOfWeek.SATURDAY))
return now.plusDays(2);
return now.plusDays(1);
});
}
转换
java.util.Date 与 LocalDate、LocalTime、LocalDateTime 转换
将Date转换为LocalDate，LocalTime，LocalDateTime可以借助于ZonedDateTime和Instant，实现如下：
Date date = new Date();
System.out.println("current date: " + date);
// Date -> LocalDateTime
LocalDateTime localDateTime = date.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
System.out.println("localDateTime by Instant: " + localDateTime);
// Date -> LocalDate
LocalDate localDate = date.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
System.out.println("localDate by Instant: " + localDate);
// Date -> LocalTime
LocalTime localTime = date.toInstant().atZone(ZoneId.systemDefault()).toLocalTime();
System.out.println("localTime by Instant: " + localTime);
//2. Date -> LocalDateTime
localDateTime = LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
System.out.println("localDateTime by ofInstant: " + localDateTime);
由于JDK8实现了向下兼容，所以Date里在JDK8版本引入了2个方法，from和
toInstant，所以我们可以借助这两个方法来实现LocalDateTime到Date的转换。将LocalDateTime转为Date如下：
LocalDateTime localDateTime = LocalDateTime.now();
System.out.println("localDateTime: " + localDateTime);
// LocalDateTime -> Date
Date date = Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());
System.out.println("LocalDateTime -> current date: " + date);
// LocalDate -> Date，时间默认都是00
LocalDate localDate = LocalDate.now();
date = Date.from(localDate.atStartOfDay(ZoneId.systemDefault()).toInstant());
System.out.println("LocalDate -> current date: " + date);
日期与字符串的转换
通过LocalDate，LocalTime，LocalDateTime的parse方法和DateTimeFormatter来实现：
//字符串->日期
LocalDate localDate = LocalDate.parse("2018-09-09", DateTimeFormatter.ofPattern("yyyy-MM-dd"));
LocalDateTime localDateTime = LocalDateTime.parse("2018-09-10 12:12:12", DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
//日期->字符串
String localDate = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
String localDateTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
// 也可以通过DateTimeFormatter的format方法
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
localDateTime = dateTimeFormatter.format(LocalDateTime.now());
时间戳与LocalDateTime转换
具体实现如下：
//时间戳->LocalDateTime
public static LocalDateTime convertToDate(long timestamp) {
// ofEpochSecond 以秒为单位， ofEpochMilli 以毫秒为单位
// Instant.ofEpochSecond(timestamp);
Instant instant = Instant.ofEpochMilli(timestamp);
return LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
}
//LocalDateTime->时间戳
public static long convertToTimestamp() {
LocalDateTime localDateTime = LocalDateTime.now();
return localDateTime.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();
}
总结
- 所有新的日期时间 API 类都实现了一系列方法用以完成通用的任务，如：加、减、格式化、解析、从日期/时间中提取单独部分。
- Java 8 中新的时间与日期 API 中的所有类都是不可变且线程安全的，任何修改操作都会返回一个新的实例。
- 新的 API 区分各种日期时间概念并且各个概念使用相似的方法定义模式，这种相似性非常有利于 API 的学习。总结一下一般的方法或者方法前缀：
- of：静态工厂方法，用于创建实例
- now：静态工厂方法，用当前时间创建实例
- parse：静态工厂方法，从字符串解析得到对象实例
- get：获取时间日期对象的部分状态。
- is：检查某些东西的是否是 true，例如比较时间前后
- with：返回一个部分状态改变了的时间日期对象拷贝
- plus：返回一个时间增加了的、时间日期对象拷贝
- minus：返回一个时间减少了的、时间日期对象拷贝
- to：转换到另一个类型
- at：把这个对象与另一个对象组合起来，例如 date.atTime(time)
- format：提供格式化时间日期对象的能力
参考：全面解析Java日期时间API - 1s_kiwen - 博客园 (cnblogs.com)
包装类
包装类对应着8种基本数据类型的引用类型（实现Java一切皆对象）
特性：
- 自动装箱和自动拆箱
Integer integer = 1; // 自动装箱
int i = integer; // 自动拆箱
-
包装类都有名为valueOf(String s, int radix)的方法，可以将字符串变为基本数据类型，根据String类型的参数创建对应的包装类对象，但参数字符串s不能为null，而且字符串必须是可以解析为相应基本类型的数据。
-
除了Character外,包装类都有parseXXX(String s, int radix)的静态方法，将字符串转换为对应的基本数据类型的数据。
Integer integer = Integer.valueOf("011010", 2); // radix：进制数，默认为10
Integer integer = Integer.parseInt("123");
Arrays类
Arrarys类是数组的工具类，提供了对数组的方法，例如排序，二分查找等。
sort()方法是数组的排序方法，默认升序排序，如需降序，实现Comparator接口的compare()方法即可
Integer[] arr = {3, 1, 5, 4};
Arrays.sort(arr, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
/*
正常：（升序）
返回值 < 0：o1 < o2
返回值 = 0：o1 = o2
返回值 > 0：o1 > o2
如需降序只要将返回值符号取反即可
*/
return o2 - o1; // 降序的简化版写法 = - (o1 - o2)
}
});
System.out.println(Arrays.toString(arr)); // 输出 [5, 4, 3, 1]
binarySearch()方法查找数组中的某个元素并返回其下标值，如果找不到则返回插入点+1的值。使用该方法前必须对数组进行排序
