第十四章 Java常用类

14、常用类
14.1 字符串相关的类	1课时
14.2 JDK 8之前时间日期API	1课时
14.3 JDK8中新时间日期API	1课时
14.4 JDK8中的Optional类	1课时
14.5 Math类	1课时
14.6 BigInteger 类与BigDecimal类	1课时

##14-1 字符串相关的类

案例

public class Person {
	String name;
	int age;
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

}

---

import java.util.concurrent.SynchronousQueue;

import org.junit.Test;

public class StringTest {

	@Test
	public void test4(){

		String s1 = "javaEE";
		String s2 = "hadoop";

		String s3 = "javaEEhadoop";
		String s4 = "javaEE" + "hadoop";

		//s5 - s8 :凡是声明为变量做连接运算的，都需要重新开辟空间。
		String s5 = s1 + "hadoop";
		String s6 = "javaEE" + s2;
		String s7 = s1 + s2;

		System.out.println(s3 == s4);//true
		System.out.println(s3 == s5);//false
		System.out.println(s3 == s6);//false
		System.out.println(s3 == s7);//false
		System.out.println(s5 == s6);//false
		System.out.println(s5 == s7);//false
		System.out.println(s6 == s7);//false

		String s8 = s1 + "hadoop";
		System.out.println(s5 == s8);//false

		//intern():得到的字符串对象以后，通过调用intern()，判断现有的字符串常量池中是否已经存在了当前内容
		//的字符串。如果存在，则直接引用现成的字符串。
		String s9 = s6.intern();
		System.out.println(s3 == s9);//true

	}

	//一个小问题
	@Test
	public void test3(){
		String s1 = null;
		s1 = "";
		s1 += "hello";
		System.out.println(s1);//nullhello --->hello

	}

	/**
	 * String:代表着不可变的字符序列。
	 *
	 * 1.String类的声明
	 * public final class String implements java.io.Serializable, Comparable<String>, CharSequence
	 * ①String声明为final，不可被继承。
	 * ②实现Serializable：表明String可序列化。浏览器/客户端<--->服务器端     进程1<---->进程2
	 *    "{name=Tom,age=12}"    JSON:本质就是String
	 * ③String重写了hashCode()/equals():常常将Map的key声明为String型。
	 * ④实现Comparable接口：String可以比较大小。
	 * ⑤实现CharSequence接口：String的底层声明了char[] value数组。
	 *
	 * 2.如何理解String的不可变性：
	 * ①向现有的字符串后添加新的字符串，必须声明新的字符串空间
	 * ②将现有的字符串替换为新的字符串，必须声明新的字符串空间
	 * ③只替换现有字符串中的指定某个字符，也必须声明新的字符串空间
	 */
	@Test
	public void test2(){
		String s1 = "javaEE";
		String s2 = "javaEE";

		System.out.println(s1 == s2);

		s1 += "hadoop";

		System.out.println(s1);
		System.out.println(s2);

		System.out.println("**********************");
		String s3 = "beijing";
		String s4 = "beijing";

		s3 = "shanghai";

		System.out.println(s3);//shanghai
		System.out.println(s4);//beijing

		System.out.println("**********************");
		String s5 = "hello";

		String s6 = s5.replace('l', 't');
		System.out.println(s6);//hetto
		System.out.println(s5);//hello

	}

	/**
	 * String:字符串
	 *
	 *
	 * 1.字符串声明的数据，会存储在字符串常量池中。第一次声明时，需要创建相应的字符串。之后，如果声明的变量，其
	 *  值与之前存在的字符串内容相同，则直接引用现成的字符串。
	 *
	 * 2.面试题：String s3 = new String("javaEE");创建的对象，在内存中生成了几个对象？
	 */
	@Test
	public void test1(){
		String s1 = "javaEE";
		String s2 = "javaEE";
		String s3 = new String("javaEE");
		String s4 = new String("javaEE");

		System.out.println(s1 == s2);//true
		System.out.println(s1 == s3);//false
		System.out.println(s1 == s4);//false
		System.out.println(s3 == s4);//false

		//判断：
		Person p1 = new Person("Tom",12);
		Person p2 = new Person("Tom",12);

		System.out.println(p1.name == p2.name);//true
		System.out.println(p1.name == "Tom");//true
	}
}

---

public class StringTest {

