Java之常用API整理

JDK中包含大量的类库，所谓API（Application Programming Interface,
应用程序的接口），就是一些已经写好的可直接调用的类或者接口，封装了类的功能。

JDK包结构：

• 划分形式：根据每个类的功能去划分在不同的包中。
  • java.lang：程序的基础类，如字符串、多线程
  • java.util：常用工具类，如集合、随机数、日历、时钟。
  • java.io ：文件操作，输入、输出操作
  • java.net ：网络操作
  • java.math:数学运算相关操作
  • java.sql:数据库的访问
  • java.text:处理文字、日期、数字、信息的格式
  • java.security:安全相关操作。

一、String类、StringBuffer类和StringBuilder类

在Java中定义了String、StringBuffer和StringBuilder三个类来封装字符串，并提供了一系列操作字符串的方法，它们都位于java.lang包中，因此不需要导包就可以直接使用。

String类

String类的构造方法：

String（）创建一个内容为空的字符串
String(char[] value) 根据指定的字符数组创建对象
String(String value) 根据指定的字符串内容创建对象

eg:

@Test
public void testString() {
	//创建一个内容为空的字符串
	String str1 = new String();
	//创建一个内容为abcd的字符串
	String str2 = new String("abcd");
	//创建一个内容为字符数组的字符串
    char[] charArray = new char[] {'d','e','f','g','f'}	;
    String str3 = new String(charArray);
    System.out.println("a"+str1+"b");
    System.out.println(str2);
    System.out.println(str3);
	
}

String类的常用方法：

eg:

/* startWith和endsWith;检索字符串是否以指定字符串开头或者结尾 */
	@Test
	public void testStartWithEndsWith() {
		String str = "Thinking in java!";
		System.out.println(str.endsWith("java!"));// true
		System.out.println(str.startsWith("T"));// true
		System.out.println(str.startsWith("thinking"));// false
	}
/* 转换字符串中英文的字母大小写形式 */
	@Test
	public void testToUpperCaseAndToLowerCase() {
		String str = "我喜欢java";
		System.out.println(str.toUpperCase());//我喜欢JAVA
		System.out.println(str.toLowerCase());//我喜欢java
	}
/* 将其他类型转化为字符串 */
	@Test
	public void testValueOf() {
		double p = 3.141592654;
		int value = 123;
		char[] chararr={'a','b','c','d','e','f','g'};
		String str=String.valueOf(p);
		System.out.println(str);//3.141592654
		str=String.valueOf(value);//123
		System.out.println(str);
		str=String.valueOf(chararr);
		System.out.println(str);//abcdefg
		}
/*
	 * 
	 * String常量池 
	 * 1.Java为了提高性能，静态字符串在常量池中创建，并尽量使用同一个对象，重用静态字符串
	 * 2.对于重复出现的字符串直接量，JVM会首先在常量池中查找，如果存在即返回该对象。
	 */
	@Test
	public void testConsPool() {
		/* 不会创建新的String对象，而是使用常量池中已有的Hello */
		String str1 = "Hello";
		String str2 = "Hello";
		System.out.println(str1 == str2);
		/* 使用new关键字会创建新的String */
		String str3 = new String("Hello");
		System.out.println(str1 == str3);
	}
/*
	 * 1.IndexOf方法用于实现字符串中检索另外一个字符串 
	 * 2.记：集中重载的IndexOf方法
	 * 		int indexOf(Stringstr)//在字符串中检索str，返回其第一个出现的位置。如果找不到则返回-1。 
	 * 		int indexOf(Strig str,int fromIndex)//从fromIndex位置开始检索。 
	 * 		int lastIndexOf(String str,int from)//str字符串中多次出现时，将返回最后一个出现的位置。
	 * 
	 */
	@Test
	public void testIdexOf() {
		String str = "I can because i think i can!";
		int index = str.indexOf("can");
		System.out.println(index);//2
		
		int index1=str.lastIndexOf("can");
		System.out.println(index1);//24
		
		int index2=str.indexOf("can", 6);//24
		System.out.println(index2);
		
		int index3=str.indexOf("Can");//-1
		System.out.println(index3);
	}
	/*
	 * 
	 * String在内存中采用Unicode编码，每个字符占用两个字节， 
	 * 任何一个字符（无论是中文还是英文）都算一个字符长度，占用两个字节
	 */

	/* 获取String对象的长度 */
	@Test
	public void testLength() {
		String str1 = "Hello";
		//Length();是获取字符串的字符长度
		System.out.println(str1.length());//5

		String str2 = "你好，Hello";
		System.out.println(str2.length());//8
	}
