異常、經常使用類、GUI、正則

時間 2019-11-12

原文原文鏈接

1、異常

一、概述：
異常：就是程序在運行時出現不正常狀況。將問題封裝成對象就是異常。
異常由來：問題也是現實生活中一個具體事務，也能夠經過 java 的類的形式進行描述。並封裝成對象。其實就是 java 對不正常狀況進行描述後的對象體現。

嚴重的問題：java 經過Error 類進行描述。通常不編寫針對性代碼對其進行處理。

非嚴重問題：java 經過Exception 類進行描述。可使用針對性的處理方式處理。

Error 類和 Exception 類都具備一些共性內容，向上抽取部分是父類 Throwable。Exception 類的錯誤表明那些諸如算術錯誤、數據格式錯誤、非法參數、非法存取等與程序有關的錯誤。Throwable 類是 java 語言中全部錯誤或異常的超類。這也就構成了 Java 的異常體系：

Throwable java

|---Error //一般出現重大問題如：運行的類不存在或者內存溢出等。正則表達式

|---Exception //運行時出現的一塊兒狀況 shell

|---RuntimeException //特殊異常類，拋時不須要聲明數據庫

Exception和Error的子類名都是以父類名做爲後綴。編程

異常體系的特色：設計模式

1）異常體系中的全部類以及創建的對象都具有可拋性。數組

2）也就是說能夠被throw和throws關鍵字所操做。安全

3）只有異常體系具有這個特色。

二、異常分類：

1）編譯時被檢測異常：網絡

該異常在編譯時，若是沒有處理(沒有拋也沒有try)，編譯失敗。該異常被標識，表明着能夠被處理。多線程

2）運行時異常(編譯時不檢測)：

在編譯時，不須要處理，編譯器不檢查。該異常的發生，建議不處理，讓程序中止，須要對代碼進行修正例如：RuntimeException以及其子類。

三、異常處理：

格式：

try{

//須要被監測的代碼

}catch(異常類常量){

//處理異常的代碼（處理方式）

}finally{

//必定會執行的代碼

}

Note:

1) catch 小括號中的參數表明要捕獲哪一種異常，應該寫 Exception 或其某個子類的對象。

2) 若發生異常，則 try 語句塊的執行發生在發生問題的位置中斷，後面若還有語句將被忽略，執行流程轉移到捕獲該異常的 catch 語句塊中。

3) 若不發生異常，則 catch 語句塊中的代碼不會被執行。

4) 不管是否發生異常 finally 塊中的代碼必定會被執行。通常用於關閉資源碼（好比：關閉數據庫），由於資源必須釋放。

5) try語句塊不能單獨出現，catch 和 finally 必須至少有一個跟在 try 後面。

6) catch 語句塊能夠寫多個，每一個 catch 捕捉不一樣的異常，一次跟在 try 語句塊的後面，發生異常時，程序將從上向下找到最早匹配的 catch 語句塊去執行，所以子類級別的異常要寫在前面，父類級別的異常靠後。

7) finally 只有一種狀況不會執行：當執行到System.exit(0);後fianlly 不會再執行。

四、throw和throws

throw定義在函數內，用於拋出異常對象。

throws定義在函數上，用於拋出異常類，能夠拋出多個用逗號隔開。

當函數內容有throw拋出異常對象，並未進行try處理。必需要在函數上聲明，不然編譯失敗。
Note：throws 和 throw 的區別：
throws 使用在函數上（寫在小括號和大括號之間）。throw 使用在函數內。
throws 後面跟的異常類。能夠跟多個。用逗號隔開。throw 後跟的是異常對象。

使用格式：

返回值類型方法名稱 throws 異常類{

if(發生異常){

throw 異常類對象;

}

Note： RuntimeException除外。也就說，函數內若是拋出的RuntimeExcpetion異常，函數上能夠不用聲明。

常見方法操做：

String getMessage（）；//獲取異常的信息。返回字符串。

toString（）；//獲取異常類名和異常信息，返回字符串。

printStackTrace(); //獲取異常類名和異常信息，以及異常出如今程序中的位置.返回值void.

//其實JVM默認的異常處理機制，就是在調用printStackTrace方法，打印異常的堆棧的跟蹤信息。

printStackTrace(PrintStream s)// 一般用該方法將異常內容保存在日誌文件中，以便查閱。

五、自定義異常類

由於項目中會出現特有的問題，而這些問題並未被 java 所描述並封裝對象。因此對於這些特有的問題能夠按照 java 的對問題封裝的思想。將特有的問題，進行自定義的異常封裝。
1）自定義異常必須是自定義類繼承 Exception。
緣由：異常體系有一個特色，由於異常類和異常對象都被拋出，他們都具有可拋性。這個可拋性是 Throwable 這個體系中獨有特色，只有 Throwable 體系中的類和對象才能夠被 throws 和 throw 操做。
2）自定義異常時：若是該異常的發生，沒法在繼續進行運算，就讓自定義異常繼承RuntimeException。

3) 當自定義了異常類繼承Exception後，若是未在類中定義異常信息，那麼經過toString方法打印出來的結果就只有自定義的異常類名，不會顯示異常信息。
4) 要定義自定義異常的信息時，可使用父類已經定義好的功能。異常信息傳遞給父類的構造函數。由於父類中已經把異常信息的操做都完成了。因此子類只要在構造時，將異常信息傳遞給父類經過super語句。那麼就能夠直接經過getMessage方法獲取自定義的異常信息。

示例以下：

class MyException extends Exception {
	private String msg;

	MyException(String msg) {
		super(msg);// 返回自定義的輸入信息
	}
}

六、異常的好處：
  1）將問題進行封裝。
  2）將正常流程代碼和問題處理代碼相分離，方便於閱讀。
七、異常的處理原則：
  1）處理方式有兩種：try 或者 throws。
  2）調用到拋出異常的功能時，拋出幾個，就處理幾個。一個 try 對應多個 catch。多個 catch，父類的 catch 放到最下面。
  3）catch 內，須要定義針對性的處理方式。不要簡單的定義 printStackTrace，輸出語句。也不要不寫。
  4）當捕獲到的異常，本功能處理不了時，能夠繼續在 catch 中拋出。