	/*
	 * String中常用的方法有哪些？
	 * length();charAt(int index);equals();compareTo(String str);
	 * startsWith();endsWith();con0tains();indexOf();lastIndexOf();
	 *
	 *
	 * String类与其它结构的转换：
	 * 1.String 与包装类、基本数据类型变量间的转换
	 * String-->包装类、基本数据类型:调用包装类Xxx的parseXxx(String s)方法
	 *     String s = "123";
	 * 包装类、基本数据类型 -->String:调用String的valueOf(xxx xxx);
	 *
	 * 2.String 与 字节数组间的转换
	 * String --> 字节数组:调用String类的getBytes()
	 * 字节数组-->String:new String(byte[] buffer,startIndex,length)
	 *
	 * 3.String 与 字符数组间的转换
	 * String --> 字符数组：调用String类的toCharArray()
	 * 字符数组 -->String:new String(char[] cbuf,startIndex,length)
	 *
	 *
	 */
	/*
        public String substring(int startpoint):返回当前字符串中从startPoint位置开始，到末尾的子字符串。
        public String substring(int start,int end):返回当前字符串中从startPoint位置开始，到end结束的左闭右开区间的子字符串。
        pubic String replace(char oldChar,char newChar):将字符串中指定的所有oldChar替换为newChar.
        public String replaceAll(String old,String new):将字符串中指定的所有old替换为new.
        public String trim():去除字符串首尾的空格
        public String concat(String str):连接两个字符串
        public boolean contains(CharSequence s)：判断当前字符串中是否包含s.
        public String[] split(String regex)
        根据给定正则表达式的匹配拆分此字符串。

	 */
	@Test
	public void test3(){
		String[] fakeFileData = {"justin\t64/5/26\t0939002302\t5433343","momor\t68/7/23\t0939100391\t5432343" };

			  for(String data : fakeFileData) {
				  String[] tokens = data.split("\t");
				   //\t为字符串的分割符号。
				  for(String token : tokens) {
					  System.out.print(token + "\t| ");}
				  System.out.println();
			  }
	}
	@Test
	public void test2(){
		String str = "嘻嘻哈哈啦啦咕咕";
		String substring = str.substring(2);
		System.out.println(str);
		System.out.println(substring);

		System.out.println(str.substring(2, 5));

		System.out.println(str.replaceAll("IT", "ET"));

		String str1 = "    hell o   ";
		String str2 = str1.trim();
		System.out.println("------" + str1 + "------");
		System.out.println("------" + str2 + "------");

		System.out.println(str.contains("嘻嘻"));
	}

	/*
public int length():返回当前字符串的长度
public char charAt(int index)：获取指定索引位置的字符
public boolean equals(Object anObject)：比较两个字符串内容是否相等。
public int compareTo(String anotherString):比较两个字符串的大小
public int indexOf(String s):返回s在当前字符串中首次出现的位置。如果不存在，返回-1.
public int indexOf(String s ,int startpoint):
public int lastIndexOf(String s):返回s在当前字符串中末次出现的位置。如果不存在，返回-1.
public int lastIndexOf(String s ,int startpoint):
public boolean startsWith(String prefix)：判断当前的字符串是否以指定的prefix字符串开始的
public boolean endsWith(String suffix)：判断当前的字符串是否以指定的suffix字符串结束的
public boolean regionMatches(int firstStart,String other,int otherStart ,int length)
	 *
	 *
	 */
	@Test
	public void test1(){
		String str = "beijing";
		System.out.println(str.length());
		System.out.println(str.charAt(0));
//		System.out.println(str.charAt(7));//越界

		String str1 = new String("beijing");
		System.out.println(str.equals(str1));

		String str2 = "bbeijing";
		System.out.println(str1.compareTo(str2));

		System.out.println(str1.indexOf("i"));
		System.out.println(str1.indexOf("i",3));

		System.out.println(str1.startsWith("beij"));

		String str3 = "bbjingcd";
		System.out.println(str1.regionMatches(3, str3, 2, 4));

	}
}

---

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.junit.Test;

public class StringDemo {
	/*
	 *
	5.对字符串中字符进行自然顺序排序。
	提示：
	1）字符串变成字符数组。
	2）对数组排序，选择，冒泡，Arrays.sort();
	3）将排序后的数组变成字符串
	 *
	 *
	 */
	@Test
	public void test5(){

		String s = "dsaffvfwqefscer";
		char[] charArray = s.toCharArray();
		Arrays.sort(charArray);

		String sortedStr = new String(charArray);
		System.out.println(sortedStr);

	}

	/*
	 * 4.获取两个字符串中最大相同子串。比如：
		str1 = "abcwerthelloyuiodef";str2 = "cvhellobnm"
		提示：将短的那个串进行长度依次递减的子串与较长的串比较。
	 *
	 *
	 */
	@Test
	public void test4(){
		String str1 = "abcwerthelloyuiodef";
		String str2 = "cvhellobnmiodef";
		List<String> list = getMaxSameString1(str1,str2);
		System.out.println(list);
	}