/*在一个字符串中截取指定的字符串*/
	@Test
	public void testSubstring(){
		String str="http://www.oracle.com";
		String substr=str.substring(11,17);
		System.out.println(substr);//oracle
		
		String subStr=str.substring(7);
		System.out.println(subStr);//www.oracle.com
		
	}
/*trim去掉字符串中前导和后继的空字符*/
	@Test
	public void Testrim(){
		String userName=" good man ";
		System.out.println(userName.length());
		
		userName=userName.trim();
		System.out.println(userName.length());
		System.out.println(userName);
		
	}	

正则表达式

1.为什么要用它？ 
在实际开发过程中经常需要对字符串数据进行一些复杂的匹配、查找、替换等操作，通过正则表达式可以方便实现字符串的复杂操作。 
2.正则表达式是什么？ 
正则表达式是一串特定的字符，组成一个“规则字符串”，这个“规则字符串”是描述文本规则的工具。正则表达式就是记录文本规则的代码。 

字符集和 
	 * 	正则表达式 		说明 
	 * 	[abc] 			a、b、c中的一个字符 
	 * 	[^abc]			除了a、b、c的任意字符 
	 * 	[a-z] 			a、b、c……z中的任意一个字符 
	 * 	[a-zA-Z0-9] 	a~zA~Z0~9中的任意一个字符
	 * 	[a-z&&[^bc]]	a~z中除了b、c的任意一个字符 
预定义字符集 
	 * 	正则表达式		说明
	 *   	. 			任意字符 
	 *  	\d			任意一个数字字符，相当于[0~9] 
	 *  	\w 			单词字符，[a-zA-Z0-9_] 
	 *  	\s 			空白字符 
	 *  	\D 			非数字字符 
	 *  	\W 			非单词 
	 *  	\S 			非空白
 数量词 
	 * 正则表达式 		说明 
	 * 	X? 				表示0个或者1个X X* 表示0个或者任意多个X 
	 * 	X+ 				表示一个或任意多个X(>=1) X{n} 表示n个X
	 *	X{n,} 			表示n个到任意多个X(>=n) X{n,m} 表示n个到m个X
	 *	
分组"()" 
	 *	()圆括号表示分组，可以将一系列正则表达式看做一个整体，
	 *	分组时可以使用"|"表示或关系

String类中用到正则表达式的几个常见方法：

• maches();将一个字符串与正则表达式进行匹配，返回值类型为boolean;
• String的split方法可以将字符串按照特定的分隔符拆分为字符串数组
• String replaceAll(String regex,String replacement) 将字符串中匹配正则表达式regex的字符串替换为replacement
  eg:

/*
 *测试maches()方法
 */
@Test
	public void testRegex() {
		String regex1 = "[a-z]";
		String regex2 = "[^a-z]";
		String regex3 = "[a-z&&[^bc]]";
		String regex4 = "\\d";
		String regex7 = "\\D";
		String regex5 = "\\w";
		String regex8 = "\\W";
		String regex6 = "\\s";
		String regex9 = "\\S";
		System.out.println("a".matches(regex1));// true
		System.out.println("b".matches(regex2));// false
		System.out.println("a".matches(regex3));// true
		System.out.println("0".matches(regex4));// true
		System.out.println("1".matches(regex5));// true
		System.out.println(" ".matches(regex6));// true
		System.out.println(" ".matches(regex7));// true
		System.out.println("_".matches(regex8));// false
		System.out.println("_".matches(regex9));// true
	}
	/*
 * 测试 split(String regex)方法
 */