八、異常的注意事項：
1）問題能在內部解決就解決，堅定再也不往外拋出。
2）catch是用於處理異常的，若是沒有catch就表明異常沒有被處理，若是該一場是編譯時異常那必需要進行聲明。
3）在子父類覆蓋時：子類拋出的異常必須是父類的異常的子類或者子集。若是父類或者接口沒有異常拋出時，子類覆蓋出現異常，只能try不能再拋。
小練習示例：

/*
老師使用電腦講課。

描述電腦：
	一、電腦運行
	二、電腦重啓
描述電腦問題：
	一、電腦藍屏了
	二、電腦起火了

描述老師：
	一、老師使用電腦
	二、老師講課。
描述老師可能出現的問題：
	一、老師不能繼續講課了，他讓同窗們本身作練習。

*/

//電腦藍屏了
class BlueScreenException extends Exception
{
	BlueScreenException(String message)
	{
		super(message);
	}
}
//電腦起火了
class FireBreakingException extends Exception
{	
	FireBreakingException(String message)
	{
		super(message);
	}
}

//老師沒法繼續上課
class StopTeachException extends Exception
{	
	StopTeachException(String message)
	{
		super(message);
	}
}
class Computer
{
	int start=1;
	//電腦啓動
	void run()throws BlueScreenException,FireBreakingException
	{
		if(start==2)
			throw new BlueScreenException("Computer_BlueScreen");
		else if(start==3)
			throw new FireBreakingException("Computer_FireBreaking");
		System.out.println("Computer_run");
	}
	//電腦重啓
	void reset()
	{	
		start=1;
		System.out.println("Computer_reset");
	}
}

class Teacher
{
	private String name;
	private Computer cpt;

	//對老師進行初始化
	Teacher(String name)
	{
		this.name=name;
		cpt=new Computer();
	}

	//老師開始講課
	public void teach()throws StopTeachException
	{
		try
		{
			cpt.run();
			
		}
		catch (BlueScreenException e)
		{
			//System.out.println(e.getMessage());
			cpt.reset();
		}
		catch (FireBreakingException e)
		{
			test();
			//System.out.println(e.getMessage());
			throw new StopTeachException("Teather_StopTeach："+e.getMessage());
		}

		System.out.println(name+"Teacher_teaching");
	}
	void test()
	{
		System.out.println("學生作練習");
	}

}
class ExceptionTest
{
	public static void main(String[] args) 
	{
		Teacher t=new Teacher("畢老師");
		try
		{
			t.teach();
		}
		catch (StopTeachException e)
		{
			System.out.println(e.toString());
			System.out.println("換老師或者放假");
		}
	}
}

2、經常使用類

一、Object類：
概述：存在於java.lang包中，是全部類的根類、超類。Java 中的每個類都直接或間接地使用Object做爲父類，全部對象都實現這個類的方法。全部類對 Object類的繼承都是java默認的，無需使用 extends 明確表示。Object 類中提供了 11 個成員方法，也就是說全部其餘類都具有這 11 個方法。其中最經常使用的方法：
public boolean equals(Object obj); //比較兩個對象是否相等
public String toString(); //返回該對象的字符串表示
void finalize(); // 當垃圾回收器肯定不存在對該對象的更多引用時，由對象的垃圾回收器調用此方法。
Class getClass(); //獲取對象的字節碼文件的描述類，後面再講反射的時候還會在說這個類。String name = s.getClass().getName();
int hashCode(); // 獲取對象的哈希值。其實就是對象的內存地址值十進制表示若自定義類中有與 Object 類中相同的方法功能，沒有必要從新定義。
//只要沿襲父類中的功能，創建本身特有的內容便可，也就是覆蓋。
equals()：咱們獲取對象後，比較它的地址值意義不大。因此也會對這個方法進行重寫。重寫要完成什麼功能，是根據需求定的。
"==" 和 equals 的用法：
"==":
1) 能夠用於比較基本數據類型，比較的就是基本數據類型的值是否相等。
2) 能夠用於比較引用數據類型，比較的是對象的地址值是否相等。
equals:
1) equals 只能用於比較引用數據類型的。
2) Object 提供的 equals 是用於比較對象地址值是否相同。
3) 自定義類中，若是重寫了 equals 方法，那麼就是按照你本身的需求來比較的。
toString()：
表示格式：getClass().getName()+"@"+Integer.toHexString(hashCode());通常咱們輸出對象名的時候，其實底層調用的就是該對象的 toString()方法。這種返回沒有意義，因此，咱們會重寫這個方法，顯示類的成員變量信息。
二、String類：
概述：多個字符組成的一個序列，叫字符串。生活中不少數據的描述都採用的是字符串的，並且咱們還會對其進行操做。字符串是一個特殊的對象，是一個被 final 修飾的類，因此不可能有子類。字符串一旦初始化就不能夠被改變（此處指的是內存中的地址值不可改變）。

構造方法：

1）String():無參構造
eg： String s = new String();
s = "hello";
  2）String(byte[] bys): 傳一個字節數組做爲參數
eg： byte[] bys = {97,98,99,100,101};
  String s = new String(bys);
  3）String(byte[] bys,int index,int length): 把字節數組的一部分轉換成一個字符串
eg：byte[] bys = {97,98,99,100,101};
String s = new String(bys,1,2);
  4）String(char[] chs): 傳一個字符數組做爲參數
eg：char[] chs = {'a','b','c','d','e'};
       String s = new String(chs);
  5）String(char[] chs,int index,int length): 把字符數組的一部分轉換成一個字符串
eg：char[] chs = {'a','b','c','d','e'};
String s = new String(chs,1,3);
  6）String(String str): 把一個字符串傳遞過來做爲參數
eg：String ss = new String(s);
  7）直接把字符串常量賦值給字符串引用對象(最經常使用)
eg：String s = "hello";
常見方法：

1）獲取

1.1字符串中包含的字符數，也就是字符串的長度

int length（）：//獲取長度。

1.2根據位置獲取位置上的某個字符