	public List<String> getMaxSameString1(String str1,String str2){
		String maxStr = (str1.length() > str2.length())? str1 : str2;
		String minStr = (str1.length() > str2.length())? str2 : str1;

		List<String> list = new ArrayList<>();

		int len = minStr.length();

		for(int i = 0;i < len;i++){//0 1 2 3 4  此层循环决定要去几个字符

			for(int x = 0,y = len - i;y <= len;x++,y++){

				if(maxStr.contains(minStr.substring(x, y))){

					list.add(minStr.substring(x, y));
				}

			}
//			if(list.size() != 0){
//				return list;
//			}

		}

		return null;
	}

	public String getMaxSameString(String str1,String str2){
		String maxStr = (str1.length() > str2.length())? str1 : str2;
		String minStr = (str1.length() > str2.length())? str2 : str1;

		int len = minStr.length();

		for(int i = 0;i < len;i++){//0 1 2 3 4  此层循环决定要去几个字符

			for(int x = 0,y = len - i;y <= len;x++,y++){

				if(maxStr.contains(minStr.substring(x, y))){

					return minStr.substring(x, y);
				}

			}

		}

		return null;
	}

	/*
	 *3. 获取一个字符串在另一个字符串中出现的次数。
					   比如：获取“ab”在 “abkkcadkabkebfkabkskab”
		   中出现的次数
	 *
	 */
	@Test
	public void test3(){
		String son = "ab";
		son = "kab";
		String mother = "abkkcadkabkebfkabkskab";

		int count = getCount(mother,son);
		System.out.println(count);
	}

	//判断son字符串在mother字符串中出现的次数
	public int getCount(String mother,String son){

		int count = 0;
		if(mother.length() >= son.length()){

			//方式一：
//			int index = 0;
//			while((index = mother.indexOf(son)) != -1){
//				count++;
//				mother = mother.substring(index + son.length());
//			}

			//方式二：比方式一效率高
			int index = 0;
			while((index = mother.indexOf(son, index)) != -1){
				count++;
				index += son.length();
			}

			return count;
		}

		return 0;

	}

	@Test
	public void test2(){
		String s = "abcdefg";
		String s1 = reverse2(s,2,5);
		System.out.println(s1);//abfedcg

	}

	//2.将一个字符串进行反转。将字符串中指定部分进行反转。比如将“abcdefg”反转为”abfedcg”
	//方式三：
	public String reverse2(String str,int start,int end){
		StringBuffer s = new StringBuffer(str.length());

		s.append(str.substring(0, start));

		for(int i = end;i >= start;i--){
			s.append(str.charAt(i));
		}

		s.append(str.substring(end + 1));

		return s.toString();
	}

	//方式二：效率最低
	public String reverse1(String str,int start,int end){
		//取第一部分
		String s = str.substring(0, start);
		//取第二部分
		for(int i = end;i >= start;i--){
			s += str.charAt(i);
		}
		//取第三部分
		s += str.substring(end + 1);
		return s;

	}

	//方式一：使用数组
	public String reverse(String str,int start,int end){
		char[] charArray = str.toCharArray();

		for(int i = start,j = end;i < j;i++,j--){
			char temp = charArray[i];
			charArray[i] = charArray[j];
			charArray[j] = temp;
		}

		return new String(charArray);
	}

	@Test
	public void test1(){

		String s = "    hell   oo   ";
		s = "     ";
		s = "a     ";
		s = "       b";
		String trimS = trim(s);
		System.out.println("-------" + trimS + "-----");

	}

	//1.模拟一个trim方法，去除字符串两端的空格。
	public String trim(String s){
		if(s != null){
			int start = 0;//首索引
			int end = s.length() - 1;//最后一个索引

			while(start <= end && s.charAt(start) == ' '){
				start++;
			}
			//得到首次出现非空格的索引：start

			while(start <= end && s.charAt(end) == ' '){
				end--;
			}
			//从后往前数，首次出现非空格的索引：end

			return s.substring(start, end + 1);

		}

		return null;

	}
}

案例

import org.junit.Test;

/**
 *
 * StringBuffer 和  StringBuilder的使用
 */
public class StringBufferBuilderTest {