@Test
public void testDemo1(){
	String str = "abccdefcdh";
	String[] arr1 = str.split("cc");
	String[] arr2 = str.split("c");
	
	System.out.println(arr1.length);//	2
	System.out.println(Arrays.toString(arr1));//[ab, defcdh]
	System.out.println("**********************************");
	System.out.println(arr2.length);//4
	System.out.println(Arrays.toString(arr2));//[ab, , def, dh]
	/*
	 * ps:可以这样理解用谁切割，谁就是“ ，”
	 */
}
	

StringBuffer类

eg:

	@Test
	public void testadd() {
		StringBuffer sb = new StringBuffer();
		sb.append("abcdefg");
		System.out.println("append添加结果："+sb);//append添加结果：abcdefg
		sb.insert(1, "123");
		System.out.println("insert添加结果："+sb);//insert添加结果：a123bcdefg
	
	}
@Test
	public void testremove() {
		StringBuffer sb = new StringBuffer("abcdefg");
		sb.delete(1, 5);
		System.out.println("删除指定位置结果："+sb);//删除指定位置结果：afg
		sb.deleteCharAt(2);
		System.out.println("删除指定位置结果："+sb);//删除指定位置结果：af
		sb.delete(0, sb.length());
		System.out.println("清空缓冲区结果："+sb);//清空缓冲区结果：
	}
@Test
	public void testalter() {//测试修改
		StringBuffer sb = new StringBuffer("abcdefg");
		sb.setCharAt(1, 'p');//修改指定位置字符
		System.out.println("修改指定位置字符结果："+sb);//修改指定位置字符结果：apcdefg
		sb.replace(1, 3, "qq");//替换指定位置字符串或字符
		System.out.println("替换指定位置字符（串）结果："+sb);//	替换指定位置字符（串）结果：aqqdefg
		System.out.println("字符串翻转结果："+sb.reverse());//	字符串翻转结果：gfedqqa
	}
	/*使用replaceAll方法实现字符串替换*/
	@Test
	public void testReplaceAll(){
		String str ="a3d6e6";
		str=str.replaceAll("[a-z]", "字母");
		str=str.replaceAll("\\d", "数字");
		System.out.println(str);//字母数字字母数字字母数字
	}

StringBuilder类

 * 1.StringBuilder封装可变的字符串，对象创建后可以通过调用方法改变其封装的字符序列。
 * 2.构造方法
 * 		public StringBuilder()
 * 		public StringBuilder(String str)
 * 3.常用的方法:重点
 * 		StringBuilder append(String str)//追加字符串
 * 		StringBuilder insert(int dstOffset,String s)//插入字符串
 * 		StringBuilder delete(int start,int end)//删除字符串
 * 		StringBuilder replace(int start,int end,String str)//替换字符串
 * 		StringBuilder reverse()//字符串反转
 * 4.StringBuilder的很多方法的返回值均为StringBuilder类型,所以返回语句均为：return this;
 * 5.由于改变了封装的字符序列后返回了该对象的引用，故可以实现连续追加。

eg:

/*测试StrngBuilder的append方法*/
	@Test
	public void testAppend(){
		StringBuilder buf=new StringBuilder("Programming Language");
		buf.append("java").append("php").append("C#");
		System.out.println(buf);//Programming LanguagejavaphpC#
	}
	/*测试StringBuilder的insert方法*/
	@Test
	public void testInsert(){
		StringBuilder buf=new StringBuilder("javaC++");
		buf.insert(buf.length(),"php");
		System.out.println(buf);//javaC++php
		}
	/*测试StringBuilder的delete方法*/
	@Test
	public void testDelete(){
		StringBuilder buf=new StringBuilder("javaC++");
		buf.delete(4,7);
		System.out.println(buf);//java
	}

StringBuffer和StringBuilder的区别？
StringBuffer是线程安全，同步处理的，性能稍慢。
StringBuilder是非线程安全的，并发处理，性能稍快。

注意：
String类覆盖了Object类的equals（）方法，而StringBuffer类和StringBuilder类没有覆盖Object类的equals（）方法。