char charAt（int index）：//當訪問到字符串中不存在的角標時，會發生字符串角標越界的錯誤。

1.3根據字符獲取該字符存在字符串的位置

int indexOf（int ch）：//返回的是ch在字符串中第一次出現的位置。//傳入的是字符對應的ASCII碼。//若是沒有找到，返回-1。

int indexOf（int ch，int fromIndex）：//從fromIndex指定位置開始，獲取ch在字符串中出現的位置。

int indexOf（String str）：//返回的是str在字符串中第一次出現的位置。

int indexOf（String str，int fromIndex）：//從fromIndex指定位置開始，獲取str在字符串中出現的位置。

int lastIndexOf（）：//反向索引

2）判斷

2.1字符串中是否包含某一個子串

boolean contains（str）；

Note：indexOf（str）能夠索引str第一次出現的位置，若是返回-1表示該str不在字符串中存在。因此，也能夠用於對指定判斷是否包。如：if（str.indexOf（「aa」）！=-1）並且該方法既能夠判斷，又能夠獲取出現的位置。若是隻爲判斷，用contains。

2.2字符串中是否有內容

boolean isEmpty()；//原理就是判斷長度是否爲0。

2.3字符串是不是以指定內容開頭

boolean startsWith（str）；

2.4字符串是不是以指定內容結尾

boolean endsWith（str）；

2.5判斷字符串內容是否相同，複寫了Object類中的equals方法

boolean equals（str）；

2.6判斷內容是否相同，並忽略大小寫。

boolean equalsIgnoreCase（）；

3）轉換

3.1將字符數組轉成字符串

構造方法：String(char[])；

String(char[],offset,count)；//將字符數組中的一部分轉成字符串。

靜態方法：

static String copyValueOf(char[])；

static String copyValueOf(char[] data,int offset ,int count )；

static String valueOf(char[])；

3.2將字符串轉成字符數組

char[] toCharArray()；

3.3將字節數組轉成字符串

String(byte[])；

String(byte[],offset,count)；//將字節數組中的一部分轉成字符串。count表示個數。

3.4將字符串轉成字節數組

byte[] getBytes()；

3.5將基本數據類型轉成字符串

String valueOf(int)；

String valueOf(double)；

Note：字符串和字節數組在轉換過程當中，是能夠指定編碼表的。

4）替換

String replace(oldchar,newchar)；//返回的是一個新字符串。若是要替換的字符不存在，返回的仍是原字符串。

5）切割

String[] split(regex)；//涉及到正則表達式的點，不能做爲切割字符串的regex。

6）子串，獲取字符串中的一部分

String substring(begin)；//從指定位置開始到結尾。若是角標不存在，會出現字符串角標越界異常。

String substring(begin,end)；//包含頭，不包含尾。

7）轉換，去除空格，比較

7.1將字符串轉成大寫或小寫

String toUpperCase();

String toLowerCase();

7.2將字符串兩端的多個空格去除

String trim();

7.3對兩個字符串進行天然順序的比較

int compareTo(String);

基於上述知識點，幾個小練習演示以下所示：

/*
 * 練習：一、字符串反轉
 *       二、獲取一個字符串在另外一個字符串中出現的次數
 *       三、有兩個字符串，找出兩個字符串中最大相同那個字符串
 */

public class StringTest {

	// 一、字符串反轉
	public static String reverseString(String str) {
		char[] ar = str.toCharArray();// 將字符串轉成字符數組
		reverse(ar);// 將字符數組進行反轉
		return new String(ar);// 返回反轉後的字符串
	}

	// 逐個調換字符數組中的對應位置的字符
	public static void reverse(char[] ar) {
		for (int i = 0, j = ar.length - 1; i < j; i++, j--) {
			swap(ar, i, j);
		}
	}

	// 自定義反轉數組中的兩個元素
	private static void swap(char[] ar, int i, int j) {
		char temp = ar[i];
		ar[i] = ar[j];
		ar[j] = temp;
	}

	// 二、獲取一個字符串在另外一個字符串中出現的次數
	public static int getNumOfString(String str, String key) {
		int num = 0;// 定義計數器
		int index = 0;// 定義腳標，用於記錄查詢位置
		while ((index = str.indexOf(key, index)) != -1) {
			// indexOf(key) 或者indexOf(key,beginIndex)均可以
			// str = str.substring(index + key.length());
			index = index + key.length();// 下一次的查詢其實位置是前一次查詢返回值加上字符串長度，以此保證每次都是日後偏移查詢
			num++;// 查到一次，計數器自增1
		}
		return num;
	}

	// 三、有兩個字符串，找出兩個字符串中最大相同那個字符串
	public static String getMaxSubString(String str1, String str2) {
		// 不論傳進來的兩個字符串誰更長，自定義maxString、minString來指向長字符串和短字符串
		String maxString = str1.length() > str2.length() ? str1 : str2;
		String minString = maxString == str1 ? str2 : str1;

		String maxSubString = null;
		for (int i = 0; i < minString.length(); i++) {// 控制在最短字串長度內
			// 依次遞減短字符串子串
			for (int j = 0, k = minString.length() - i; k <= minString.length(); j++, k++) {
				maxSubString = minString.substring(j, k);// 獲取短字符串的子串
				if (maxString.indexOf(maxSubString) != -1) {// 若是包含在長字符串中則代表找到了
					return maxSubString;
				}
			}
		}
		return "-1";
	}

	public static void main(String[] args) {
		String str = "abc cde";
		String s1 = "ascasfhelloasfasf v";
		String s2 = "ashellolkkd";
		System.out.println(reverseString(str));
		System.out.println(getNumOfString(str, "c"));
		System.out.println(getMaxSubString(s2, s1));
	}
}

結果以下所示：

三、StringBuffer類
概述：字符緩衝區類，是一個容器，一個線程安全的可變字符序列。 StringBuffer 能夠對字符串內容進行增刪改查等操做，不少方法和 String 相同。

特色：長度是可變化的。能夠直接操做多個數據類型。最終會經過 toString 方法變成字符串。

常見操做：

1）存儲

StringBuffer append()：將指定數據做爲參數添加到已有數據的結尾處。