	/*
	 * 测试String 、StringBuffer 、 StringBuilder三者的效率
	 *
	 * 从效率高到低： StringBuilder > StringBuffer > String
	 */
	@Test
	public void test3(){
		long startTime = 0L;
		long endTime = 0L;

		String text = new String();
		StringBuffer buffer = new StringBuffer("");
		StringBuilder builder = new StringBuilder("");

		startTime = System.currentTimeMillis();
		for(int i = 0;i<80000;i++){
			buffer.append(String.valueOf(i));
		}
		endTime = System.currentTimeMillis();
		System.out.println("StringBuffer的执行时间："+(endTime-startTime));

		startTime = System.currentTimeMillis();
		for(int i = 0;i<80000;i++){
			builder.append(String.valueOf(i));
		}
		endTime = System.currentTimeMillis();
		System.out.println("StringBuilder的执行时间："+(endTime-startTime));

		startTime = System.currentTimeMillis();
		for(int i = 0;i<80000;i++){
			text = text + i;
		}
		endTime = System.currentTimeMillis();
		System.out.println("String的执行时间："+(endTime-startTime));

	}

	/**
	 *  StringBuffer中的方法：
            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):删除当前可变字符串中从startIndex到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()

	 *
	 * 总结：
	 * 增：append(Xxx xxx)
	 * 删：delete(int startIndex, int endIndex)
	 * 改：setCharAt(int n ,char ch) / replace( int startIndex ,int endIndex, String str)
	 * 查：charAt(int n)
	 * 插：insert(int index, String str)
	 * 长度：length()
	 * 遍历：使用for + charAt()
	 *
	 *
	 */
	@Test
	public void test2(){
		StringBuffer s1 = new StringBuffer("helloworld");
//		StringBuffer s2 = s1.delete(2, 5);
//		System.out.println(s1);
//		System.out.println(s2);

		StringBuffer s3 = s1.replace(2, 5, "ccc");
		System.out.println(s1);
		System.out.println(s3);
	}

	/**
	 *
	 *
	 * 面试题：
	 * String:不可变的字符序列；底层使用char[]存储
	 * StringBuffer:可变的字符序列；线程安全的，效率低；底层使用char[]存储
	 * StringBuilder:可变的字符序列；线程不安全的，效率高，(jdk 5.0新增)；底层使用char[]存储
	 *
	 * 类比：String --->数组； StringBuffer --->Vector   StringBuilder --->ArrayList
	 *    ArrayList list = new ArrayList();
	 *    list.add(123);//new Object[10];
	 *    ....
	 *    扩容:1.5倍的方式扩容。
	 *
	 *
	 *   这里：
	 *   String str = new String();//new char[0];
	 *   str.length();
	 *
	 *   String str1 = new String("abc");//new char[]{'a','b','c'};
	 *
	 *   对比：
	 *   StringBuffer s1 = new StringBuffer();//char[] value = new char[16]
	 *
	 *   StringBuffer s2 = new StringBuffer(10);//char[] value = new char[10]
	 *
	 *   s1.append("abc");//value[0] = 'a',value[1] = 'b',value[2] = 'c';
	 *   ...
	 *   每次添加时，都需要判断底层的char[]是否能够盛装下新要添加的字符串。
	 *   如果不能盛装下，需要扩容。默认扩容为原来的2倍 + 2.
	 *
	 *   启示：
	 *   StringBuffer s1 = new StringBuffer(int capacity);开发中建议使用此构造器。
	 *
	 *
	 *
	 */
	@Test
	public void test1(){
		String str = new String();
		System.out.println(str.length());
	}
}

14-2 JDK8之前时间日期API

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

import org.junit.Test;

/**
 * jdk 8 之前 日期+时间 API的使用
 *
 */
public class TimeTest {

	/**
	 * java.util.Calendar(日历)类的使用
	 *
	 * @throws ParseException
	 */
	@Test
	public void test4(){
		//1.实例化
		Calendar calendar = Calendar.getInstance();

		//get()
		int day = calendar.get(Calendar.DAY_OF_MONTH);
		System.out.println(day);

		//set()
		calendar.set(Calendar.DAY_OF_MONTH, 20);
		day = calendar.get(Calendar.DAY_OF_MONTH);
		System.out.println(day);

		//add()
		calendar.add(Calendar.DAY_OF_MONTH, -2);
		day = calendar.get(Calendar.DAY_OF_MONTH);
		System.out.println(day);

		//日历 --->日期
		Date date = calendar.getTime();
		System.out.println(date);

		//使用指定的Date对象，来设置calendar
		Date date1 = new Date();
		calendar.setTime(date1);
		day = calendar.get(Calendar.DAY_OF_MONTH);
		System.out.println(day);

	}