验证如下：

@Test
public void testEquals() {
	String s1 = new String("abc");
	String s2 = new String("abc");
	System.out.println(s1.equals(s2));//true
	StringBuffer sb1 = new StringBuffer("abc");
	StringBuffer sb2 = new StringBuffer("abc");
	System.out.println(sb1.equals(sb2));//false
	StringBuilder sb11 = new StringBuilder("abc");
	StringBuilder sb22 = new StringBuilder("abc");
	System.out.println(sb11.equals(sb22));//false
}

二、Math类与Random类

Math类是数学操作类，提供了一系列用于数学运算的静态方法，包括求绝对值、三角函数等。Math类中有两个静态常量PI和E，分别代表π和e。

Math类

	@Test
	public void testMath() {
		System.out.println("计算绝对值的结果："+Math.abs(-1));
		System.out.println("求大于参数的最小整数："+Math.ceil(5.6));
		System.out.println("求小于参数的最大整数："+Math.floor(-4.2));
		System.out.println("对小数进行四舍五入后的结果："+Math.round(-4.6));
		System.out.println("求两个数的较大值："+Math.max(2.1, -2.1));
		System.out.println("求两个数的较小值："+Math.min(2.1, -2.1));
		System.out.println("生成一个大于等于0.0小于1.0的随机值："+Math.random());//该方法生成随机数的范围：[0,1)
		/*
		 * 运行结果：
		 * 计算绝对值的结果：1
         *求大于参数的最小整数：6.0
         *求小于参数的最大整数：-5.0
         *对小数进行四舍五入后的结果：-5
         *求两个数的较大值：2.1
         *求两个数的较小值：-2.1
         *生成一个大于等于0.0小于1.0的随机值：0.8628127642110086
		 */
	}

Random类
在JDK的java.util包中有一个Random类，它可以在指定的取值范围内随机产生数字。在Random类中提供了两个构造方法：

• Random（） 构造方法，用于创建一个伪随机数生成器

@Test
	public void testRandom(){
		Random r = new Random();
		for(int i = 0;i < 10; i++){
			System.out.print(r.nextInt(10)+" ");//随机产生10个[0,10)之间的整数
			/*
			 * 第一次运行结果：2 2 4 6 4 6 0 1 5 0 
			 * 第二次运行结果：8 8 2 7 8 9 1 4 1 4 
			 */
		}
	}

注意：
第一个构造方法是无参的，创建的Random实例对象每次使用的种子是随机的，因此每个对象所产生的随机数不同。如果希望创建的多个Random实例对象产生相同序列的随机数，则可以在创建对象时调用第二个构造方法，传入相同的种子即可。

• Random（long seed）构造方法，使用一个long型的seed种子创建伪随机数生成器