StringBuffer insert(intoffset ,數據)：能夠將數據插入到指定offset位置。

2）刪除

StringBufferedelete(start,end)：刪除緩衝區中的數據，包含start，不包含end。

StringBuffer deleteCharAt(index)：刪除指定位置的字符。//清空緩衝區：對象.delete(0,對象.length());

3）獲取

char charAt(int index)；

int indexOf(String str)；

int lastIndexOf(String str)；

int length()；

String substring(int start,int end)；

4）修改

StringBuffer replace(int start,int end,String str)；

void setCharAt(int index,char ch)；

5）反轉

StringBuffer reverse()；

6）將緩衝區中指定數據存儲到指定字符數組中

voidgetChars(int srcBegin, int srcEnd,char[] dst,int dstBegin)
四、StringBuilder類
概述：StringBuilder在JDK1.5 版本以後出現的，一個可變的字符序列。此類提供一個與 StringBuffer 兼容的 API，但不保證同步。該類被設計用做 StringBuffer 的一個簡易替換，用在字符串緩衝區被單個線程使用的時候（這種狀況很廣泛）。若是可能，簡易優先採用 StringBuilder 類，由於此類比 StringBuffer 效率高。
StringBuilder 和 StringBuffer 的功能是同樣的，可是有區別：
StringBuffer(JDK1.0)是線程安全的。通常用於多線程。
StringBuilder(JDK1.5)不保證線程安全。通常用於單線程。
Note：通常來講，咱們寫的程序都是單線程的，因此，用 StringBuilde，效率高，之後開發建議使用 StringBuilder。

五、System類
概述：System類包含一些有用的類字段和方法。它不能被實例化。在System類提供的設施中，有標準輸入、標準輸出和錯誤輸出流；對外部定義的屬性和環境變量的訪問；加載文件和庫的方法；還有快速複製數組的一部分的實用方法。其中的屬性和方法全是靜態。
字段摘要：
  err 「標準」錯誤輸出流
  in 「標準」輸入流；默認是鍵盤
  out 「標準」輸出流；默認是控制檯
方法：
  static void setIn(InputStream in) 從新分配「標準」輸入流
  static void setOut(PrintStream out) 從新分配「標準」輸出流
  static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length);從指定源數組中複製一個數組，複製從指定的位置開始，到目標數組的指定位置結束。
  static long currentTimeMillis(); 返回以毫秒爲單位的當前時間。
  exit(int status); 退出當前虛擬機。0 以外的表示非正常退出。
  static void gc(); 運行垃圾回收器
  getProperty(); 獲取指定鍵提示的系統屬性
  static Properties getProperties(); 獲取系統屬性信息，肯定當前的系統屬性。
//由於 Properties 是 Hashtable 的子類，也就是 Map 集合的一個子類對象。那麼能夠經過map 的方法取出該集合中的元素。該集合中存儲都是字符串。沒有泛型定義。
六、Runtime類
概述：每一個 Java 應用程序都有一個 Runtime 類實例，使應用程序可以與其運行的環境相鏈接。能夠經過 getRuntime()方法獲取當前運行時，應用程序不能建立本身的Runtime 類實例。
理解：此類沒有提供構造函數。因不能直接 new 建立本身的類對象，會聯想到類中全部方法都是靜態的。可是該類中還有非靜態方法。說明該類確定會提供了方法獲取本類對象。並且該方法是靜態的，並返回值類型是本類類型。由這個特色能夠看出該類使用了單例設計模式完成。該方式爲：static Runtime getRuntime(); //返回與當前 Java 應用程序相關的運行時對象。
其餘方法：
  Process exec(String conmand); //在單獨的進程中執行指定的字符串命令。

Note：在使用時容易發生異常，須要在方法上拋出異常。其中的參數大多數爲 String 類型，能夠是一個應用程序或者其地址，做用是執行打開一個應用程序。Process 是一個抽象類，不須要本身去實現它，由於計算機底層自動實現了該類。其中的方法有：Abstract void destroy()用以殺掉子進程。
七、Date類
概述：表示特定的瞬間，精確到毫秒。在 JDK1.1 開始，使用 Calendar 類實現日期和時間字段之間轉換。使用 DateFormat 類來格式化和解析日期字符串。Date 中的相應大部分方法已廢棄。UTC 爲世界標準時間。GMT 爲民間標準（格林威治標準時）
構造方法:
public Date(); //分配 Date 對象並初始化此對象，以表示分配它的時間（精確到毫秒）。
  public Date(long Date); //分配 Date 對象並初始化此對象，以表示自從標準基準時間（稱爲「曆元（epoch）」，即 1970 年 1 月 1 日 00:00:00GMT）以來的指定毫秒數。
方法摘要：
  int compareTo(Date anotherDate) // 比較兩個日期的順序。
  boolean equals(Object obj) //比較兩個日期的相等性。
  public void getTime(); //返回當前時間的毫秒值
  public void setTime(); //設置當前毫秒值
  boolean after(Date when); //測試此日期是否在指定日期以後。
  boolean before(Date when);// 測試此日期是否在指定日期以前。
long 與 Date 類型轉換：
  System.currentTimeMillions();//獲取系統當前時間，返回值 long 類型
  Date.getTime();(注：需先建立 Date 對象)
Date 與 String 類型轉換：
  public final String format(Date date);
獲取系統時間的兩種方法的區別：
第一種：
  Date time=new Date(); //建立時間對象

  System.out.println(time); //輸出系統時間
第二種：
  long l=System.currentTimeMillis();//獲取系統當前時間
  Date d=new Date(l);
  System.out.println(d);
分析：兩種方法的 Date 時間運行的結果相同,它們都建立時間對象 Date，區別在於第二種方法時間對象引用了系統的 long 型時間。而 System.currentTimeMillis()方法返回值爲 long 型，還能夠利用此方法計算應用程序的運行時間。
八、DateFormat與SimpleDateFormat類
DateFormat：使用與語言無關的方式格式化和並解析日期和時間。是一個日期格式化子類的抽象類。該類能夠進行格式化也能夠解析字符串。
方法：
String format(Date date);//將 Date 日期格式化爲日期時間字符串。