	/*
	 * 练习一：
	 * 如何将字符串的"2014-1-16"数据转换为java.sql.Date对象？
	 *
	 *
	 * 练习二：“三天打渔，两天晒网”  从 1990-1-1开始实施。
	 *       判断1990-1-1之后xxxx-xx-xx日是打渔？晒网？
	 *       比如：2017-08-15
	 * 方式一：1990-1-1  ---> 2016-12-31  +     2017-1-1 ----->2017-8-15   计算出总天数
	 *      计算的总天数为sumDays.
	 *      sumDays % 5 == 1,2,3 :打渔
	 *      sumDays % 5 == 4,0 :晒网
	 *
	 * 方式二：1990-1-1   ---->java.util.Date: date1
	 *       2017-08-15  ------>java.util.Date :date2
	 *
	 *      sumDays = (date2.getTime() - date1.getTime()) / (1000 * 60 * 60 * 24) + 1
	 *
	 *
	 */
	@Test
	public void testExer() throws ParseException{
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		String info = "2014-1-16";
		Date date = sdf.parse(info);

//		System.out.println(date);

		java.sql.Date date1 = new java.sql.Date(date.getTime());
		System.out.println(date1);

	}

	/**
	 * java.text.SimpleDateFormat类
	 *
	 * 1.SimpleDateFormat的作用：
	 *   格式化：日期--->文本
	 *   解析：格式化的逆过程，文本 --->日期
	 *
	 * 2.SimpleDateFormat实例化
	 * @throws ParseException
	 *
	 */
	@Test
	public void test3() throws ParseException{
		//1.使用默认构造器
		SimpleDateFormat sdf = new SimpleDateFormat();
		//格式化：String format(Date date):
		Date date = new Date();
		String dateStr = sdf.format(date);
		System.out.println(dateStr);//17-8-15 下午2:20

		//解析： Date parse(String dateStr)
		Date date1 = sdf.parse("17-8-15 下午2:18");
		System.out.println(date1);

		//2.使用带参数的构造器
//		SimpleDateFormat sdf1 = new SimpleDateFormat("EEE, d MMM yyyy HH:mm:ss Z");
		SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
		//格式化
		String dateStr1 = sdf1.format(date);
		System.out.println(dateStr1);//2017-08-15 02:24:40

		//解析
		Date date2 = sdf1.parse("2017-08-15 02:24:40");
		System.out.println(date2);

	}

	/**
	 * java.util.Date类
	 * 		|----java.sql.Date类
	 *
	 * 1.java.util.Date类：
	 *    如何实例化：两个构造器
	 *    常用方法：toString() / getTime();
	 *
	 * 2.java.sql.Date类：与数据表中的Date类型的变量对应。
	 */
	@Test
	public void test2(){

		//构造器一：获取系统当前时间对应的Date对象
		Date date = new Date();

		System.out.println(date.toString());
		//getTime()：返回当前日期对应的毫秒数：当前时间与1970-1-1 00：00：00直接的毫秒数
		System.out.println(date.getTime());

		//构造器二：获取毫秒数所对应的Date对象
		Date date1 = new Date(1502768492941L);
		System.out.println(date1);

		System.out.println("************如下的是java.sql.Date*********************");
		//实例化：
		java.sql.Date date2 = new java.sql.Date(1502768492941L);
		System.out.println(date2.toString());//2017-08-15
		System.out.println(date2.getTime());

		//小练习：如何将java.util.Date转换为java.sql.Date
		//情形一：
		Date date3 = new java.sql.Date(153145234532L);
//		date3 = new Date();//会报异常
		java.sql.Date date4 = (java.sql.Date) date3;
		System.out.println(date4);

		//情形二：
		System.out.println();
		Date date5 = new Date();
		java.sql.Date date6 = new java.sql.Date(date5.getTime());
		System.out.println(date6);

	}

	@Test
	public void test1(){
		//用来返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。
		long currentTimeMillis = System.currentTimeMillis();
		System.out.println(currentTimeMillis);
	}

}

---

14-3 JDK8中新时间日期API

闰秒，是指为保持协调世界时接近于世界时时刻，由国际计量局统一规定在年底或年中（也可能在季末）对协调世界时增加或减少1秒的调整。由于地球自转的不均匀性和长期变慢性（主要由潮汐摩擦引起的），会使世界时（民用时）和原子时之间相差超过到±0.9秒时，就把协调世界时向前拨1秒（负闰秒，最后一分钟为59秒）或向后拨1秒（正闰秒，最后一分钟为61秒）； 闰秒一般加在公历年末或公历六月末。

目前，全球已经进行了27次闰秒，均为正闰秒。