@Test
	public void testRandomDemo(){
		Random r = new Random(5);//创建对象时传入种子
		for(int i = 0; i <10; i++){
			System.out.print(r.nextInt(10)+" ");//随机产生10个[0,10)之间的整数
			/*
			 * 第一次运行结果：7 2 4 4 6 5 4 1 2 1 
			 * 第二次运行结果：7 2 4 4 6 5 4 1 2 1 
			 */
		}

从运行结果可以看出，当创建Random类的实例对象时，如果指定了相同的种子，则每个实例对象产生的随机数具有相同的序列。

三、包装类

在Java中，很多类的方法都需要接收引用类型的对象，此时就无法将一个基本类型数据的值传入。为了解决这样的问题，JDK中提供了一系列的包装类，通过这些包装类可以将基本类型的值包装为引用数据类型的对象。

Integer类的常用方法：

eg:

/**
	 * 测试Number的intValue方法和doubleValue方法
	 */
	@Test
	public void testIntValueAndDoubleValue() {
		Number d = 123.45;
		Number n = 123;
		//输出d和n对象所属类型
		System.out.println(d.getClass().getName());//java.lang.Double
		System.out.println(n.getClass().getName());//java.lang.Integer
		
		int  intValue = n.intValue();
		double doubleValue = d.doubleValue();
		System.out.println(intValue + "," + doubleValue);//123,123.45
		     intValue = n.intValue();//拆箱，将对象n解析为int类型的数值
		  doubleValue = n.doubleValue();//拆箱，将对象n解析为double类型的数值
		  System.out.println(intValue + "," + doubleValue);//	123,123.0
	}

/*String 转化为double*/
	
	@Test
	public void testParseDouble() {
		String str = "12345.00";
		double value = Double.parseDouble(str);
		System.out.println(value);//12345.0
		str = "123455.00";
		value = Double.parseDouble(str);
		System.out.println(value);//		123455.0
	}

注意事项：
1.包装类都重写了toString（） 方法，以字符串的形式返回被包装的基本数据类型的值。
2.除了Character类，包装类都有valueOf(String s)方法，可以根据String类型的参数创建包装类对象，但参数字符串s不能为null，而且字符串必须是可以解析为相应基本类型的数据，否则编译虽然通过，但是运行时会报错。
3.除了Character类，包装类都有parseXXX(String s)的静态方法，将字符串转换为对应的基本类型的数据。参数s不能为null，而且同样必须是可以解析为相应基本类型的数据，否则编译虽然通过，但运行时会报错。

拆箱和装箱

包装类和基本数据类型在进行转换时，引入了装箱和拆箱的概念，其中装箱是指将基本数据类型的值转化为引用数据类型；反之，拆箱是指将引用数据类型的对象转化为基本数据类型。
从java5.0版本以后加入到了autoboxing功能

下列代码均为正确形式

  *  Integer a = 100;//装箱
  *  Integer b = 200;//装箱
  *  Integer c = a + b;//拆箱再装箱
  *  double d = c;//拆箱

@Test
	public void testInteger() {
		//Integer a = Integer.valueOf(100);
		Integer a = 100;//装箱
		//Integer b = Integer.valueOf(100);
        Integer b = 200;//装箱
        Integer c = Integer.valueOf(a.intValue()+b.intValue());
        Integer c = a + b;//拆箱再装箱
        //int d = c
        //int d = c.intValue()
        double d = c;//拆箱
        System.out.println(d);
	}

四、Date类、Calendar类与DateFormat类

Date类：

Date类中大部分构造方法都被声明为已过时，只有两个构造方法是建议使用的

• Date()，无参构造，用来创建当前日期时间的Date对象
• Date(long date)，有参构造，用来创建指定时间的Date对象，其中date参数表示1970年1月1日00：00:00（称为历元）以来的毫秒数。

@Test
	public void testDemo1(){
		//创建表示当前时间的Date对象
		Date date1 = new Date();
		//创建表示距1970年1月1日00：00:00，966666666ms的Date对象
		Date date2 = new Date(966666666);
		System.out.println(date1);//Thu May 02 21:30:24 CST 2019
		System.out.println(date2);//	Mon Jan 12 12:31:06 CST 1970
		
		
	}

Calendar类

Calendar类用来完成日期和时间字段的操作，它可以通过特定的方法设置和读取日期的特定部分，比如年、月、日、时、分、秒等。Calendar类是一个抽象类，不可以实例化，在程序中需要调用其静态方法getInstance()来得到一个Calendar对象，然后调用其相应的方法。

@Test
	public void testDemo1(){
        	Calendar calendar = Calendar.getInstance();	
        	int year = calendar.get(Calendar.YEAR);
        	int month = calendar.get(Calendar.MONTH)+1;//月份的起始值从0开始，而不是1。
        	int date = calendar.get(Calendar.DATE);
        	int hour = calendar.get(Calendar.HOUR);
        	int minute = calendar.get(Calendar.MINUTE);
        	int second = calendar.get(Calendar.SECOND);
        	System.out.println("当前时间为："+year+"年"+month+"月"+date
        			+"日"+hour+"时"+minute+"分"+second+"秒");
        	//当前时间为：2019年5月2日9时44分4秒
		
	}

/*设置日期及时间分量*/
	@Test
	public void testSet() {
		//获取Calendar对象
		Calendar  c = Calendar.getInstance();
		c.set(Calendar.YEAR,2014);
		c.set(Calendar.MONTH, Calendar.MAY);
		c.set(Calendar.DATE, 25);
		System.out.println(c.getTime());//Sun May 25 22:04:03 CST 2014
		c.set(Calendar.DATE, 32);
		System.out.println(c.getTime());//	Sun Jun 01 22:04:03 CST 2014
		
	}

/*获取时间分量*/
	@Test
	public void testGet() {
		Calendar c = Calendar.getInstance();
		c.set(Calendar.YEAR, 2014);
		c.set(Calendar.MONTH, Calendar.DECEMBER);
		c.set(Calendar.DATE, 25);
		System.out.println(c.getTime());//Thu Dec 25 22:06:56 CST 2014
		int dayOfWeek = c.get(Calendar.DAY_OF_WEEK);
		System.out.println(dayOfWeek);//输出为5，表示周四，周日为每周第一天
	}

/*测试getActualMaximum*/
	/*
	 * int getActualMaximun(int field)给定此Calendar的时间值，
	 * 返回指定日历字段可能拥有的最大值。
	 */
	@Test
	public void testGetActualMaximum() {
		int year = 2019;
		Calendar c = Calendar.getInstance();
		c.set(Calendar.YEAR,year);
		c.set(Calendar.DATE, 1);
		for(int month = Calendar.JANUARY;(month) <= Calendar.DECEMBER;month++){
			c.set(Calendar.MONTH, month);
			System.out.println(year+"年"+(month+1)+"月："+c.getActualMaximum(Calendar.DATE)+"天");
			/*
			 *  2019年1月：31天
             *  2019年2月：28天
             *  2019年3月：31天
             *  2019年4月：30天
             *  2019年5月：31天
             *  2019年6月：30天
             *  2019年7月：31天
             *  2019年8月：31天
             *  2019年9月：30天
             *  2019年10月：31天
             *  2019年11月：30天
             *  2019年12月：31天
			 */
		}
	}

Dateformat类

在打印Date对象时都是以默认的英文格式输出日期和时间，如果想将Date对象表示的日期以指定的格式输出时，就需要用到Dateformat类。Dateformat类专门用于将日期格式化为字符串或者用特定格式显示的日期字符串转换成一个Date对象。Dateformat类是抽象类，不能被直接实例化，但它提供了静态方法，通过这些方法可以获取Dateformat类的实例对象，并调用其他相应的方法进行操作。
常用方法：





在DateFormat类中定义了四个常量值用于作为参数传递给这些方法，其中包括FULL、
LONG、MEDIUM、SHORT。
eg:

@Test
public void testdDateFormatDemo2(){
	Date date = new Date();
	DateFormat fullformat = DateFormat.getDateInstance(DateFormat.FULL);
	DateFormat longformat = DateFormat.getDateInstance(DateFormat.LONG);
	DateFormat mediumformat = DateFormat.getDateInstance(DateFormat.MEDIUM);
	DateFormat shortformat = DateFormat.getDateInstance(DateFormat.SHORT);
	System.out.println("当前日期的完整格式："+fullformat.format(date));
	System.out.println("当前日期的长格式："+longformat.format(date));
	System.out.println("当前日期的普通格式："+mediumformat.format(date));
	System.out.println("当前日期的短格式："+shortformat.format(date));
	System.out.println("**********************************************************************");
	Date date2 = new Date();
	DateFormat dateformate1= DateFormat.getDateInstance(0);
	DateFormat dateformate2= DateFormat.getDateInstance(1);
	DateFormat dateformate3= DateFormat.getDateInstance(2);
	DateFormat dateformate4= DateFormat.getDateInstance(3);
	System.out.println(dateformate1.format(date2));
	System.out.println(dateformate2.format(date2));
	System.out.println(dateformate3.format(date2));
	System.out.println(dateformate4.format(date2));
	System.out.println("**********************************************************************");
	Date date1 = new Date();
	DateFormat fullformat1 = DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.FULL);
	DateFormat longformat1 = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG);
	DateFormat mediumformat1 = DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.MEDIUM);
	DateFormat shortformat1 = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT);
	System.out.println("当前日期的完整格式："+fullformat1.format(date1));
	System.out.println("当前日期的长格式："+longformat1.format(date1));
	System.out.println("当前日期的普通格式："+mediumformat1.format(date1));
	System.out.println("当前日期的短格式："+shortformat1.format(date1));