SimpleDateFormat：是一個以與語言環境有關的方式來格式化和解析日期的具體類。它容許進行格式化（日期 -> 文本）、解析（文本 -> 日期）和規範化。

方法：
  SimpleDateFormat(); // 用默認的模式和默認語言環境的日期格式符號構造 SimpleDateFormat。
  SimpleDateFormat(String pattern); //參數 Date，建立格式對象。用給定的模式和默認語言環境的日期格式符號構造
格式化日期時間步驟：
  1)在建立對象時指定一個格式：YYYY 年 MM 月 dd 日 HH：mm:ss (若是調用格式化器無參構造，此步驟省略)
  2)建立一個格式器 SimpleDateFormat
  3)建立一個日期對象 Date d
  4)使用格式化器的 formate 方法格式化 d，獲得想要的格式字符串。
Note：hh 表示 12 小時制（1—12），HH 表示 24 小時制（0—23），更多日期和時間模式請參考SimpleDateFormat類的API說明
示例以下：

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

/*
 * Date類：
 * 一、獲取系統當前時間
 * 二、利用SimpleDateFormat類格式化指定時間
 */
public class DateDemo {
	public static void main(String[] args) {

		// 第一種獲取方式
		Date date1 = new Date();

		// 第二種獲取方式
		long time = System.currentTimeMillis();
		Date date2 = new Date(time);
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH時mm分ss秒");
		String needDate = sdf.format(date2);
		System.out.println("系統時間戳：" + date2);
		System.out.println("格式化時間：" + needDate);
		System.out.println("格式化模板：" + sdf.toPattern());
	}
}

結果以下：

九、Calendar類
概述：Calendar 是一個抽象類。時間點（某一時刻）
方法：
getInstance(); //獲取日曆（使用默認時區和語言環境獲取一個日曆），不是經過子類建立，而是經過父類方法 getInstance()返回一個 Calendar對象。
int get(int field);//參數是日曆字段值 ,月份的統計是從 0 到 11 的
void set(); //設置日曆字段。
abstract void add(int field,int amount); //根據日曆規則，爲給定的日曆字段添加或者減去指定的時間量。
如下返回值類型爲 int：
年： calendar.get(Calendar.YEAR);
月: calendar.get(Calendar.MONTH);
日: calendar.get(Calendar.DAY_OF_MONTH);
星期: calendar.get(Calendar.DAY_OF_WEEK);
時： calendar.get(Calendar.HOUR_OF_DAY);
分： calendar.get(Calendar.MINUTE);
秒： calendar.get(Calendar.SECOND);
示例以下：

import java.util.Calendar;

/*
 * Calendar類：
 * 	set() 給指定日曆設置給定值
 * 	get() 獲取指定字段
 * 
 * 	add() 在指定時間上加上一個指定的值再顯示
 */
public class CalendarDemo {

	public static void main(String[] args) {

		// 獲取某年2月的天數，例如2012年的2月有幾天
		Calendar c = Calendar.getInstance();
		// 3月1日減一天就是2月的最後一天，Calendar月份範圍0-11
		c.set(2012, 2, 1);
		c.add(Calendar.DAY_OF_MONTH, -1);
		System.out.println(c.get(Calendar.YEAR) + "年"
				+ (c.get(Calendar.MONTH) + 1) + "月共有"
				+ c.get(Calendar.DAY_OF_MONTH));
		// 日曆設置到2個月後
		c.add(Calendar.MONTH, 2);
		System.out.println("日曆設置到2個月後是" + c.get(Calendar.YEAR) + "年"
				+ (c.get(Calendar.MONTH) + 1) + "月"
				+ c.get(Calendar.DAY_OF_MONTH) + "日");
	}

}

結果以下：

十、Math類（靜態工具類）
Math:包含用於數學基本運算的方法。
字段摘要：
E：天然對數的底數。（double）
PI： π，即圓周與直徑之比。（double）
方法：
abs(); //絕對值
cbrt(); //立方根
ceil(); //返回大於等於參數的最小整數（double）特別注意負數的值
floor(); //返回小於等於參數的最小整數（double）
round(); //四捨五入（int 或 long）原理：原數加 0.5 判斷
random(); //僞隨機數（0——1 之間的數，不包含 1）
max(); //返回兩個數中最大值
min(); //返回兩個數中最小值
Note： 此處的 random 類與 Math 類中的 random()方法做用相似。Random 類能夠生成對象，用其下的 next()方法或者 nextInt()方法生成僞隨機數。其中有方法：
int next(int bits); //生成下一個僞隨機數
int nextInt(int n); //返回下一個僞隨機數，在 0 與指定值（不包括指定值）之間均勻分佈的 int 值。
3、GUI
一、概述：
GUI：Graphical User Interface(圖形用戶接口)。用圖形的方式，來顯示計算機的操做圖形界面。方便、直觀。
CLI：Command line User Interface(命令行用戶接口)。就是 DOS 命令行操做。不直觀。
Java 爲 GUI 提供的對象，都存在 java.Awt 和 javax.Swing 兩個包中。Java中對於圖形化編程有個完整的繼承體系：

如圖所示：

Awt 與 Swing：
java.Awt: (Abstract Window Toolkit,抽象窗口工具集)，須要調用本地系統方法實現功能。屬重量級控件。跨平臺性較弱。
javax.Swing: 在 AWT 基礎上，創建一套圖形界面系統，其中提供了更多組件，並且徹底由 Java 實現。加強了可移植性，屬輕量級控件。
Note：開發時，製做圖形化界面時，通常須要導入兩個包，import java.awt.*; 和 import java.awt.event.*;。
二、佈局管理器
佈局：容器中組件的排放方式。
常見的佈局管理器：
FlowLayout(流式佈局管理器)：從左到右的順序排列。Panel 默認的佈局管理器。
  BorderLayout(邊界佈局管理器):東南西北中。Frame 默認的佈局管理器。
  GridLayout(網絡佈局管理器)：規則的矩陣。
  GardLayout（卡片佈局管理器）：選項卡。
  GridBagLayout(網格包佈局管理器):非規矩的矩陣。