import java.time.DayOfWeek;
import java.time.Duration;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.OffsetDateTime;
import java.time.Period;
import java.time.ZoneId;
import java.time.ZoneOffset;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;
import java.time.temporal.Temporal;
import java.time.temporal.TemporalAccessor;
import java.time.temporal.TemporalAdjuster;
import java.time.temporal.TemporalAdjusters;
import java.util.Date;
import java.util.Set;

import org.junit.Test;

public class JDK8TimeTest {

	//7.DateTimeFormatter:日期时间的格式化工具     -----重要
	//类似于：SimpleDateFormat
	@Test
	public void test9(){
//		预定义的标准格式。如：ISO_LOCAL_DATE_TIME;ISO_LOCAL_DATE
		DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
		LocalDateTime localDateTime = LocalDateTime.now();
		String formatDateTime = dateTimeFormatter.format(localDateTime);
		System.out.println(formatDateTime);

//		本地化相关的格式。如：ofLocalizedDate(FormatStyle.MEDIUM)
		//FormatStyle.MEDIUM / FormatStyle.LONG :适用于LocalDateTime
		//FormatStyle.FULL / FormatStyle.SHORT : 适用于LocalDate / LocalTime
		LocalDate localDate = LocalDate.now();
		DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM);
		//格式化：DateTime ---->文本
		String formatDateTime1 = dateTimeFormatter1.format(localDateTime);
		System.out.println(formatDateTime1);//2017-8-15 17:04:50