//	当前日期的完整格式：2019年5月3日 星期五
//	当前日期的长格式：2019年5月3日
//	当前日期的普通格式：2019-5-3
//	当前日期的短格式：19-5-3
//	**********************************************************************
//	2019年5月3日 星期五
//	2019年5月3日
//	2019-5-3
//	19-5-3
//	**********************************************************************
//	当前日期的完整格式：2019年5月3日 星期五 上午09时39分49秒 CST
//	当前日期的长格式：2019年5月3日 上午09时39分49秒
//	当前日期的普通格式：2019-5-3 9:39:49
//	当前日期的短格式：19-5-3 上午9:39
	

/*
 * parse(String source)能够将一个字符串解析成Date对象，但是
 * 它要求字符串必须符合日期/时间的格式要求，否则会抛出异常。
 */
@Test
public void testParseDate(){
	DateFormat fullformat1 = DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.FULL);
	DateFormat longformat1 = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG);
	DateFormat mediumformat1 = DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.MEDIUM);
	DateFormat shortformat1 = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT);
	String str1 = "2019年5月3日 星期五 上午09时39分49秒 CST";
	String str2 = "2019年5月3日 上午09时39分49秒";
	String str3 = "2019-5-3 9:39:49";
	String str4 = "19-5-3 上午9:39";
	try {
		System.out.println(fullformat1.parse(str1));
	} catch (ParseException e) {
		e.printStackTrace();
	}
	try {
		System.out.println(longformat1.parse(str2));
	} catch (ParseException e) {
		e.printStackTrace();
	}
	try {
		System.out.println(mediumformat1.parse(str3));
	} catch (ParseException e) {
		e.printStackTrace();
	}
	try {
		System.out.println(shortformat1.parse(str4));
	} catch (ParseException e) {
		e.printStackTrace();
	}
