标签：常用 Java System Date LocalDateTime println LocalDate out

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()方法有多种设置，用于返回商末位小数点的处理，这些模式的含义和名称如下表所示：

日期与时间类

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的值。使用该方法前必须对数组进行排序

标签：常用,Java,System,Date,LocalDateTime,println,LocalDate,out
From： https://www.cnblogs.com/timqiu/p/16598915.html

Java常用类