		//解析:文本 --->DateTime
		TemporalAccessor temporalAccessor = dateTimeFormatter1.parse("2017-8-15 17:04:50");
		System.out.println(temporalAccessor);

//		自定义的格式。如：ofPattern(“yyyy-MM-dd hh:mm:ss E”)
		DateTimeFormatter dateTimeFormatter2 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
		//格式化：DateTime ---->文本
		String dateTimeStr = dateTimeFormatter2.format(localDateTime);
		System.out.println(dateTimeStr);//2017-08-15 05:07:33
		//解析:文本 --->DateTime
		TemporalAccessor temporalAccessor1 = dateTimeFormatter2.parse("2017-08-15 05:07:33");
		System.out.println(temporalAccessor1);

	}

	//6.TemporalAdjuster:时间校正器
	@Test
	public void test8(){
		//获取当前日期的下一个周日是哪天？
		TemporalAdjuster temporalAdjuster = TemporalAdjusters.next(DayOfWeek.SUNDAY);

		LocalDateTime localDateTime = LocalDateTime.now().with(temporalAdjuster);
		System.out.println(localDateTime);

		//获取下一个工作日是哪天？
		LocalDate localDate = LocalDate.now().with(new TemporalAdjuster(){

			@Override
			public Temporal adjustInto(Temporal temporal) {
				LocalDate date = (LocalDate)temporal;
				if(date.getDayOfWeek().equals(DayOfWeek.FRIDAY)){
					return date.plusDays(3);
				}else if(date.getDayOfWeek().equals(DayOfWeek.SATURDAY)){
					return date.plusDays(2);
				}else{
					return date.plusDays(1);
				}

			}

		});

		System.out.println("下一个工作日是：" + localDate);
	}

	//5.Period:用于计算两个“日期”间隔，以年、月、日衡量
	@Test
	public void test7(){
		LocalDate localDate = LocalDate.now();
		LocalDate localDate1 = LocalDate.of(2028, 3, 18);

		Period period = Period.between(localDate, localDate1);
		System.out.println(period);

		System.out.println(period.getYears());
		System.out.println(period.getMonths());
		System.out.println(period.getDays());

		Period period1 = period.withYears(2);
		System.out.println(period1);

	}

	//4.Duration:用于计算两个“时间”间隔，以秒和纳秒为基准
	@Test
	public void test6(){
		LocalTime localTime = LocalTime.now();
		LocalTime localTime1 = LocalTime.of(15, 23, 32);
		//between():静态方法，返回Duration对象，表示两个时间的间隔
		Duration duration = Duration.between(localTime1, localTime);
		System.out.println(duration);

		System.out.println(duration.getSeconds());
		System.out.println(duration.getNano());

		LocalDateTime localDateTime = LocalDateTime.of(2016, 6, 12, 15, 23, 32);
		LocalDateTime localDateTime1 = LocalDateTime.of(2017, 6, 12, 15, 23, 32);

		Duration duration1 = Duration.between(localDateTime1, localDateTime);
		System.out.println(duration1.toDays());

	}

	//3. ZonedDateTime:带时区的日期时间
	@Test
	public void test5(){
		//now():获取本时区的ZonedDateTime对象
		ZonedDateTime zonedDateTime = ZonedDateTime.now();
		System.out.println(zonedDateTime);
		//now(ZoneId id):获取指定时区的ZonedDateTime对象
		ZonedDateTime zonedDateTime1 = ZonedDateTime.now(ZoneId.of("Asia/Tokyo"));
		System.out.println(zonedDateTime1);
	}

	//3. ZoneId:类中包含了所有的时区信息
	@Test
	public void test4(){
		//getAvailableZoneIds():获取所有的ZoneId
		Set<String> zoneIds = ZoneId.getAvailableZoneIds();
		for(String s : zoneIds){
			System.out.println(s);
		}
		System.out.println();

		//获取“Asia/Tokyo”时区对应的时间
		LocalDateTime localDateTime = LocalDateTime.now(ZoneId.of("Asia/Tokyo"));
		System.out.println(localDateTime);

	}

	//2. Instant:时间点     -----重要
	//类似：Date
	@Test
	public void test3(){
		//now():得到Instant的实例
		Instant instant = Instant.now();//表示自1970年1月1日0时0分0秒（UTC）开始的秒数
		System.out.println(instant);

		//atOffset():得到带偏移量的日期时间
		OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));
		System.out.println(offsetDateTime);

		//得到时间戳
		long milli = instant.toEpochMilli();
		System.out.println(milli);//1502785241830

		//根据毫秒数，得到时间点的对象
		Instant instant2 = Instant.ofEpochMilli(milli);
		System.out.println(instant2);
	}

	//1. LocalDate / LocalTime / LocalDateTime     -----重要
	//理解为对Calendar
	@Test
	public void test2(){
		//实例化
		//now()
		LocalDate localDate = LocalDate.now();

		LocalTime localTime = LocalTime.now();

		LocalDateTime localDateTime = LocalDateTime.now();

		System.out.println(localDate);
		System.out.println(localTime);
		System.out.println(localDateTime);

		//of()
		LocalDate localDate2 = LocalDate.of(2017, 8, 15);
		System.out.println(localDate2);

		LocalDateTime localDateTime2 = LocalDateTime.of(2017, 8, 15, 11, 11, 23);
		System.out.println(localDateTime2);
		System.out.println();
		//getXxx():
		System.out.println(localDateTime.getDayOfYear());
		System.out.println(localDateTime.getDayOfMonth());
		System.out.println(localDateTime.getDayOfWeek());
		System.out.println(localDateTime.getMonth());
		System.out.println(localDateTime.getMonthValue());
		System.out.println(localDateTime.getHour());
		System.out.println(localDateTime.getMinute());

		//withXxx():体现了不可变性
		LocalDateTime localDateTime3 = localDateTime.withDayOfMonth(20);
		System.out.println(localDateTime);
		System.out.println(localDateTime3);

		LocalDateTime localDateTime4 = localDateTime.withHour(12);
		System.out.println(localDateTime4);

		//plus()
		//minus()
		LocalDateTime localDateTime5 = localDateTime.plusDays(3);
		System.out.println(localDateTime5);

		LocalDateTime localDateTime6 = localDateTime.minusMinutes(20);
		System.out.println(localDateTime6);

		boolean isBefore = localDateTime.isBefore(localDateTime6);
		System.out.println(isBefore);//false
		boolean isAfter = localDateTime.isAfter(localDateTime6);
		System.out.println(isAfter);//true

		//isLeapYear():
		System.out.println(localDate.isLeapYear());
		LocalDate localDate3 = localDate.minusYears(1);
		System.out.println(localDate3.isLeapYear());

	}

	@Test
	public void test1(){
		Date date = new Date(2017-1900, 8 - 1, 15);
		System.out.println(date);
	}
}

14-4 JDK8中的Optional类

public class Girl {
	private String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Girl(String name) {
		super();
		this.name = name;
	}

	@Override
	public String toString() {
		return "Girl [name=" + name + "]";
	}

}

---

public class Man {

	private Girl girl;

	public Man(Girl girl) {
		super();
		this.girl = girl;
	}

	public Girl getGirl() {
		return girl;
	}

	public void setGirl(Girl girl) {
		this.girl = girl;
	}

	@Override
	public String toString() {
		return "Man [girl=" + girl + "]";
	}

	public Man() {
		super();
	}

}

---

import java.util.Optional;

import org.junit.Test;

public class ManTest {

	// Optional使用的练习
	@Test
	public void test3(){
		String name = getGirlName2(new Man(new Girl("迪丽热巴")));
		System.out.println(name);

		name = getGirlName2(new Man());
		System.out.println(name);

		name = getGirlName2(null);
		System.out.println(name);

	}