//	Fri May 03 09:39:49 CST 2019
//	Fri May 03 09:39:49 CST 2019
//	Fri May 03 09:39:49 CST 2019
//	Fri May 03 09:39:00 CST 2019

}

SimpleDateFormat类

在使用DateFormat对象将字符串解析为日期时，需要输入固定格式的字符串，这显然不够灵活。JDK中提供了一个SimpleDateFormat类，该类是DateFormat类的子类。SimpleDateFormat类可以使用new关键字创建实例对象，它的构造方法接收一个格式字符串参数，表示日期格式模板。
构造方法：

• SimpleDateFormate()
• SimpleDateFormate(String pattern) 用给定的模式和默认的语言环境的日期格式符号 构造SimpleDateFormate

方法：

• final String format(Date date) Date- >String
• Date parse(String source) throws ParseException String->Date

日期模式匹配字符：

  * 字符          含义                 示例
   * y             年                  yyyy年-2013年；yy-13年
   * M             月                  MM月-01月；M-1月
   * d             天                  dd日-06天；d日-6日
   * E             星期               E-星期？
   * a             AM-PM标识      a-下午（PM）
   * H             小时（24制）
   * h             小时（12制）
   * m              分钟
   * s              秒

@Test
	public void testFormate() {
		//构造格式
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		//实例化Date对象
		Date date = new Date();
		//格式化日期
		String dateStr = sdf.format(date);
		System.out.println(dateStr);//2019-05-03 09:59:07
	}
	/*
	 * 解析String为Date
	 */
	@Test
	public void testParse() throws ParseException {
		/*和format相反，parse方法用于按照特定的格式将表示时间的字符串转换为Date对象*/
		String str = "2020-1-15";
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		Date date = sdf.parse(str);
		System.out.pr