Java面向对象：Java核心API、Java常用类
常用类概述
1、包装类 √
2、String类 ★
3、StringBuffer和StringBuilder类 ★
4、Math类
5、System类
6、Arrays类 ★
7、BigInteger类和BigDecimal类
8、Date日期类、Calendar日历类以及新的日期
包装类
理解
数据类型
基本数据类型
引用数据类型
数组
用class定义的
用interface定义的
需求：
① 获取int类型的最大值
② 将某个整数转换成十六进制形式
概念：为八大基本数据类型对应的提供了引用数据类型，则这些引用数据类型称为包装类
int i=10;
Integer i2=new Integer(i);
分类 ★
byte————————————Byte
short———————————Short
int—————————————Integer
long————————————Long
float—————————— Float
double——————————Double
char————————————Character
boolean—————————Boolean
基本类型和包装类型之间的转换 ★
jdk5.0之前：
手动装箱：
方式一：Integer i = new Integer(10);
方式二：Integer i2 = Integer.valueOf(10);
手动拆箱：
int j = i.intValue();
jdk5.0之后：
自动装箱：
Integer i = 10;
自动拆箱：
int j = i;
包装类型和String类型之间的转换
包装类型————>String类型
Integer i = 10;
//方式1：
String s1= i.toString();
//方式2：
String s2 = String.valueOf(i);
//方式3：
String s3 = i+"";
System.out.println(s3);
String————>包装类
//方式1：
Integer j = new Integer(s1);
//方式2：
Integer j2 = Integer.valueOf(s2);
基本类型和String类型之间的转换
基本类型————>String类型
int i = 10;
//方式1：
String s=i+"";
//方式2：
String s2 = String.valueOf(i);
String————>基本类型（除了char类型）
int j = Integer.parseInt(s);
char c = s.charAt(0);
包装类型中的常见API
通用的方法：
valueOf：将String类型或基本类型转换成对应的包装类型
parseXX:将String类型转换成对应的基本类型
xxValue:将包装类型转换成对应的基本类型
Character类的常见方法：
toUpperCase
toLowerCase
isUpperCase
isLowerCase
isDigit
isLetter
isWhiteSpace
String类
理解
String类用于保存一组字符串序列的
"john"、""都相当于字符串常量对象
创建对象
方式1：直接赋值
String s = "hello";
方式2：通过调用构造器
String s = new String("hello");
【面试题】两种创建对象方式的区别
方式一：先去常量池查看是否有“hello”字符序列，如果没有，则创建，如果有直接引用该地址
s指向的是常量池的对象
方式二：需要在堆中创建对象，该对象维护了一个value属性，value指向常量池的“hello”，如果常量池中没有“hello”，则创建，再指向；如果已经有了，则直接用value指向
s指向的是堆中的对象
String类的常见方法
length 获取字符个数
charAt 获取指定索引处的字符
toUpperCase转大写
toLowerCase转小写
indexOf获取字符或字符串第一次出现的索引，如果找不到返回-1
lastIndexOf获取字符或字符串最后一次出现的索引，如果找不到返回-1
startsWith判断是否以xx开头
endsWith判断是否以XX结尾
regionMatches判断是否某范围内的子串一致
contains 判断子串是否存在，返回true|false
compareTo 比较两个字符串大小
equals/equalsIgnoreCase判断字符串内容是否相等
substring截取子串
replace/replaceAll替换
trim去前后空格
split拆分
concat拼接字符串
toCharArray转换成字符数组
StringBuffer类
String类和StringBuffer的对比
相同点：
都用于保存字符串，都可以对字符串进行一些增删或其他处理的操作
不同点：
String类用于保存字符串常量
StringBuffer类用于保存字符串变量
StringBuffer类创建对象
只能通过调用构造器创建对象！
new StringBuffer（）; 构造一个初始容量为16的char数组
new StringBuffer(string);构造一个初始容量为string.length+16的数组，并初始化值为string
new StringBuffer(capacity)；构造一个初始容量为capacity的char数组
StringBuffer类和String类之间的转换
一、StringBuffer——>String
StringBuffer buffer = new StringBuffer("john");
//方式一：
String s1 = buffer.toString();
//方式二：
String s2 = new String(buffer);
二、String————>StringBuffer
String s = "鸠摩智";
//方式一：
StringBuffer b1 = new StringBuffer(s);
//方式二：
StringBuffer b2 = new StringBuffer();
b2.append(s);
StringBuffer类的方法
增 append
删 delete
改 replace
查 indexOf/lastIndexOf
插入 insert
反转 reverse
长度 length
StringBuffer和StringBuilder的对比
共同点 版本 线程安全（同步） 效率
StringBuffer 保存可变字符串 老 安全 较低
StringBuilder 保存可变字符串 新 不安全 较高
StringBuilder>StringBuffer>String
Math类
里面包含一系列的用于数学运算的静态方法。
常见方法：
sqrt 求开方
pow 求幂
ceil 向上取整
floor 向下取整
round 四舍五入，返回整型
abs 绝对值
random随机数
max最大值
min最小值
Arrays类
里面包含一系列用于数组管理和操作的方法
常见方法：
sort(T[]) :对数组的元素进行自然排序，要求元素必须实现了Comparable
sort(T[],Comparator):对数组的元素进行定制排序，元素本身可以不实现Comparable
binarySearch(T[],key):对数组通过二分搜索法进行查找，如果key找到了，返回索引，否则返回负数。要求：要查找的数组必须提前排好序！
copyOf(T[],length):复制数组的元素
equals(T[],T[]):判断两个数组的内容是否相等
fill(T[],key):填充数组的各元素值为key
toString():将数组各元素进行拼接，返回String
System类
常见方法
arrayCopy 复制数组元素，一般使用Arrays.copyOf代替
exit：退出程序
currentTimeMillens:获取当前时间距离1970-1-1的毫秒数。
gc:运行垃圾回收器
BigDecimal和BigInteger类
常见方法
add 加法
substract减法
multiply乘法
divide除法，注意：可以添加参数2设置四舍五入模式
日期类
第一代日期
java.util.Date类
java.text.SimpleDateFormat类
第二代日期
java.util.Calendar类
第三代日期(jdk8新特性)
LocalDate|LocalTime|LocalDateTime类：类似于Calendar
Instant：类似于Date
DateTimeFormatter：类似于SimpleDateFormat
常用类详解
一、包装类的理解
包装类：属于引用类型，一一对应了八大基本数据类型，为了给基本数据类型提供便利的方法
分类：
byte——Byte
short——Short
int——Integer
long——Long
float——Float
double——Double
char——Character
boolean——Boolean
二、包装类和基本类型的转换
一）手动装拆箱
手动装箱
double d=10;
Double d1 = new Double(d);
Double d2 = Double.valueOf(d);
手动拆箱
double x = d1.doubleValue();
二）自动装拆箱
自动装箱
Double d1 = d;
自动拆箱
double d2 = d1;
注意：
1、当包装类型进行运算或比较时，自动进行拆箱操作
2、Double d =10;错误！
三、包装类型和String类型之间的转换
包装类型——>String类型
Integer i = 10;
String s1 = i.toString();
String s2 = i+"";
String s3 = String.valueOf(i);
String类型——>包装类型（除了Character）
Integer j = Integer.valueOf(s1);
Integer j2 = new Integer(s1);
四、基本类型和String类型之间的转换
基本类型——>String类型
int i = 10;
String s = i+"";
String s2 = String.valueOf(i);
String类型——>基本类型
int j = Integer.parseInt(s);
boolean b = Boolean.parseBoolean(s);
char c =s.charAt(索引);
五、Character类的常见方法
isUpperCase(char) :判断字符是否为大写
isLowerCase(cahr):判断字符是否为小写
isDigit(char):判断是否为数字
isLetter(cahr):判断是否为字母
isWhiteSpace(char):判断是否为空格
toUpperCase(char):变大写
toLowerCase(char):变小写
六、【面试题】
面试题1：
Integer i = new Integer(12);
Integer j = new Integer(12);
syso(i==j);//false//对象判断的是地址
Integer i = new Integer(12);
Integer j = 12;
syso(i==j);//false
Integer i = 12; //自动装箱 有valueOf方法 内部类缓存了常见的基本整数 ，从-128到127，如果超出范围 那就new了一个新对象，所以地址不一样
Integer j = 12;
syso(i==j);//true
Integer i = 222;
Integer j = 222;
syso(i==j);//false
Integer i = 127;
int i = 127;
syso(i==j);//true
Integer i =128;
int i = 128;
syso(i==j);//true
面试题2：包装类只能更改地址，所以当包装类做参数，形参的改变不影响实参！
public static void main(String[] args){
Integer i = 100;
Integer j = 999;
swap(i,j);
syso(i+"\t"+j);//100 999
}
public static void swap(Integer i,Integer j){
i=1;
j=2;
Integer t = i;
i = j;
j = t;
syso(i+"\t"+j);//999 100
}
一、String类创建对象
方式一：直接赋值
String s = "hello";//在方法区，的常量池中，先看看常量池有无“hello”。创建 hello-0x09 ,栈中的s指向 方法区的常量池-0x09，s指向常量池的对象
方式二：通过调用构造器
String s2 = new String("hello");只要是new的 都是在堆中开辟空间 s2指向堆中的空间 0x07，堆中 0x07有一个value ，检测常量池是否有“hello”常量，如果有，直接用calue指向s
两种创建对象方式的区别：
方式一：先去常量池查看是否有“hello”，如果没有则创建，如果有，直接用s指向
方式二：先去堆中创建对象，里面通过value属性指向常量池的“hello”，如果常量池有“hello”，则直接通过value指向；如果没有则重新创建，然后指向。s最终指向的是堆中的对象
【面试题】
String s = "hello";
String s2 = new String("hello");
String s3 = "hello";
String s4 = new String("hello");
syso(s==s3);//true
syso(s2==s4);//false
syso(s==s2);//false
syso(s.intern()==s2.intern());//true
syso(s.intern()==s2);//false
syso(s.equals(s2));//true
二、String类的对象的不可变性
原因：String类中通过final的常量value代表里面的元素值
特点：String类的变量每次更改，更改的都是地址。所以String类不适合做更新的操作，因为效率较低，一般使用StringBuffer或StringBuilder做更新操作！
【面试题1】
String s = "hello";
s.concat("hhh");
syso(s);//hello
s.replace("h","H");
syso(s);//hello
【面试题2】
public static void main(String[] args){
String s1 = "黄";
String s2 = new String("红");
swap(s1,s2);
syso(s1+"\t"+s2);//黄 红
}
public static void swap(String x,String y){
String t = x;
x = y;
y=t;
syso(x+"\t"+y);//红 黄
}
【面试题3】
String s = "hello"+"abc";创建了一个对象
String a = "hello";
String b = "abc";
String s = a+b; 创建了三个对象
三、String类的常见方法
equals:判断两个字符串的内容是否相等，严格区分大小写
equalsIgnoreCase:判断两个字符串的内容是否相等，忽略大小写
length:获取字符串的长度
indexOf:获取字符（串）第一次出现的索引，如果找不到返回-1
lastIndexOf：获取字符（串）最后一次出现的索引，如果找不到返回-1
substring:截取子串
substring(startIndex)
substring(startIndex,endIndex): [startIndex,endIndex)
startsWith : 判断字符串是不是以xx开头
endsWith : 判断字符串是不是以xx结尾
regionMatchs:匹配两个字符串指定位置的子串是否一致
trim：去前后空格
charAt：获取指定索引处的字符
toCharArray:转换成字符数组
compareTo:比较两个字符串大小
split:分割字符串
format:格式字符串
String.format("姓名是：%s,性别是：%c,成绩是：%.2f,年龄是：%d","张三丰",'男',98.4,12);
concat:拼接字符串
replace：替换字符串的旧值为新值
一、StringBuffer和StringBuilder的区别
StringBuffer和StringBuilder类都是java.lang包的类，用于保存字符串的变量，相当于String类的增强版。提供了一系列对字符串操作的方法
而且有很多方法和String类的方法相似
二、StringBuffer类的创建对象
new StringBuffer();创建了一个初始容量为16 的 StringBuffer对象
new StringBuffer(string);创建了一个初始值为string的StringBuffer对象，容量=string.length()+16
new StringBuffer(capacity);创建了一个初始容量为capacity的StringBuffer对象
三、StringBuffer类的常见方法
append追加任意类型的元素
delete删除指定索引范围处的元素
delete(int start ,int end)
replace修改指定索引范围处的元素
replace(int start,int end,任意类型的元素)
indexOf查找元素是否存在，如果存在返回第一次出现的索引，否则返回-1
insert 插入任意类型的元素
insert(指定的索引，任意类型的元素)
length获取实际保存的元素的长度
四、StringBuffer和StringBuilder的对比
保存 线程安全（同步） 版本 效率
StringBuilder 可变字符串 不安全 新（1.5） 高
StringBuffer 可变字符串 安全 老（1.0） 低
五、String和StringBuffer的对比
String 用于保存字符串常量，里面的值不能更改，每次更改都相当于在更改地址，效率较低
StringBuffer用于保存字符串变量，里面的值可以更改，效率较高
Math类
一、说明
Math类是java.lang包下的核心类，里面保存了一系列静态方法，用于进行数学运算或操作
二、常见方法
abs 绝对值
pow 求幂
random随机数
round四舍五入
sqrt求开方
max求最大值
min求最小值
ceil 向上取整
floor向下取整
Arrays类
一、说明
Arrays类是java.util包下的工具类，里面提供了一系列静态方法，用于操作数组的
二、常见方法
sort(数组名)：自然排序，要求待排序的数组的元素类型必须实现Comparable接口，并实现抽象方法compareTo
sort(数组名,Comparator)：定制排序，根据比较器的比较规则进行定制排序
copyOf(待复制的数组名，新数组的长度)：复制数组的内容，返回新数组
binarySearch(数组名，待查找的元素)：根据二分搜索法查找元素是否存在，要求待查找的数组必须排好序
equals(数组名1，数组名2)：判断两个数组的内容是否相等
fill(数组名，待填充的元素)：填充数组
toString
System类
一、说明
System类是java.lang包下的一个类，里面包含了一系列静态方法和静态常量
二、常见方法
gc:运行垃圾回收机制
exit:退出程序
currentTimeMillens:返回当前时间距离1970-1-1 基准时间的毫秒数
arrayCopy:复制数组
BigInteger和BigDecimal类
一、说明
BigInteger和BigDecimal都是java.math包下的类，用于保存较大的整型或精度更高的浮点型
二、使用
BigDecimal b1 = new BigDecimal("1234568902345678");
BigDecimal b2 = new BigDecimal("23456");
System.out.println(b1.add(b2));
System.out.println(b1.subtract(b2));
System.out.println(b1.multiply(b2));
System.out.println(b1.divide(b2,BigDecimal.ROUND_HALF));
日期类
第一代日期类：Date类和SimpleDateFormat类
java.util.Date类
java.util.SimpleDateFormat类
说明：
Date类表示特定的瞬间，精确到毫秒，侧重于表示一个时间
使用：
//创建Date对象
Date date1 = new Date();//获取当前时间
Date date2 = new Date(234567890);//获取指定的时间 【用的较少】
SimpleDateFormat sdf = new SimpleDateFormat("格式");
String s=sdf.format(date);
format 和 parse
第二代日期类：Calendar类
java.util.Calendar
说明：
是一个抽象类，只能创建子类对象。侧重于获取日历字段，也就是提供了一系列用于特定瞬间和年、月、日转换的方法
使用：
Calendar c = Calendar.getInstance();不能new了 因为是抽象类
int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH)+1;
int day = c.get(Calendar.DAY_OF_MONTH);
int hour = c.get(Calendar.HOUR);
int minute = c.get(Calendar.MINUTE);
int second = c.get(Calendar.SECOND);
c.set(2018,2,3);
第三代日期类：
LocalDate、LocalTime、LocalDateTime
类似于Calendar
LocalDate只包含日期，可以获取日期字段
LocalTime只包含时间，可以获取时间字段
LocalDateTime包含日期+时间，可以获取日期和时间字段
LocalDateTime new=LocalDateTime.mow（）；
syso(now.getYear());
getMonthValue
getMonth
get
Instant
类似于Date
提供了一系列和Date类转换的方式
Instant——>Date:
Date date = Date.from(instant);
Date——>Instant:
Instant instant = date.toInstant();
DateTimeFormatter格式日期类
类似于SimpleDateFormat
DateTimeFormat dtf = DateTimeFormatter.ofPattern(格式);
String str = dtf.format(日期对象);
图解Java常用类
针对八种基本定义相应的引用类型—包装类（封装类）
有了类的特点，就可以调用类中的方法。
基本数据类型包装成包装类的实例 —装箱
通过包装类的构造器实现：
int i = 500; Integer t = new Integer(i);
还可以通过字符串参数构造包装类对象：
Float f = new Float(“4.56”);
Long l = new Long(“asdf”); //NumberFormatException
获得包装类对象中包装的基本类型变量 —拆箱
调用包装类的.xxxValue()方法：
boolean b = bObj.booleanValue();
JDK1.5之后，支持自动装箱，自动拆箱。但类型必须匹配。
字符串转换成基本数据类型
通过包装类的构造器实现：
int i = new Integer(“12”);
通过包装类的parseXxx(String s)静态方法：
Float f = Float.parseFloat(“12.1”);
基本数据类型转换成字符串
调用字符串重载的valueOf()方法：
String fstr = String.valueOf(2.34f);
更直接的方式：
String intStr = 5 + “”
包装类用法举例
int i = 500;
Integer t = new Integer(i);
装箱：包装类使得一个基本数据类型的数据变成了类。
有了类的特点，可以调用类中的方法。
String s = t.toString(); // s = “500“,t是类，有toString方法
String s1 = Integer.toString(314); // s1= “314“ 将数字转换成字符串。
String s2=“4.56”;
double ds=Double.parseDouble(s2); //将字符串转换成数字
拆箱：将数字包装类中内容变为基本数据类型。
int j = t.intValue(); // j = 500，intValue取出包装类中的数据
包装类在实际开发中用的最多的在于字符串变为基本数据类型。
String str1 = "30" ;
String str2 = "30.3" ;
int x = Integer.parseInt(str1) ; // 将字符串变为int型
float f = Float.parseFloat(str2) ; // 将字符串变为int型
String类：构造字符串对象
常量对象：字符串常量对象是用双引号括起的字符序列。 例如：“你好”、“12.97”、"boy"等。
字符串的字符使用Unicode字符编码，一个字符占两个字节
String类较常用构造方法:
String s1 = new String();
String s2 = new String(String original);
String s3 = new String(char[] a);
String s4 = new String(char[] a,int startIndex,int count)
String str = “abc”;与String str1 = new String(“abc”);的区别？
String是一个final类，代表不可变的字符序列
字符串是不可变的。一个字符串对象一旦被配置，其内容是不可变的。
1.以下语句创建了几个对象？
String s1 = “hello”;
s1=“haha”;
2.以下打印结果是什么？
String s1 = “hello”;
s1.concat(“world”);
System.out.pirntln(s1);
public int length()
public char charAt(int index)
public boolean equals(Object anObject)
public int compareTo(String anotherString)
public int indexOf(String s)
public int indexOf(String s ,int startpoint)
public int lastIndexOf(String s)
public int lastIndexOf(String s ,int startpoint)
public boolean startsWith(String prefix)
public boolean endsWith(String suffix)
public boolean regionMatches(int firstStart,String other,int otherStart ,int length)
public String substring(int startpoint)
public String substring(int start,int end)
pubic String replace(char oldChar,char newChar)
public String replaceAll(String old,String new)
public String trim()
public String concat(String str)
public boolean contains(CharSequence s)
public String[] split(String regex)
根据给定正则表达式的匹配拆分此字符串。
字符串转换为基本数据类型
Integer包装类的public static int parseInt(String s)：可以将由“数字”字符组成的字符串转换为整型。
类似地,使用java.lang包中的Byte、Short、Long、Float、Double类调相应的类方法可以将由“数字”字符组成的字符串，转化为相应的基本数据类型。
基本数据类型转换为字符串
调用String类的public String valueOf(int n)可将int型转换为字符串
相应的valueOf(byte b)、valueOf(long l)、valueOf(float f)、valueOf(double d)、valueOf(boolean b)可由参数的相应类到字符串的转换
字符串与字符数组
String 类的构造方法：
String(char[]) 和 String(char[]，int offset，int length) 分别用字符数组中的全部字符和部分字符创建字符串对象
String类提供了将字符串存放到数组中的方法：
public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
将字符串中的全部字符存放在一个字符数组中的方法：
public char[] toCharArray()
字符串与字节数组
String(byte[])用指定的字节数组构造一个字符串对象。String(byte[]，int offset，int length) 用指定的字节数组的一部分，即从数组起始位置offset开始取length个字节构造一个字符串对象。
public byte[] getBytes() 方法使用平台默认的字符编码，将当前字符串转化为一个字节数组。
public byte[] getBytes(String charsetName) 使用参数指定字符编码，将当前字符串转化为一个字节数组。
java.lang.StringBuffer代表可变的字符序列，可以对字符串内容进行增删。
很多方法与String相同，但StringBuffer是可变长度的。
StringBuffer是一个容器。
StringBuffer类有三个构造器：
1．StringBuffer()初始容量为16的字符串缓冲区
2．StringBuffer(int size)构造指定容量的字符串缓冲区
3．StringBuffer(String str)将内容初始化为指定字符串内容
StringBuffer append(String s), StringBuffer append(int n) ,
StringBuffer append(Object o) , StringBuffer append(char n),
StringBuffer append(long n), StringBuffer append(boolean n),
StringBuffer insert(int index, String str)
public StringBuffer reverse()
StringBuffer delete(int startIndex, int endIndex)
public char charAt(int n )
public void setCharAt(int n ,char ch)
StringBuffer replace( int startIndex ,int endIndex, String str)
public int indexOf(String str)
public String substring(int start,int end)
public int length()
StringBuilder 和 StringBuffer 非常类似，均代表可变的字符序列，而且方法也一样
String：不可变字符序列
StringBuffer：可变字符序列、效率低、线程安全
StringBuilder(JDK1.5)：可变字符序列、效率高、线程不安全
String使用陷阱：
string s="a"; //创建了一个字符串 s=s+"b"; //实际上原来的"a"字符串对象已经丢弃了，现在又产生了一个字符串s+"b"（也就是"ab")。如果多次执行这些改变串内容的操作，会导致大量副本字符串对象存留在内存中，降低效率。如果这样的操作放到循环中，会极大影响程序的性能。
1. java.lang.System类
System类提供的public static long currentTimeMillis()用来返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。
此方法适于计算时间差。
计算世界时间的主要标准有：
UTC(Coordinated Universal Time)
GMT(Greenwich Mean Time)
CST(Central Standard Time)
2. java.util.Date类
表示特定的瞬间，精确到毫秒
构造方法：
Date( )使用Date类的无参数构造方法创建的对象可以获取本地当前时间。
Date(long date)
常用方法
getTime():返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
toString():把此 Date 对象转换为以下形式的 String： dow mon dd hh:mm:ss zzz yyyy 其中： dow 是一周中的某一天 (Sun, Mon, Tue, Wed, Thu, Fri, Sat)，zzz是时间标准。
代码
import java.util.Date;
public void testDate(){
Date date = new Date();
System.out.println(date);
System.out.println(System.currentTimeMillis());
System.out.println(date.getTime());
Date date1 = new Date(date.getTime());
System.out.println(date1.getTime());
System.out.println(date1.toString());
}
3. java.text.SimpleDateFormat类
Date类的API不易于国际化，大部分被废弃了，java.text.Simp
leDateFormat类是一个不与语言环境有关的方式来格式化和解析日期的具体类。
它允许进行格式化（日期文本）、解析（文本日期）
格式化：
SimpleDateFormat() ：默认的模式和语言环境创建对象
public SimpleDateFormat(String pattern)：该构造方法可以用参数pattern指定的格式创建一个对象，该对象调用：
public String format(Date date)：方法格式化时间对象date
解析：
public Date parse(String source)：从给定字符串的开始解析文本，以生成一个日期。
Date date = new Date(); //产生一个Date实例
//产生一个formater格式化的实例
SimpleDateFormat formater = new SimpleDateFormat();
System.out.println(formater.format(date));//打印输出默认的格式
SimpleDateFormat formater2 = new SimpleDateFormat(
"yyyy年MM月dd日 EEE HH:mm:ss");
System.out.println(formater2.format(date));
//实例化一个指定的格式对象
//按指定的格式输出
try {
Date date2 = formater2.parse(“2008年08月08日 星期一
08:08:08");
//将指定的日期解析后格式化按指定的格式输出
System.out.println(date2.toString());
} catch (ParseException e) {
e.printStackTrace();
}
4. java.util.Calendar(日历)类
Calendar是一个抽象基类，主用用于完成日期字段之间相互操作的功能。
获取Calendar实例的方法
使用Calendar.getInstance()方法
调用它的子类GregorianCalendar的构造方法。
一个Calendar的实例是系统时间的抽象表示，通过get(int field)方法来取得想要的时间信息。比如YEAR、MONTH、DAY_OF_WEEK、HOUR_OF_DAY 、MINUTE、SECOND
public void set(int field,int value)
public void add(int field,int amount)
public final Date getTime()
public final void setTime(Date date)
Calendar calendar = Calendar.getInstance();
// 从一个 Calendar 对象中获取 Date 对象
Date date = calendar.getTime();
//使用给定的 Date 设置此 Calendar 的时间
calendar.setTime(date);
calendar.set(Calendar.DAY_OF_MONTH, 8);
System.out.println("当前时间日设置为8后,时间是:" +
calendar.getTime());
calendar.add(Calendar.HOUR, 2);
System.out.println("当前时间加2小时后,时间是:" +
calendar.getTime());
calendar.add(Calendar.MONTH, -2);
System.out.println("当前日期减2个月后,时间是:" +
calendar.getTime());
如果我们可以跟别人说：“我们在1502643933071见面，别晚了！”那么就再简单不过了。但是我们希望时间与昼夜和四季有关，于是事情就变复杂了。JDK 1.0中包含了一个java.util.Date类，但是它的大多数方法已经在JDK 1.1引入Calendar类之后被弃用了。而Calendar并不比Date好多少。它们面临的问题是：
可变性：像日期和时间这样的类应该是不可变的。
偏移性：Date中的年份是从1900开始的，而月份都从0开始。
格式化：格式化只对Date有用，Calendar则不行。
此外，它们也不是线程安全的；不能处理闰秒等。
总结：对日期和时间的操作一直是Java程序员最痛苦的地方之一。
第三次引入的API是成功的，并且java 8中引入的java.time API 已经纠正了过去的缺陷，将来很长一段时间内它都会为我们服务。
Java 8 吸收了 Joda-Time 的精华，以一个新的开始为 Java 创建优秀的 API。新的 java.time 中包含了所有关于
本地日期（LocalDate）、本地时间（LocalTime）、本地日期时间（LocalDateTime）、时区（ZonedDateTime）和持续时间（Duration）的类。
历史悠久的 Date 类新增了 toInstant() 方法，用于把 Date 转换成新的表示形式。这些新增的本地化时间日期 API 大大简化了了日期时间和本地化的管理。
java.time – 包含值对象的基础包
java.time.chrono – 提供对不同的日历系统的访问
java.time.format – 格式化和解析时间和日期
java.time.temporal – 包括底层框架和扩展特性
java.time.zone – 包含时区支持的类
LocalDate、LocalTime、LocalDateTime 类是其中较重要的几个类，它们的实例是不可变的对象，分别表示使用 ISO-8601日历系统的日期、时间、日期和时间。它们提供了简单的本地日期或时间，并不包含当前的时间信息，也不包含与时区相关的信息。
注：ISO-8601日历系统是国际标准化组织制定的现代公民的日期和时间的表示法，也就是公历。
在处理时间和日期的时候，我们通常会想到年,月,日,时,分,秒。然而，这只是时间的一个模型，是面向人类的。第二种通用模型是面向机器的，或者说是连续的。在此模型中，时间线中的一个点表示为一个很大的数，这有利于计算机处理。在UNIX中，这个数从1970年开始，以秒为的单位；同样的，在Java中，也是从1970年开始，但以毫秒为单位。
java.time包通过值类型Instant提供机器视图，不提供处理人类意义上的时间单位。Instant表示时间线上的一点，而不需要任何上下文信息，例如，时区。概念上讲，它只是简单的表示自1970年1月1日0时0分0秒（UTC）开始的秒数。因为java.time包是基于纳秒计算的，所以Instant的精度可以达到纳秒级。(1 ns = 10-9 s) 1秒 = 1000毫秒 =106微秒=109纳秒
作为一个开发者，如果不用去处理时区和它带来的复杂性，那是幸运的。java.time包下的LocalDate、LocalTime、LocalDateTime和Instant基本能满足需求。当你不可回避时区时，ZonedDateTime类可以满足我们的需求。
其中每个时区都对应着 ID，地区ID都为 “{区域}/{城市}”的格式
例如 ：Asia/Shanghai 等
now()：使用系统时间获取当前的ZonedDateTime
now(ZoneId zone)：返回指定时区的ZonedDateTime
ZoneId：该类中包含了所有的时区信息
getAvailableZoneIds() : 静态方法，可以获取所有时区时区信息
of(String id) :静态方法， 用指定的时区信息获取 ZoneId 对象
例子：
Duration:用于计算两个“时间”间隔，以秒和纳秒为基准
Period:用于计算两个“日期”间隔，以年、月、日衡量
TemporalAdjuster : 时间校正器。有时我们可能需要获取例如：将日期调整到“下一个工作日”等操作。
TemporalAdjusters : 该类通过静态方法(firstDayOfXxx()/lastDayOfXxx()/nextXxx())提供了大量的常用 TemporalAdjuster 的实现。
例如获取下个周日：
java.time.format.DateTimeFormatter 类：该类提供了三种格式化方法：
预定义的标准格式。如：
ISO_LOCAL_DATE_TIME;ISO_LOCAL_DATE
本地化相关的格式。如：ofLocalizedDate(FormatStyle.FULL)
自定义的格式。如：ofPattern(“yyyy-MM-dd hh:mm:ss E”)
到目前为止，臭名昭著的空指针异常是导致Java应用程序失败的最常见原因。以前，为了解决空指针异常，Google公司著名的Guava项目引入了Optional类，Guava通过使用检查空值的方式来防止代码污染，它鼓励程序员写更干净的代码。受到Google Guava的启发，Optional类已经成为Java 8类库的一部分。
Optional实际上是个容器：它可以保存类型T的值，或者仅仅保存null。Optional提供很多有用的方法，这样我们就不用显式进行空值检测。
Optional类的Javadoc描述如下：这是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。
Optional 类(java.util.Optional) 是一个容器类，代表一个值存在或不存在，原来用 null 表示一个值不存在，现在 Optional 可以更好的表达这个概念。并且可以避免空指针异常。
常用方法：
Optional.empty() : 创建一个空的 Optional 实例
Optional.of(T t) : 创建一个 Optional 实例
Optional.ofNullable(T t):若 t 不为 null,创建 Optional 实例,否则创建空实例
isPresent() : 判断是否包含值
T get(): 如果调用对象包含值，返回该值，否则抛异常
orElse(T t) : 如果调用对象包含值，返回该值，否则返回t
orElseGet(Supplier s) :如果调用对象包含值，返回该值，否则返回 s 获取的值
map(Function f): 如果有值对其处理，并返回处理后的Optional，否则返回 Optional.empty()
flatMap(Function mapper):与 map 类似，要求返回值必须是Optional
java.lang.Math提供了一系列静态方法用于科学计算；其方法的参数和返回值类型一般为double型。
abs 绝对值
acos,asin,atan,cos,sin,tan 三角函数
sqrt 平方根
pow(double a,doble b) a的b次幂
log 自然对数
exp e为底指数
max(double a,double b)
min(double a,double b)
random() 返回0.0到1.0的随机数
long round(double a) double型数据a转换为long型（四舍五入）
toDegrees(double angrad) 弧度—>角度
toRadians(double angdeg) 角度—>弧度
Integer类作为int的包装类，能存储的最大整型值为2^31−1，BigInteger类的数值范围较Integer类、Long类的数值范围要大得多，可以支持任意精度的整数。
构造方法
BigInteger(String val)
常用方法
public BigInteger abs()
public BigInteger add(BigInteger val)
public BigInteger subtract(BigInteger val)
public BigInteger multiply(BigInteger val)
public BigInteger divide(BigInteger val)
public BigInteger remainder(BigInteger val)
public BigIntegerpow(int exponent)
public BigInteger[] divideAndRemainder(BigInteger val)
一般的Float类和Double类可以用来做科学计算或工程计算，但在商业计算中，要求数字精度比较高，故用到java.math.BigDecimal类。BigDecimal类支持任何精度的定点数。
构造方法
public BigDecimal(double val)
public BigDecimal(String val)
常用方法
public BigDecimal add(BigDecimal augend)
public BigDecimal subtract(BigDecimal subtrahend)
public BigDecimal multiply(BigDecimal multiplicand)
public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)
例如
public void testBigInteger(){
BigInteger bi = new BigInteger("12433241123");
BigDecimal bd = new BigDecimal("12435.351");
BigDecimal bd2 = new BigDecimal("11");
System.out.println(bi);
//System.out.println(bd.divide(bd2));
System.out.println(bd.divide(bd2,BigDecimal.ROUND_HALF_UP));
System.out.println(bd.divide(bd2,15,BigDecimal.ROUND_HALF_UP));
}