	public String getGirlName2(Man man){

		Optional<Man> op = Optional.ofNullable(man);

		Man man1 = op.orElse(new Man(new Girl("佟老师")));//man1一定是非空的

		Girl girl = man1.getGirl();

		Optional<Girl> op1 = Optional.ofNullable(girl);

		Girl girl1 = op1.orElse(new Girl("苍老师"));//girl1一定是非空的

		return girl1.getName();
	}

	@Test
	public void test2(){
		String name = getGirlName1(new Man());
		System.out.println(name);
	}

	public String getGirlName1(Man man){
		if(man != null){
			Girl girl = man.getGirl();
			if(girl != null){
				return girl.getName();
			}
		}
		return "苍老师";
	}

	@Test
	public void test1() {
		//原来的方式可能存在空指针异常。
//		String name = getGirlName(null);
		String name = getGirlName(new Man());
		System.out.println(name);
	}

	public String getGirlName(Man man){
		return man.getGirl().getName();
	}
}

---

import java.util.Optional;
import java.util.concurrent.SynchronousQueue;

import org.junit.Test;

/**
 * Optional类使用的测试
 *
 * Optional:是一个封装了具体类型数据的容器。
 * 其中，具体的类型：通过Optional的泛型体现。
 *     具体类型的数据：通过Optional内部的T value体现
 */
public class OptionalTest {

	@Test
	public void test1(){
		//返回一个没有封装任何数据的Optional对象
//		Optional<Object> op = Optional.empty();
//		System.out.println(op);
//
//		//isPresent():判断内部的数据是否存在
//		if(op.isPresent()){
//			//get():返回Optional对象内部封装的数据
//			System.out.println(op.get());
//		}else{
//			System.out.println("内部木有数据");
//		}

		System.out.println("**********************");
		//of(T t):当t为null时，报异常。建议不用此方法
		Optional<String> op = Optional.of("beijing");
//		Optional<String> op = Optional.of(null);
		System.out.println(op);

		//isPresent():判断内部的数据是否存在
		if(op.isPresent()){
			//get():返回Optional对象内部封装的数据
			System.out.println(op.get());
		}else{
			System.out.println("内部木有数据");
		}

		System.out.println("**********************");
//		Optional<String> op1 = Optional.ofNullable("beijing");
		Optional<String> op1 = Optional.ofNullable(null);
		System.out.println(op1);

		//isPresent():判断内部的数据是否存在
		if(op1.isPresent()){
			//get():返回Optional对象内部封装的数据
			System.out.println(op1.get());
		}else{
//			System.out.println("内部木有数据");
			//orElse(T t):如果调用对象包含值，返回该值，否则返回t
			String str = op1.orElse("xxxxx");
			System.out.println(str);

		}

		System.out.println("**********************");
		//总结："beijing"位置的对象如果不为空，则返回此对象。如果为空，返回"shanghai"对应的对象。
		//进而，通过使用Optional能够规避空指针的异常。
		Optional<String> op2 = Optional.ofNullable("beijing");
		String str1 = op2.orElse("shanghai");
		System.out.println(str1);
	}
}

14-5 Math类

import java.io.IOException;
import java.math.BigDecimal;
import java.math.BigInteger;

import org.junit.Test;

public class OtherTest {

	/*
	 * Integer类作为int的包装类，能存储的最大整型值为2^31−1，
	 * BigInteger类的数值范围较Integer类、Long类的数值范围要大得多，可以支持任意精度的整数。
	 *
	 * 在商业计算中，要求数字精度比较高，故用到java.math.BigDecimal类。BigDecimal类支持任何精度的定点数。
	 *
	 *
	 */
	@Test
	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));
		}

	//规则：var + 0.5 之后，截断。
	// 11.6 + 0.5 = 12.1
	// 11.4 + 0.5 = 11.9
	@Test
	public void test2() {
		long l = Math.round(-11.5); // -11.5 + 0.5 = -11
		System.out.println(l);
		long l1 = Math.round(-11.4);// -11.4 + 0.5 = -10.9
		System.out.println(l1);
		long l2 = Math.round(-11.6);// - 11.6 + 0.5 = -11.1
		System.out.println(l2);
	}

	@Test
	public void test1() throws IOException {
		String str = "学java";
		System.out.println(str.getBytes("UTF-8").length);
		System.out.println(str.getBytes("GBK").length);

	}
}

14-6 BigInteger与BigDecimal类

虚拟机内存解析移步