三、Component
Component 是一個具備圖形表示能力的對象，可在屏幕上顯示，並可與用戶進行交互。經常使用子類：Window、Panel(面板，不能單獨存在)。Window 經常使用子類：Frame、DialogFrame 類：是帶有標題和邊框的頂層窗口。若顯示窗體，必須設置 setVisible 顯示。設置 Frame 時，有一個默認的管理器是邊界式佈局（BorderLayout）。
主要方法：
  add() //添加組件（含參數）
  setVisible(Boolean b) //根據參數的值來顯示或隱藏組件
  setSize() //設置窗體大小，參數爲窗口的橫座標和縱座標
  setLocation() //設置窗體在本地位置，參數爲橫、縱座標
  setLayout() //設置佈局管理器（參數能夠是相應佈局管理器的對象）
  setBounds() //移動組件並調整其大小，參數是 4 個座標（左邊距、右邊距、寬、高）
  addMouseListener() //添加指定的鼠標監聽器
  addKeyListener() //添加鍵盤監聽事件
建立圖形化界面的步驟：
  1）建立 frame 窗體。
  2）對窗體進行基本設置。好比大小，位置，佈局。
  3）定義組件。
  4）將組件經過窗體的 add 方法添加到窗體中。
  5）讓窗體顯示，經過 setVisible(true)
四、事件監聽機制
組成：
事件源、事件（Event）、監聽器（Listener）、事件處理（引起事件後處理方式）
事件源：就是 awt 包或者 swing 包中的那些圖形界面組件。
事件：每個事件源都有本身特有對應事件和共性事件。
監聽器：將能夠觸發某一個事件的全部動做都封裝到監聽器中。
事件處理：對時間元傳來的信息進行處理並反饋出去。

Note：在 java 中事件源、事件（Event）、監聽器（Listener）都已定義好，直接獲取其對象使用。只須要作事件處理（對產生的動做進行處理）。
五、Window（窗體事件）
Window :
addWindowListener( ) //添加窗口事件監聽器
windowListener 接口：複寫方法，實例化對象，才能使用。但它有一個已複寫所有方法的子類WindowAdapter。
WindowAdapter：接收窗口事件的抽象適配器類。此類中的方法爲空。它是一個沒有抽象方法的抽象類，目的是不能建立對象。此類存在的意義是方便建立監聽器對象。使用：由於 WindowListener 的子類 WindowAdapter 已經實現了 WindowListener 接口。並覆蓋了其中的全部方法。那麼我只要繼承自 Windowadapter 覆蓋我須要的方法便可。具體方法以下：
windowClosing( ) //關閉窗口
  windowIconified( ) //窗口最小化狀態
  windowOpened() //打開窗口
  windowActivated() //前置窗口
  windowClosed() //關閉窗口
  wind owDeactivated() //後置窗口
六、Button（含 Action 事件）
方法：
  addActionListener() //添加指定的動做監聽器
ActionListener 接口：用於接收操做事件的監聽器接口。是少數沒有適配器接口的其中一個。其中只有一個方法 actionPerformed(),做用：發生操做時調用。
七、鼠標事件和鍵盤事件
MouseListener: 用於接收組件上「感興趣的」鼠標事件（eg：按下、釋放、單擊、進入或離開）的監聽器接口。有適配器。
方法：
  mouseClicked(MouseEvent e) //鼠標單擊（按下並釋放）
  mouseEntered(MouseEvent e) //鼠標進入組件
  mouseExited(MouseEvent e) //鼠標離開組件
  mousePressed(MouseEvent e) //鼠標按下時
  mouseReleased(MouseEvent e) //鼠標釋放時
Note：鼠標按下與 Action 事件同時存在操做時，鼠標按下先發生。
MouseEvent: (適配器)
成員變量：static int mouse_clicked
方法：
  int getClickCount() //返回鼠標單擊次數
keyListener: 有適配器。
  static int VK_ENTER
  keyPressed(keyEvent e) //按下某個鍵時調用此方法
  keyReleased(keyEvent e) //釋放某個鍵時調用此方法
  keyTyped(keyEvent e) //鍵入某個鍵時調用此方法
keyEvent: (適配器)
  char getkeyChar() //返回與此事件中的鍵相關聯的字符
  int getkeyCode() //獲取鍵盤對應的碼
  static String getKeyText(int keyCode) //經過碼獲取對應的鍵盤字符
Note：InputEvent 類中 isControlDown() 判斷 ctrl 鍵是否被按下；InputEvent 類中 consume() 以非默認方式處理事件，屏蔽鍵
八、TextField 和 TextArea
TextField: 文本框類；TextArea:  文本區域
構造方法: TextField() //建立文本框。帶參數能夠設置文本框大小，只能指定列（寬）。
TextArea()   //建立文本區域，既能指定行數又能指定列數，還能夠指定文本區域內含有的默認文字
方法：
append(String str) //追加文本。將給定文本追加到文本區的當前文本在他們的父類 TextComponent 中，
String getText() //獲取文本的方法
setText()   //設置填充文本內容，參數爲內容
九、Dialog 和 Label
Dialog: 是一個帶標題和邊界的頂層窗口。對話框，默認邊界佈局管理器，通常對話框不能單獨存在，必須依賴於窗體。
FileDialog: 是 Dialog 的子類。顯示一個對話框窗口，用戶能夠從中選擇文件。構造參數能夠有模式：FileDialog.LOAD(打開，加載文件)和 FileDialog.SAVE（保存）默認打開。
方法：
String getFile() //獲取選定文件
String getDirectory() //獲取文件對話框目錄
Label: 標籤，最經常使用的控件之一，setText()來設置指定文本
十、MenuBar、MenuItem、Menu
MenuBar: 封裝綁定到框架的菜單欄的平臺概念。爲了將該菜單欄與Frame對象關聯，能夠調用該框架的setMenuBar方法，add()用來添加菜單欄。
MenuItem：菜單項
Menu：菜單條，其中add()用來將指定菜單項或者標籤添加到菜單欄。
Note：MenuBar 包括 Menu，Menu 包括 MenuItem、Menu（帶箭頭）。MenuBar 爲菜單欄，通常一個窗口中只有一個；Menu 菜單項，能夠設置多個，若並排顯示，都添加進 MenuBar；若顯示在菜單項中（帶二級箭頭菜單條），則 Menu 嵌套（添加）Menu 便可。MenuItem 子菜單，是最終子菜單。能夠設置多個，添加進 Menu。
GUI示例以下：

/*
 GUI：文本框和文本區域功能等（對話框）
 */

import java.awt.*;
import java.awt.event.*;
import java.io.*;

public class MyWindowDemo {
	private Frame f;
	private TextField tf;
	private Button but;
	private TextArea ta;

	private Dialog d;
	private Label lab;
	private Button okBut;

	MyWindowDemo() {
		init();
	}

	public void init() {
		f = new Frame("my window");
		f.setBounds(300, 100, 600, 500);
		f.setLayout(new FlowLayout());

		tf = new TextField(60);

		but = new Button("轉到");

		ta = new TextArea(25, 70);

		// 此處不該該直接初始化對話框等組件，通常處理用戶出錯問題再建立使用對話框
		// 這裏只爲演示看效果。
		d = new Dialog(f, "提示信息-self", true);
		d.setBounds(400, 200, 240, 150);
		d.setLayout(new FlowLayout());
		lab = new Label();
		okBut = new Button("肯定");

		d.add(lab);
		d.add(okBut);
		// 注意：不要將對話框添加到frame中，只有出現問題纔會調用出現對話框

		f.add(tf);
		f.add(but);
		f.add(ta);

		myEvent();
		f.setVisible(true);
	}

	private void myEvent() {

		okBut.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				d.setVisible(false);
			}
		});
		d.addWindowListener(new WindowAdapter() {
			public void windowClosing(WindowEvent e) {
				d.setVisible(false);
			}
		});

		tf.addKeyListener(new KeyAdapter() {
			public void keyPressed(KeyEvent e) {
				if (e.getKeyCode() == KeyEvent.VK_ENTER)
					showDir();
			}
		});

		but.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				showDir();

			}
		});

		f.addWindowListener(new WindowAdapter() {
			public void windowClosing(WindowEvent e) {
				System.exit(0);
			}
		});
	}

	private void showDir() {
		String dirPath = tf.getText();

		File dir = new File(dirPath);

		if (dir.exists() && dir.isDirectory()) {
			ta.setText("");// 清空文本
			String[] names = dir.list();
			for (String name : names) {
				ta.append(name + "\r\n");// 追加文本
			}
		} else {
			String info = "您輸入的信息：" + dirPath + "是錯誤的。請重輸";
			lab.setText(info);
			d.setVisible(true);
		}
	}

	public static void main(String[] args) {
		new MyWindowDemo();
	}
}

結果以下：

4、正則表達式
一、概述：符合必定規則的表達式。一些特殊符號的使用。
做用：用於操做字符串
特色：用於一些特定的字符串來表達一些代碼操做---到達簡化效果
好處：能夠簡化對字符串的校驗操做
弊端：符號定義越多，正則越長，閱讀性極差
二、正則表達式構造摘要（非捕獲組）主要：
----字符類：只能規則一個字符
[abc]  判斷字符串當中某一個字符位上出現的字符。字符是 a、b 或 c。
  [^abc]  任何字符，只要不是 a、b、c 便可。
  [a-zA-Z]  a 到 z 或 A 到 Z，兩頭的字母包括在內（範圍）
  [a-d[m-p]] a 到 d 或 m 到 p：[a-dm-p]（並集）
  [a-z&&[def]] d、e 或 f（交集）
----預約義字符類：這裏的\不是轉義字符。使用時，記得用\\
  .  任何字符（與行結束符可能匹配也可能不匹配）
  \d  數字：[0-9]
  \D  非數字： [^0-9]
  \s  空白字符：[ \t\n\x0B\f \r]
  \S  非空白字符：[^\s]
  \w  單詞字符：[a-zA-Z_0-9]
  \W  非單詞字符：[^\w]
----Greedy 數量詞：x 表明規則,當字符不肯定或者不少的時候
  X? X，一次或一次也沒有
  X*  X，零次或屢次
  X+  X，一次或屢次
  X{n} X，剛好 n 次
  X{n,} X，至少 n 次
  X{n,m} X，至少 n 次，可是不超過 m 次
----邊界匹配器：
  ^  行的開頭
  $  行的結尾
  \b  單詞邊界
  \B  非單詞邊界
  \A  輸入的開頭
  \G  上一個匹配的結尾
  \Z  輸入的結尾，僅用於最後的結束符（如有）
  \z  輸入的結尾
三、具體操做功能：
1）匹配：String matches(regex)
  2）切割：String[] split(String regex)
  3）替換：String replaceAll(String regex, String replacement)String 類中方法：
  4）獲取：將字符串中符合規則的子串取出，具體操做步驟以下：
      a）將正則表達式封裝成對象
      b）讓正則對象和藥操做的字符串相關聯

c）獲取正則匹配引擎
d）經過引擎對符合規則的子串進行取出
四、功能選擇：
1）只想知道是否正確————>匹配
2）想要將已有的字符串便稱另外一個字符串————>替換
3）想要按照本身的規則將字符串變成多個子串————>切割
4）想要拿到符合需求的字符串子串————>獲取
示例1：

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/*
 * 正則表達式：
 * 	做用：用於操做字符串
 * 	特色：用於一些特定的字符串來表達一些代碼操做---到達簡化效果
 * 	好處：能夠簡化對字符串的校驗操做
 * 	弊端：符號定義越多，正則越長，閱讀性極差
 * 
 * 具體操做功能：
 * 	一、匹配：String matches(regex)
 * 	二、切割：String[] split(String regex) 
 * 	三、替換：String replaceAll(String regex, String replacement)
 * 	四、獲取：將字符串中符合規則的子串取出
 * 	操做步驟：
 * 		1）將正則表達式封裝成對象
 * 		2）讓正則對象和藥操做的字符串相關聯
 * 		3）獲取正則匹配引擎
 * 		4）經過引擎對符合規則的子串進行取出
 * 
 * 
 */
public class RegexDemo {

	public static void main(String[] args) {
		System.out.println("---------checkQQ-----------");
		checkQQ();
		System.out.println("---------regexDemo1-----------");
		regexDemo1();
		System.out.println("---------checkPhonenum-----------");
		checkPhonenum();
		System.out.println("---------splitDemo-----------");
		splitDemo();
		System.out.println("---------replaceAllDemo-----------");
		replaceAllDemo();
		System.out.println("---------getDemo-----------");
		getDemo();
	}

	// 獲取
	public static void getDemo() {
		String str = "zhong guan cong hei ma di shi er qi jiu yao kai ban le.";
		System.out.println("字符串：" + str);
		String regex = "\\b[a-z]{4}\\b";
		// 將規則封裝成對象
		Pattern p = Pattern.compile(regex);
		// 讓正則對象和要做用的字符串相關聯,獲取匹配器對象
		Matcher m = p.matcher(str);
		// String類中的matches()用的就是Pattern和Matcher對象來完成的，僅僅爲了使用簡單而封裝的，功能單一

		// 將規則做用到字符串上，並進行符合規則的子串查找
		// boolean flag = m.find();
		// System.out.println(flag);
		// System.out.println(m.group());// 用於獲取匹配後的結果
		System.out.println("獲取結果爲：");
		while (m.find()) {
			System.out.println(m.group());
			System.out.println(m.start() + "..." + m.end());
		}

	}

	// 替換
	public static void replaceAllDemo() {
		String str = "wwwwwwwitheimaaaaacom";
		// 用「#」替換數字
		// String repstr = str.replaceAll("\\d{5,}", "#");

		// 將疊詞替換&
		// String repstr = str.replaceAll("(.)\\1+", "&");

		// 將重疊的字母替換成單個字母,用$n(n爲前面的組標識)獲取前面的組
		String repstr = str.replaceAll("(.)\\1+", "$1");
		System.out.println("字符串：" + str + "替換後結果爲：" + repstr);
	}

	// 切割
	public static void splitDemo() {
		String str = "wwwkkitheimaqqcom";
		// str = "d:\\abc\\a.txt";
		// .表明任何字符（與行結束符可能匹配也可能不匹配）要使用必須轉義 \\.
		// String regex = "\\.";

		// 路徑分隔符\\對應的regex爲\\\\
		// String regex = "\\\\";

		// 按照疊詞切割.
		// 爲了讓規則的結果被重用，能夠講規則封裝成一個組，用()完成。
		// 組的出現都有編號，從1開始，要想使用就能夠經過\n(n爲租的編號)表示
		String regex = "(.)\\1+";
		String[] arr = str.split(regex);
		System.out.println("切割結果以下：");
		for (String ar : arr) {
			System.out.println(ar);
		}
	}

	// 匹配測試1
	public static void regexDemo1() {
		String str = "a111111";
		String regex = "[a-z]\\d{3,5}";
		System.out.println("匹配測試1" + str.matches(regex));
	}

	// 匹配手機號：手機號段 13xxx 15xxx 18xxx
	public static void checkPhonenum() {
		String phone = "18767330882";
		String regex = "1[358]\\d{9}";
		boolean flag = phone.matches(regex);
		if (flag) {
			System.out.println("驗證手機號" + phone + "---is ok");
		} else {
			System.out.println("驗證手機號" + phone + "---is wrrong");
		}
	}

	// 驗證QQ號，不能0開頭，5-15位，不能有字符
	public static void checkQQ() {
		String qq = "1512465";
		String regex = "[1-9]\\d{4,14}";

		boolean flag = qq.matches(regex);
		if (flag) {
			System.out.println("驗證QQ號" + qq + "---is ok");
		} else {
			System.out.println("驗證QQ號" + qq + "---is wrrong");
		}
	}
}

結果如圖所示：

示例2：

import java.util.Collections;
import java.util.TreeSet;

/*
 * 功能選擇：
 * 一、只想知道是否正確————>匹配
 * 二、想要將已有的字符串便稱另外一個字符串————>替換
 * 三、想要按照本身的規則將字符串變成多個子串————>切割
 * 四、想要拿到符合需求的字符串子串————>獲取
 */
public class RegexTest {

	public static void main(String[] args) {
		System.out.println("----------regexTest1----------");
		regexTest1();
		System.out.println("----------ipSort----------");
		ipSort();
		System.out.println("----------checkMail----------");
		checkMail();
	}

	// 對郵件地址進行驗證。
	public static void checkMail() {
		String mail = "cavenzzep@163.com.cn";
		String regex = "\\w+@[a-zA-Z0-9]+(\\.[a-zA-Z]+){1,3}";
		System.out.println(mail.matches(regex));
	}

	// * 練習需求： 將下面的字符串轉換成(我要進黑馬)
	public static void regexTest1() {
		String str = "我我...我我...我要...要要要...要去...去去去...去北京...京京京";
		// 將已有的字符串變成另外一個字符串————>替換
		// 一、先將.去掉
		// 二、將重複的內容變成單個子符內容
		str = str.replaceAll("\\.+", "");
		System.out.println(str);
		str = str.replaceAll("(.)\\1+", "$1");
		System.out.println(str);
	}

	// 將ip地址進行地址段順序排序
	public static void ipSort() {
		String ip = "192.168.0.1 2.2.2.1 168.192.10.10 10.10.10.10 254.254.254.1 255.255.255.1";
		ip = ip.replaceAll("(\\d+)", "00$1");
		System.out.println(ip);
		ip = ip.replaceAll("0*(\\d{3})", "$1");
		System.out.println(ip);

		String[] ips = ip.split(" ");
		TreeSet<String> tree = new TreeSet<String>(Collections.reverseOrder());
		for (String newIp : ips) {
			// System.out.println(newIp);
			tree.add(newIp);
		}
		for (String s : tree) {
			System.out.println(s.replaceAll("0*(\\d+)", "$1"));
		}
	}
}

結果如圖所示：

以上所述僅表明我的觀點，若有出入請諒解。