【個人筆記】JavaSE 基礎

注意的隱藏**：
1.就近匹配原則
2.java採用的是 Unicode 字符集
3.表達式數據結果的類型自動提升
4.注意 短語與（短路或） 的巧用
5. HashMap 類對象中允許出現一對 null 鍵 null 值
6.集合中不能存放基本數據類型，而只能存放引用數據類型
7.描述文件路徑可使用 / 或 \\ 




一、開發入門
1.Java是否只有編譯過程，無所謂的鏈接，直接生成目標字節碼文件？
2.  path ：系統程序默認的尋找目錄
    classpath ：Java 類文件默認找尋路徑
    set path=%path%;[your path];
    javac.exe ：java 編譯工具
    java.exe ： java 字節碼文件運行工具
    javac.exe 編譯 --> java.exe {JVM啓動，類加載，解釋執行}
    jar.exe ：打包工具
    javadoc.exe ：文檔製作工具


二、JAVA編程基礎
1.Java 代碼的基本格式
[修飾符] class [類名]{
[程序代碼];
}
2.標識符的組成
所有大小寫字母、數字、_ 、$
3.常量
整型：0b(0B)111001010、0134、12398、0x(0X)7F
默認爲 int 類型
浮點型：0.7f(F) 、0.8d(D) 、5.022e+23f (e 表示以10爲底的指數)
默認爲 double 類型
字符：'a' '$' '\u0000'
特殊：'\r' 回車符
'\n' 換行符
'\t' 製表符
'\b' 退格符
'\'' '\"' '\\'
4.變量
4.1 數據類型
基本數據類型
整型 byte(8) short(16) int(32) long(64) 
浮點型 float(32) double(64)
字符型 char(16)
布爾型 boolean
引用數據類型
類 class
接口 interface
數組
枚舉 enum
註解 annotation
4.2 數據類型強轉時發生"高位數據丟失"
4.3 在定義時，不可同時爲多個變量賦值，如：
int x=y=z=5; 【錯】
5. 運算符
5.1 在使用 -=、+=、*=、/=、%= 等運算時，強制類型轉換會自動完成
5.2  & 與 && 的使用（| 與 || 的使用），後者爲短路與（短路或），在使用的過程中，一旦左側的結果能確定整個表達式的結果，則短路與（短路或）不進行右邊的運算。（正常與 & 會進行兩邊的運算）
b>0 && z++>1;
x==0 || y++>0;
5.3 位運算符
& 按位與、| 按位或、~ 取反、^ 按位異或、<< 左移、>> 右移、>>> 無符號右移
6.選擇結構語句
if(Expression){
...;
}


if(Expression){
...;
}else{
...;
}


三目運算符    Expression ? Expression_1 : Expression_2;


if(Expression){
...;
}else if{
...;
}
...else{
...;
}


switch(Expression){
case [Expression]:
...;
break;
case [Expression]:
...;
break;
....
default:
...;
break;
}
注：如果多個case條件後面使用的執行語句是一樣的，則該執行語句只需書寫一次即可。（在case後使用表達式時不會出現該情況）
*Code : Test_Switch.java
7.循環結構語句
while(Expression){
...;
}


do{
...;
}while(Expression);


for(初始化表達式 ; 循環條件 ; 操作表達式){
...;
}
8.跳轉語句
8.1 break
· 跳出當前循環層
· 跳出到指定循環層
*Code : Test_break.java
8.2 continue 的使用與break相似
*Code : Test_continue.java
9.方法
修飾符 返回值類型 方法名([參數類型 參數名1 , 參數類型 參數名2 , ...]){
執行語句
...
return 返回值;
}
9.1 重載：1.方法名相同  2.參數個數或參數類型不同
10.數組
10.1 一維數組
動態初始化
類型[] 數組名 = new 類型[長度];
靜態初始化
類型[] 數組名 = new 類型[]{元素,元素,...};
類型[] 數組名 = {元素,元素,...};
注意：不可寫成 int[] x = new int[4]{1,2,3,4};
10.2 多維數組
int[][] arr = new int[3][4];
int[][] arr = new int[3][];
int[][] arr = {{1,2,3},{4,5,6},{7,8}};
*Code : Test_Array.java

三、面向對象
1.特性
封裝性：將對象的屬性和行爲封裝起來，不需要讓外界知道細節
繼承性：通過繼承，可以在無需重新編寫原有類的情況下對原有類的功能進行擴展
多態性：指的是一個類中定義的屬性和方法被其他類繼承後，他們可以具有不同的數據類型或表現出不同的行爲
2.類與對象
類名 對象名稱 = new 類名();
對象引用.對象成員
2.1 this 關鍵字
· 可用於調用對象本身的屬性和方法
· 可在構造方法中調用其他構造方法，且必須位於第一行、只能調用一次
this([參數1 , 參數2 , ...]);
不能在兩個構造方法中使用this相互調用
*Code : Test_extends : Animal.java Dog.java Test.java
3.垃圾回收
可使用 System.gc(); 方法來通知Java虛擬機立即進行垃圾回收
當一個對象在內存中被釋放時，他的 finalize(); 方法會被調用
public void finalize(){
...;
}
*Code : Test_finalize.java
4. static 關鍵字
4.1 靜態（成員）變量
在內存中只有一份，能夠被一個類的所有實例對象所共享
· JVM 會初始化其值
類名.變量名  或  對象名.變量名
4.2 靜態（成員）方法
不實例化對象即可使用該方法
類名.方法名();
4.3 靜態代碼塊
在類加載時執行的代碼塊，類只加載一次，故代碼塊只執行一次
static{
...;
}
5. 內部類
5.1 成員內部類
· 在成員內部類中可以訪問外部類的所有成員
class Outer{
private int num = 4;
class Inner{
System.out.println("num = " + num);
//同 System.out.println("num = " + Outer.this.num);
}
}
· 不允許定義靜態成員
· 通過外部類訪問內部類（在其他類中實例化某個類的內部類）（外部類也會被實例化）
外部類名.內部類名 變量名 = new 外部類名().new 內部類名();
如： Outer.Inner inner = new Outer().new Inner();
*Code : Outer_Inner.Outer.java & Outer_Inner.Test.java
5.2 靜態內部類
· 使用 static 關鍵字來修飾該內部類
· 在靜態內部類中只能訪問外部類的靜態成員，不能調用外部費靜態成員變量
· 可以定義靜態成員
· 在其他類中實例化該內部類（可以在不實例化外部類的情況下實例化內部類）
外部類名.內部類名 變量名 = new 外部類名.內部類名();
*Code : Outer_Inner.Outer.java & Outer_Inner.Test.java
5.3 方法內部類
· 指在成員方法中定義的類，它只能在當前方法中被使用
· 方法內部類也可以訪問外部類的成員變量
5.4 匿名內部類
· 格式
在需要該匿名內部類實例化對象的位置使用以下格式實例化對象
new 父類(參數列表)[或 父接口](){
//匿名內部類中需要實現的方法等
}
注：該類是匿名的，故稱爲匿名內部類
*Code : test_anonymousinnerclass : Animal.java & Test.java
6.Java 的文檔註釋
· 以 /** 開頭，以 */ 結束
參數：@author ：程序的作者
@version ：程序的開發版本號
@param ：方法定義的參數以及參數對應的說明
@return ：方法的返回值代表的意義
· 生成文檔的命令
如：javadoc -d . -author -version Test.java
-d 表示指定輸出文檔存放的目錄
-author 表示文檔中需包含作者信息
-version 表示文檔中需包含版本信息 
7.繼承
· 關鍵字 ： extends
· 單繼承，多層繼承
· 重寫：子類中存在與父類中相同方法名、參數列表、返回值類型相同的方法
8.super 關鍵字
· 可使用 super 關鍵字訪問父類中的成員變量和成員方法
super.成員變量
super.成員方法([參數1,參與2,...]);
· 可使用 super 關鍵字調用父類的構造方法，且該語句必須位於子類構造函數第一行，只能有一句
super([參數1,參數2,...]);
*Code : Test_extends : Animal.java Dog.java Test.java
9.final 關鍵字
· final 修飾類 --> 不能被繼承，且該類中所有的方法自動被 final 修飾，
· final 修飾方法 --> 不能被重寫
· final 修飾變量（成員變量和局部變量） --> 常量，且只能被賦值一次，JVM不會默認對其進行初始化
10.抽象類和接口
10.1 抽象類 abstract
· 抽象類中存在構造方法
· 抽象類中未必有抽象方法
10.2 接口 interface
· 接口是特殊的抽象類，存在的所有方法都是抽象方法
· 方法默認使用 public abstract 修飾，變量默認使用 public static final 修飾（該變量只能在聲明時初始化）
· 類使用 implements 實現某些接口，接口使用 extends 繼承某些接口（使用逗號隔開多個接口）
· 繼承和實現接口同時存在時，extends 必須位於 implements 之前
· 抽象類可以只實現接口的部分方法，但普通類必須實現接口所有抽象方法
10.2.1 匿名內部類
new 父類(參數列表) 
11.多態
· 父類變量可引用子類對象
· 使用 instanceof 來判斷某個類是否是另一個類（或接口）的實例或其子類實例，返回一個boolean值
[對象或對象的引用變量] instanceof [類或接口]
12.Object 類
· 是所有類的父類
· 方法
.toString(); //輸出對象的基本信息
.getClass().getName(); //獲得所屬類的類名
.hashCode(); //返回該對象的哈希值，int類型值
13.異常 Exception
· 所有的 Error 和 Exception 都繼承自 java.lang.Throwable 類
java.lang.Throwable
Error -IOError
 -AWTError
Exception
 -RuntimeException（可不使用 catch 捕獲）
  -ArithmeticException
  -ClassCastException
 -其他子類（必須使用 catch 捕獲）（重點學習該類異常）
· 常用方法
String getMessage(); //返回此 throwable 的詳細信息字符串
void printStackTrace(); //將此 throwable 及其追蹤輸出到標準輸出流
void printStackTrace(); //將此 throwable 及其追蹤輸出到指定的輸出流
13.1 try...catch 和 finally
· 格式
try{
//程序代碼塊
}catch(ExceptionType(Exception類及其子類) e){
//對 ExceptionType 的處理
}finally{
//無論是否有捕獲到異常都要執行的程序代碼塊
}
注：finally{} 塊當不使用時可被省略
finally{} 代碼塊有一種情況下不會被執行，那就是在 try{}catch{} 中執行了 System.exit(0); 語句，該語句表示退出當前的 java 虛擬機，Java 虛擬機停止了任何代碼塊都不會執行。
13.2 throws 關鍵字
· 該關鍵字用於聲明某方法可能會發生的異常
· 被該關鍵字修飾的方法使用時必須使用 try{}catch{} 捕獲異常，或在使用該方法的方法聲明同樣可能拋出的異常
· 如果程序中的異常沒有被處理，程序就會非正常終止
· 格式
修飾符 返回值類型 方法名([參數列表]) throws ExceptionType_1 [,ExceptionType_2[,...]]{}
注：ExceptionType 表示可能拋出的異常類或其父類
13.3 throw 關鍵字
在程序的代碼塊中使用，用於拋出一個異常實例對象
· 格式
throw ExceptionType(Exception 類或其子類) e;
13.4 異常的分類
· checked 異常（編譯時異常）
Exception 類中除了 RuntimeException 類及其子類外都是編譯時異常
· 使用 try{}catch{} 捕獲並處理
· 在調用該方法的方法聲明處使用 throws 關鍵字聲明拋出異常
· unchecked 異常（運行時異常）
java 編譯器不會對其進行檢查，一般由邏輯錯誤引起的
· 自定義異常
用戶自定義的異常，繼承自 Exception 類或其子類
在定義時可使用 Exception 的無參構造函數或有參構造函數
*Code : test_exception : DivideByMinusException.java & Test.java
13.5 包
常用於對 .java 文件進行集中管理，沒有顯式地聲明 package 語句，則處於默認包下
· package 關鍵字
用於聲明某個類屬於哪個包
package 包名;
· import 關鍵字
使用該關鍵字可在程序中一次導入某個指定包下的類，這樣就不必在每次使用該類時都要輸入完整的類名了
import 包名.類名; //導入某個包下的某個類
import 包名.*; //導入某個包下的所有類
13.6 其他
13.6.1 編譯 .java 文件
javac -d . Example.java
-d 指定生成的 .class 文件存放位置
13.6.2 給 java 程序打包
jar -cvf helloworld.jar cn
-c 代表創建歸檔文件
-v 在標準輸出中生成詳細輸出
-f 指定歸檔文件名
jar -xvf helloworld.jar
將 jar 包裏的文件和文件夾解壓到當前文件夾下
java -jar helloworld.jar
執行 jar 文件
· 生成的 .jar 包裏的 MANIFEST.MF 文件就是用來指定 jar 包主類的文件
在該文件裏添加 "Main-Class:[完整的類名]"
13.6.3 訪問控制權限
從小到大：private < default < protected < public
private : 被修飾的類成員只能被該類的其他成員訪問
default : 當一個類或類的成員不使用任何修飾符修飾時，則默認爲 default ，只能被本包的其他類訪問
protected : 被修飾的類的成員既能被同一包下的其他類訪問，也能被不同包下的子類訪問
public : 被修飾的類或類的成員能被所有其他類訪問，不論訪問類與被訪問類是否在同一包下


四、多線程
實現多段程序交替運行
1.線程的創建
1.1 繼承 java.lang.Thread 類，並重寫 run() 方法
1.1.1 Thread 類的常用方法
.run(); //使用當前進程執行 run();
.start(); //開啓一個新的線程，並使用該線程執行 run();
1.2 實現 java.lang.Runnable 接口，並實現 run() 方法
通過 Thread(Runnable target); 構造方法來創建一個線程對象
· 實現了當使用多線程去處理同一資源時，把線程同程序代碼、有效數據有效分離（即使用同一 Runnable 實例化對象去創建多個線程，可實現在多線程下使用同一對象資源）
2.Thread 類的常用方法
.setName(String name); //設置該線程的 name ；也可以使用構造方法 Thread(Runnable,String); 來設置
.currentThread(); //獲取當前線程對象
3.後臺線程
· 新創建的線程默認是前臺線程
· 對Java程序來說，只要還有一個前臺線程在運行，這個進程就不會結束；如果一個進程中只有後臺線程運行，這個進程就會結束
3.1 常用方法（Thread 對象）
.setDaemon(boolean b); //將一個線程設置成後臺線程，該方法只能在 .start(); 方法調用前調用，否則會引發 IllegalThreadStateException 異常
.isDaemon();  //判斷該線程是否爲後臺線程
4.線程的生命週期及狀態轉換
4.1 線程的週期
新建狀態（new）：僅爲線程對象分配了內存資源
就緒狀態（Runnable）：線程對象調用了 .start(); 方法
運行狀態（Running）：獲得 CPU 的使用權
阻塞狀態（Blocked）：
· 當線程獲取某個對象的同步鎖時，該鎖被其他線程所持有
· 當線程調用了一個阻塞式的 IO 同步方法
· 當線程調用了某個對象的 .wait(); 方法時
· 當線程調用了 Thread.sleep(); 方法時時
· 當線程調用了另一個線程的 .join(); 方法時
死亡狀態（Terminated）：
· 當線程中的 run(); 方法執行完畢時
· 當線程執行過程中出現一個未捕獲的異常（Exception）或錯誤（Error）
· 注：線程進入死亡狀態，但是該線程對象仍是一個Thread對象，在沒有被垃圾回收器回收之前仍可以和引用其他對象一樣引用它。
4.2 線程的調度
4.2.1 調度模型
· 分時調度模型
爲所有線程輪流分配一個 CPU 使用權的時間片
· 搶佔式調度模型（默認）
優先級高的線程優先佔用 CPU；對於相同優先級的線程，則隨機選擇一個線程使其佔用 CPU 
4.2.2 線程的優先級
· 可使用 1~10 來表示，數字越大優先級越高，超出範圍會報錯
static int MAX_PRIORITY； //表示線程的最高優先級，相當於 10
static int MIN_PRIORITY;  //表示線程的最低優先級，相當於 1
static int NORM_PRIORITY;  //表示線程的普通優先級，相當於 5
· 常用方法（Thread 類實例化對象）
void setPriority(int newPriority);  //設置該線程的優先級
int getPriority();  //獲得該線程的優先級
· 注：不同操作系統對優先級的支持是不一樣的，不能很好地和 java 中線程優先級一一對應，因此，在設計多線程應用程序時，其功能的實現一定不能依賴於線程的優先級，而只能把線程優先級作爲一種提高程序效率的手段
4.2.3 線程休眠（繼續佔有同步鎖）
“運行狀態” --> “阻塞狀態” -（休眠時間結束）-> “就緒狀態”
使‘運行狀態’的線程進入‘阻塞狀態’一段時間（線程暫停執行一段時間），休眠時間結束後，回到‘就緒狀態’
public static native void sleep(long millis) throws InterruptedException;  //休眠方法，默認單位爲  ms
· 使用方法
Thread.currentThread().sleep(); 與 Thread.sleep(); 相同，該方法爲靜態方法，作用於執行該代碼的‘當前進程’
4.2.4 線程讓步（放棄同步鎖）
“運行狀態” --> “就緒狀態”-（CPU第二次調度...第三次...）-> “運行狀態”或“就緒狀態”
使當前線程讓出 CPU 使用權，並進入‘就緒狀態’，讓系統的調度器在具有與當前線程相同優先級或更高優先級且處於‘就緒狀態’的線程之間重新調度一次
public static native void yield(); //線程讓步方法，靜態方法，執行該代碼的當前進程
· 使用方法
Thead.yield(); 
*Code : test_thread : MyThread.java & Test_Yield.java
4.2.5 線程插隊（搶佔同步鎖）
“運行狀態” --> “阻塞狀態” -（插隊的線程執行結束）->“就緒狀態”
當在某個線程中調用‘某一線程’的 .join(); 方法時，調用的線程將被阻塞，直到插隊線程（‘某一線程’）執行結束
public final void join() throws InterruptedException;
· 使用方法（Thread 類或其子類的實例化對象）
.join();
*Code : test_thread : MyThread.java & Test_Join.java
4.3 多線程同步
· 利用鎖對象的唯一性來確保代碼訪問共享資源時不出現‘意外’，鎖對象的標誌位默認爲 1，被佔用後置爲 0
· 鎖對象不能在 run(); 方法中創建
· 被 synchronized 修飾的代碼塊或方法在某一時刻只允許一個線程訪問
4.3.1 同步代碼塊
synchronized(lock){  //lock 是一個鎖對象，可以是任意類型
//操作共享資源代碼塊
}
*Code : test_thread : Test_Synchronized_1.java
4.3.2 同步方法
synchronized 返回值類型 方法名([參數列表]){
//共享資源代碼塊
}
· 注：
非靜態同步方法的鎖對象是調用該方法的對象，即 this 指向的對象，實現 run(); 方法的類的實例化對象。
靜態同步方法的鎖對象是該類方法所在的 java.lang.Class 對象 “類名.class"
*Code : test_thread : Test_Synchronized.java
4.3.3 死鎖
JVM沒有檢測死鎖和處理死鎖的措施。
4.4 多線程通信
· 用於解決當多個線程同時操作同一存儲空間而引發的‘意外’問題（數據的存儲結果超乎意料）
4.4.1 常用的同步鎖對象（任意類型）的方法，該方法定義在 Object 類中（存在一個‘同步鎖等待隊列’，該隊列存放線程對象）
.wati();  //使調用該方法的當前線程‘放棄同步鎖’進入等待，直到其他線程‘獲得該同步鎖’並調用同步鎖的 notify(); 方法或 notifyAll(); 方法喚醒該線程
.notify();  //喚醒此同步鎖上等待的第一個調用 wait(); 方法的線程
.notifyAll();  //喚醒此同步鎖上等待的所有調用 wait(); 方法的線程
*注： public final void wait() throws InterruptedException;
         public final native void notify();
         public final native void notifyAll();
*Code : test_thread : Test_Wait_Notify.java


五、Java API
1. String 類和 StringBuffer 類（java.lang）
1.1 String 類（常量，一旦創建，其內容和長度都是不可改變的，只能創建（生成）新的字符串）
1.1.1 初始化
String str = "[字符串]";
String str = new String();
String str = new String(char[] value);
String str = new String(String value);
String str = new String(char[] value,int beg,int end);
1.1.2 常用操作
boolean equalsIgnoreCase(String another);  //比較兩個字符串（忽略大小寫）
int indexOf(int ch); //返回該字符第一次出現的位置
boolean isEmpty();  //當且僅當字符串長度爲 0 時返回 true
boolean contains(CharSequance cs);  //判斷此字符串中時候包含指定的字符串序列
String replace(CharSequence oldstr,CharSequence newstr);  //返回一個新的字符串，它是通過用 newstr 替換此字符串中出現的所有的 oldstr 得到的
String[] split(String regex); //根據參數 regex 將原來的字符串分割成若干個子字符串
String trim();  //返回一個新字符串，它除去了原字符串首尾的空格
String substring(int beginIndex);  //返回一個新的字符串，同包含字符串中索引 beginIndex 後的所有字符串（包含開始索引的字符）
String substring(int beginIndx,int endIndex);  //返回一個新的字符串，它包含此字符串中從索引 beginIndex 到索引 endIndex 之間的所有字符（包含開始索引的字符，不包括結束索引的字符）
· 其他：
int lastIndexOf(int ch);
char charAt(int index);
boolean startsWith(String prefix);  //判斷此字符串是否以指定的字符串開始
boolean endsWith(String suffix);
int length();  //返回此字符串的長度
boolean equals(Object anObject); //將此字符串與指定的字符串比較
String toUpperCase(); //使用默認語言環境的規則將 String 中的所有字符串都轉換爲大寫
String toLowerCase();
String valueOf(int i);  //返回 int 參數的字符串表示形式，靜態方法
char[] toCharArray();  //將此字符串轉換爲一個字符數組
* Code : test_javaapi : Test_String.java
1.1.3 注意
在 JVM 中，相同內容的字符串常量在內存中只存在一份（引用地址相同），而在運行時產生的相同內容的字符串在內存中的引用地址不同
1.2 StringBuffer 類（也稱字符串緩衝區，其內容和長度都是可以改變的）
1.2.1 初始化
StringBuffer sb = new StringBuffer();
StringBuffer sb = new StringBuffer(String str);
StringBuffer sb = new StringBuffer(CharSequence cs);
StringBuffer sb = new StringBuffer(int capacity);  //設定容量，容量不足時會自動改變
1.2.2 常用方法（StringBuffer 對象）
StringBuffer append(String str);  //添加字符串到 StringBuffer 對象中
StringBuffer insert(int offset,String str);  //在指定（從頭開始）偏移量 offset 位置插入字符串 str
StringBuffer deleteCharAt(int index);  //刪除字符串中指定索引位置的字符
StringBuffer delete(int start,int end);  //刪除 StringBuffer 對象中指定範圍的字符或字符串序列（包含開始索引字符，不包含結束做引字符）
StringBuffer replace(int start,int end,String s);  //替換指定範圍內的字符串爲另一字符串（包含開始索引字符，不包含結束索引字符）
void setCharAt(int index,char ch);  //替換指定索引位置的字符
String toString();  //返回 StringBuffer 緩衝區中的字符串
StringBuffer reverse();  //將緩衝區中的字符串反轉
*Code : test_javaapi : Test_StringBuffer.java
1.3 兩者的比較
· String 類表示的字符串是常量
· String 類覆蓋了 Object 類的 equals(); 方法，而 StringBuffer 類沒有覆蓋該方法
· String 類對象之間可以用操作符 '+' 進行連接，而 StringBuffer 類對象之間不能，會編譯錯誤
2. System 類和 Runtime 類
2.1 System 類
· static void exit(int status);
該方法用於終止當前正在運行的 java 虛擬機，其中參數 status 表示狀態碼，若狀態非 0，則表示異常終止
· static long gc();
運行垃圾回收器，並對垃圾進行回收
· static long currentTimeMillis();
返回以毫秒爲單位的當前時間，該值表示當前時間與1970年1月1日0點0分0秒之間的時間差，一般成爲時間戳
· staitc void arraycopy(Object src,int srcPos,Object dest,int destPos,int length);
從 src 引用的指定源數組複製到 dest 引用的數組，複製從指定的位置（srcPos 與 destPos 表示起始位置）開始的一定長度的數據
· static Properties getProperties();
取得當前系統的全部屬性，該方法會返回一個 Properties 類對象，屬性以鍵值對的形式存在
*Code : test_javaapi : Test_System.java
2.2 Runtime 類
該類用於表示虛擬機運行時的狀態，它用於封裝 JVM 虛擬機進程，採用單例模式進行設計，故不可以直接實例化
· 獲得 Runtime 類實例對象
Runtime runtime = Runtime.getRuntime();
· 常用方法（Runtime 類對象）
.availableProcessors(); //獲得當前虛擬機可使用的處理器個數
.freeMemory();  //獲得當前虛擬機的空閒內存大小（字節）
.maxMemory();  //獲得當前虛擬機最大可用內存空間大小（字節）
public Process exec(String command) throws IOException;  //執行一個 dos 命令，同“運行”
該方法返回一個 Process 類對象，調用該對象的 .destroy(); 方法可以關閉該進程
*Code : test_javaapi : Test_Random.java
3. Math 類和 Random 類
3.1 java.util.Math 類
· 常用方法
Math.abs(int num);  //求一個數的絕對值
Math.ceils(double num);  //求大於某個數的最小整數（double）
Math.floor(double num);  //求小於某個數的最大整數（double）
Math.round(double num);  //求一個數四捨五入的結果（long）
Math.max(num_1,num_2);  //求兩個數中的最大值
Math.min(num_1,num_2);  //求兩個數中的最小值
Math.random();  //返回一個值（0.0 <= x <1.0）
*Code : test_javaapi : Test_Math.java
3.2 java.util.Random 類（僞隨機數生成器）
· 創建僞隨機數生成器
Random random = new Random();  //隨機使用一個種子（當前時間戳）創建僞隨機數生成器
Random random = new Random(long seed);  //使用給定的種子來創建僞隨機數生成器
· 注：種子相同產生的隨機序列相同
· 常用方法
boolean nextBoolean();  //產生一個隨機的 boolean 值
double nextDouble();  //產生一個 [0,1) 之間的 double 值
float nextFloat();  //產生一個 [0,1) 之間的 float 值
int nextInt();  //產生一個隨機的有符號的 int 值
int nextLong();  //產生一個隨機的有符號的 long 值
*Code : test_javaapi : Test_Random.java
4.包裝類
4.1 基本數據類型對應的包裝類
· byte --> Byte 
· char -->Character
· int --> Integer
· Integer 類的常用靜態方法
public static String toBinaryString(int i);  //將一個整型數值轉換爲二進制值字符串
public static String toHexString(int i);  //將一個整型數值轉換爲十六進制值字符串
public static String toOctalString(int i); //將一個整型數值轉換爲八進制值字符串
public static int parseInt(String s);  //將一個整型數據字符串識別爲整型數值
· Integer 類對象的常用方法
.intValue();  //將 Integer 類型的值以 int 類型值返回
· short --> Short
· long --> Long
· float --> FLoat
· double --> Double
· boolean --> Boolean
4.2 注意
· 所有的包裝類都重寫了 Object 類中的 .toString(); 方法，該方法以字符串的形式返回被包裝的基本數據類型的值
· 除了 Character 類外，其他包裝類都有 valueOf(String s); 方法（靜態方法），該方法會根據傳入的 String 類型參數返回一個適合的包裝類對象，該字符串不能爲 null 且是可以被解析的，否則即使通過編譯也會發生運行時錯誤
· 除了 Character 類外，其他包裝類都有 parseXXX(String s); 方法（靜態方法），用法及規則同上
· ‘裝箱’與‘拆箱’
裝箱：指的是把 基本數據類型值 --> 包裝類對象
拆箱：指的是把 包裝類對象 --> 基本數據類型值
注：JDK 5.0 之後支持自動裝箱與自動拆箱技術，基本數據類型值也可以和包裝類對象直接使用操作符進行運算
*Code : test_javaapi : Test_PackingClass.java
5. Date 類、Calendar 類與 DateFormat 類
5.1 java.util.Date 類
· 初始化
Date date = new Date();  //創建一個當前時間的 Date 對象
Date date = new Date(long millisecond);  //根據一個時間戳創建 Date 對象
· 該類對象以默認格式輸出日期和時間
5.2 java.util.Calendar 類（抽象類）
· 用於完成時間和日期字段的操作，可以通過特定的方法設置和讀取日期的特定部分，該類是一個抽象類，不可以直接實例化
· 獲得一個 Calendar 類實例化對象
Calendar calendar = Calendar.getInstance();  //創建一個代表默認時區內當前時間的 Calendar 對象
· Calendar 類對象的常用方法
public final void setTime(Date date);  //傳入一個 Date 類對象來設置 Calendar 類對象的值
public final Date getTime();  //獲得 Calendar 類對象對應的 Date 類對象
public int get(int field);  //返回指定日曆字段的值
如： Calendar.YEAR、Calendar.MONTH、Calendar.DATE、Calendar.HOUR、Calendar.MINUTE、Calendar.SECOND
注：Calendar.MONTH 代表的月字段的值範圍爲 [0,11]
      Calendar 類對象中字段的修改會發生進位
· Calendar 類的兩種模式
- lenient 模式（日曆字段模式）（默認模式）
該模式下允許字段超出其取值範圍，當輸出時間時會自動標準化時間
- non-lenient 模式
該模式下的日期和時間只接受規定範圍內的數值
*Code : test_javaapi : Test_Calendar.java
5.3 java.text.DateFormat 類（抽象類）
該類用於將一個日期格式化爲字符串或將一個特定格式顯示的日期字符串轉換成一個 Date 對象
· 獲得 DateFormat 類對象
public final static getDateFormat();  //用於創建默認語言環境和格式化風格的日期格式化器
public final static getDateFormat(int style);  //用於創建默認語言環境和指定格式化的日期格式器
public final static getDateTimeFormat();  //用於創建默認語言環境和格式化風格的日期/時間格式器
public final static getDateTimeFormat(int dateStyle,int timeStyle);  //用於創建默認語言環境和指定格式化風格的日期/時間格式器
· 常用方法（DateFormat 類對象）
public final String format(Date date);  //將一個 Date 類對象格式化爲日期/時間字符串
public Date parse(String source) throws ParseException;  //將給定字符串解析成一個 Date 類對象，字符串必須符合格式要求，否則會拋出異常
· 給定的四種格式化風格
DateFormat.FULL；  //表示完整格式，如 2017年1月6日 星期五 下午07時38分27秒 CST
DateFormat.LONG;  //表示長格式，如 2017年1月6日 下午07時38分27秒
（默認）DateFormat.MEDIUM;  //表示普通格式，如 2017-1-6 19:38:27
DateFormat.SHORT;  //表示短格式，如 17-1-6 下午7:38
*Code : test_javaapi : Test_DateFormat.java
5.4 java.text.SimpleDateFormat 類（DateFormat 類的子類）（自定義日期/時間格式化器）
可以使用 new 來實例化對象，它的構造方法介紹一個格式字符串參數，表示日期格式模板
· 實例化 SimpleDateFormat 類
SimpleDateFormat simpleDateFormat = new SimpleDateFormat();  //默認以短格式爲模板
SimoleDateFormat simpleDateFormat = new SimpleDateFormat(String pattern);
· 佔位符
yyyy - 年
MM - 月（數字）
dd - 日
HH - 時
mm - 分
ss - 秒
*Code : test_javaapi : Test_SimpleDateFormat.java


六、集合類
1.集合的分類
Collection : List : 元素有序，可重複（ArrayList , LinkedList , Vector）
     Set : 元素無序，不可重複（HashSet , TreeSet）
Map : 用於存儲包含鍵（key）、值（value）映射關係的值
包含一個存放 key 的 Set 視圖（key 具有唯一性）和一個存放 value 的 Collection 視圖
2. Collection 接口
2.1 該接口的方法
boolean add(Object o);  //添加一個元素
boolean addAll(Collection c);  //把另一個集合中的元素添加到該集合中
void clear(); //清空該集合中的所有元素
boolean remove(Object o);  //刪除該集合中指定的元素
boolean removeAll(Collection c);  //刪除該集合中存在的另一集合中的元素
boolean isEmpty();  //判斷該集合是否爲空
boolean contains(Object o);  //判斷該集合是否包含某個元素
boolean containsAll(Collection c);  //判斷該集合中是否包含另一集合中的所有元素
Iterator iterator();  //獲得該集合的迭代器
int size();  //獲得該集合的中元素的個數
2.2 List 接口
2.2.1 接口常用方法
void add(int index,Object element);  //將 element 插入到 List 集合的 index 處
boolean addAll(int index,Collection c);  //將另一個集合中的所有元素插入到 List 集合的 index 處
Object get(int index);  //獲得 List 集合中 Index 處的元素
Object remove(int index);  //刪除 List 集合中 index 處的元素
Object set(int index,Object element);  //將 List 集合中 index 處元素替換爲 element 元素，並將替換後的元素返回
int indexOf(Object o);  //返回 o 元素在 List 集合中第一次出現的位置
int lastIndexOf(Object o);  //返回 o 元素在 List 集合中最後一次出現的位置
List subList(int fromIndex,int toIndex);  //返回一個子集合，該子集合包含源集合中從 fromIndex （包含）到 toIndex （不包含）之間的所有元素
2.2.2 java.util.ArrayList 類（該集合是線程不安全的，即其方法不具有同步鎖特徵）
該類內部封裝了一個長度可變的數組對象。
· 特點：查找訪問元素方便快捷，但不適合做大量的增刪操作
2.2.3 java.util.LinkedList 類
該類內部維護了一個雙向循環鏈表，使用引用的方式來記住前一個元素和後一個元素。
· 特點：對元素的增刪操作有很高的效率
· 常用方法（LinkedList 類對象）
void add(int index,E element);  //在此集合中指定的位置插入 element 
void addFirst(Object o);  //在集合的開頭位置插入 o
void addLast(Object o);  //在集合的結尾位置插入 o
Object getFirst();  //返回該集合的第一個元素
Object getLast();  //返回該集合的最後一個元素
Object removeFirst();  //移除並返回該集合的第一個元素
Object removeLast();  //移除並返回該集合的最後一個元素
2.2.4 java.util.Iterator 接口（只能從第一個元素遍歷到最後一個元素）（僅可正向迭代）
該接口主要用於遍歷 Collection 中的元素，故也稱爲 迭代器
· 常用方法（實現 Iterator 接口的類實例化對象）
boolean hasNext();  //判斷集合中是否存在下一個元素
Object next();  //獲得下一個元素
· 如果想要通過 .next(); 方法得到特定的元素類型，需進行強制類型轉換
· 若在迭代過程中，使用集合的 .remove(); 操作，則可能引發 ConcurrentModificationException 異常，原因是集合刪除元素可能導致迭代器預期的迭代次數發生改變，導致迭代器的結果不準確。解決辦法是在執行 .remove(); 操作後不再使用該迭代器，或使用迭代器本身的 .remove(); 方法來移除元素（該方法導致的迭代次數變化對 Iterator 來說是可預知的）。
· 
2.2.5 foreach 循環（增強的 for 循環）
只能對元素進行訪問，不能修改（僅是對臨時變量引用的修改）
· 格式
for(容器中元素類型 臨時變量 : 容器變量){
//執行語句
}
2.2.6 ListIterator 接口（Iterator 接口的子類）（可正向迭代，可反向迭代）
· 只能用於遍歷 List 集合
· 特有方法
void add(Object o);  //將指定的元素插入列表
boolean hasPrevious();  //判斷當前指針元素所指向的元素是否存在前一個元素
Object previous();  //返回前一個元素
void remove();  //從列表中移除當前迭代器指針所指向的元素
· 獲得 ListIterator 對象
ListIterator listIterator = list.listIterator();  //默認指針指向第一個元素
ListIterator listIterator = list.listIterator(int index);  //指針指向 index 位置的元素
2.2.7 Enumeration 接口（只可正向遍歷）
· 該接口用於遍歷 Vector 集合（該集合是線程安全的，即其方法具有同步鎖特徵）
· Vector 類的用法與 ArrayList 相同
· 獲得 Enumeration 對象
Enumeration en = ( Vector 集合的實例化對象).elements();
· 該接口的常用方法
boolean hasMoreElements();  //判斷是否存在下一個元素
Object nextElement();  //獲得下一個元素
*Code : test_collection_map : Test_List.java
2.3 Set 接口
2.3.1 java.util.HashSet 類（無序）
· 特點：具有良好的存取和查找性能
· 該集合添加元素的流程
先調用元素的 .hashCode(); 方法來確定元素的存儲位置；若該位置上已存在元素，則調用元素的 .equals(); 方法來判斷是否爲同一元素，若結果爲 true ，則表示元素重複，丟棄該元素，若結果爲 false，則替換原位置上的元素。
· 一般要求對存入元素的類的下列方法進行重寫
public int hashCode();
public boolean equals(Object obj);
2.3.2 java.util.TreeSet 類（有序）（採用平衡的二叉樹原理）
· 存入該集合的類必須實現 java.lang.Comparable 接口，實現 public int compareTo(Object obj); 方法；或在定義該集合時傳入一個適合的比較器（即該類實現了 Comparator 接口，實現該接口中的 public int compare(Object obj1,Object obj2); 方法）。
*Code : test_collection_map : Test_Set.java
3. Map 接口
3.1 該接口的常用方法
void put(Object key,Object value);  //將指定的 value 與此映射的指定的 key 關聯
Object get(Object key);  //返回指定 key 所映射的 value ，若不存在則返回 null
boolean containsKey(Object key);  //若存在該 key ，則返回 true
boolean containsValue(Object value);  //若存在該 value，則返回 true
Set keySet();  //返回一個包含左右 key 的 Set 視圖
Conllection<V> values();  //返回此映射中包含的所有的 value 的 Collection 視圖
Set<Map.Entry<K,V>> entrySet();  //返回一個包含所有 key 和 value 的 Set 視圖
3.2 java.util.HashMap 類（默認對 key 進行排序）
· key 相同則 value 會發生覆蓋
· Map.Entry 類是 Map 接口內部類
· 元素取出順序與存入順序不同
· 該集合中允許出現一對 null 鍵 null 值
3.3 java.util.LinkedHashMap 類（是 HashMap 類的子類）
· 該類內部維護一個雙向鏈表，使元素的迭代順序與存入的順序相同
3.4 java.util.TreeMap 類（對 key 排序，採用平衡的二叉樹原理）
· 要求 key 元素類實現 Comparable 接口或傳入一個實現 Comparator 接口的比較器
· 遍歷方法同 HashMap 類
3.5 java.util.Properties 類（Hashtable 類的子類）（用於存儲配置項）
· HashMap 與 Hashtable 的區別在於後者是線程安全的且讀取較慢
· Properties 類主要用於存儲字符串類型的 key 和 value
· 常用方法（Properties 類對象）
public synchronized Object setProperty(String key,String value);  //用於添加或修改鍵值
public String getProperty(String key);  //獲得 key 所對應的 value，找不到 key 則返回 null 
public String getProperty(String key,String defaultValue);  //獲得 key 所對應的 value，若找不到 key 則返回 defaultValue 
*Code : test_collection_map : Test_Map.java
4.泛型（JDK 5.0 新特性）
· parameterized type 即參數化類型（泛型），限定方法操作的數據類型，避免了在程序中進行強制類型轉換
· 使用方法
在定義集合類時，使用 "<參數化類型>" 的方式指定該類中方法操作的數據類型
如： ArrayList<String> list = new ArrayList<String>();
· 自定義泛型
在類定義時，類名後添加 "<Type_1 [ , Type_2[ , ...]]>" 以聲明參數類型
*Code ： test_collection_map : Test_ParameterizedType.java
5. java.util.Collections 集合操作工具類
5.1 排序操作
public static <T> boolean addAll(Collection<? super T> c,T... elements);  //將所有指定元素添加到指定的 Collection 集合中
public static void reverse(List<?> list);  //反轉 List 類對象中的元素順序
public static void shuffle(List<?> list);  //隨機排序 List 類對象中的元素（洗牌）
public static void sort(List list);  //對 List 類對象中的所有元素按自然順序排序
public static void sort(List list,Comparator c);  //使用給定的比較器對 List 類對象中的所有元素進行排序
public static void swap(List list,int i,int j);  //將指定 List 類對象中的 i 索引元素和 j 索引元素進行交換
5.2 查找、替換操作
public static int binarySearch(List list,Object key);  //使用二分法搜索指定的 key 對象在 List 類對象中的索引，該 List 類對象必須是有序的
public static Object max(Collection c);  //根據元素的自然順序返回 List 類對象中最大的元素
public static Object min(Collection c);  //根據元素的自然順序返回 List 類對象中最小的元素
public static boolean replaceAll(List list,Object oldVal,Object newVal);  //把 List 類對象中所有的 oldVal 替換成 newVal 
6. java.util.Arrays 數組操作工具類
· 常用方法
public static void sort(int[] arr);  //該方法有多個重載，對數組進行排序
public static int binarySearch(Object[] arr,Object key);  //該方法有多個重載，使用二分法在排序過的數組中進行查找並返回索引
public static int[] copyOfRange(int[] original,int from,int to);  //拷貝源數組中指定範圍內的元素，超出範圍內的以‘默認值’填充，包括 from 索引元素，不包括 to 索引元素
public static void fill(Object[] arr,Object value);  //以 value 來填充該數組
public static String toString(Object[] arr);  //返回此數組的字符串表現形式，該方法不是對 Object 類中 .toString(); 方法的重寫


七、IO
1. IO流 ： 字節流 ： 字節輸入流、字節輸出流
   字符流 ： 字符輸入流、字符輸出流
2.字節流
2.1 java.io.InputStream 抽象類
· 子類
FileInputStream 
BufferedInputStream ： 裝飾類，內部定義了一個大小爲 8192 的字節數組
· 常用方法
public int read() throws IOException;  //從輸入流讀取一個字節（8位），轉換爲0~255的整數，並返回該證整數（EOF 值爲 -1）
public int read(byte[] b) throws IOException;  //從輸入流讀取若干字節，保存到 b 數組中，並返回成功讀取的字節數
public int read(byte[] b,int off,int len) throws IOException;  //從輸入流的起始位置 off 開始讀取 len 個字節數保存到 b 數組中，並返回成功讀取的字節數
public void close() throws IOException;  //關閉此輸入流並釋放與該流關聯的所有系統資源
· 初始化
FileInputStream fileInputStream = new FileInputStream(String filename) throws FileNotFoundException;
BufferedInputstream bis = new BufferedInputStream(InputStream in);  //裝飾類
2.2 java.io.OutputStream 抽象類
· 子類
FileOutputStream
BufferedOutputStream ： 裝飾類，內部定義了一個大小爲 8192 的字節數組
· 常用方法
public void write(int b) throws IOException;  //向輸出流寫入一個字節
public void write(byte[] b) throws IOException;  //把 b 數組中的所有字節寫入輸出流
public void write(byte[] b,int off,int len) throws IOException;  //把 b 數組中從偏移量 off 的位置開始的 len 個字節寫入輸出流
public void flush() throws IOException;  //刷新此輸出流並強制把緩衝區中的數據寫入到目標設備
public void close() throws IOException;  //關閉此輸出流並釋放與此流相關的所有系統資源
· 初始化
FileOutputStream fileOutputStream = new FileOutputStream(String name) throws FileNotFoundException;
FileOutputStream fileOutputStrema = new FileOutputStream(String name,boolean append) throws FileNotFountException;  // append 參數表示是否以‘追加’方式寫入數據
BufferedOutputStream bos = new BufferedOutputStream(OutputStream out);  //裝飾類
*Code : test_io : Test_Input_Output_Stream.java & Test_Byte_FileCopy.java & Test_Byte_Buffered.java
3.字符流
3.1 java.io.Reader 抽象類
· 子類
FileReader
BufferedReader ：裝飾類，內部定義了一個大小爲 8192 的字節數組
LineNumberReader ：BufferedReader 的直接子類
· 常用方法
public int read() throws IOException;  //讀取一個字符，返回該字符的整型值（該方法有多個重載）
· BufferedReader 的特有方法
public String readLine() throws IOException;  //讀取一行（返回的結果中不包括 換行符）
· LineNumberReader 的特有方法
public void setLineNumber(int lineNumer);  //設置起始行號（並非從該行開始讀）
· 初始化
FileReader fileReader = new FileReader(String fileName) throws FileNotFoundException;
BufferedReader br = new BufferedReader(Reader r);
LineNumberReader lr = new LineNumberReader(Reader r);
3.2 java.io.Writer 抽象類
· 子類
FileWriter
BufferedWriter ：裝飾類，內部定義了一個大小爲 8192 的字節數組
· 常用方法
public void write(int ch) throws IOException;  //寫入一個字符（該方法有多個重載）
public void writer(String str) throws IOException;  //寫入一個字符串
public Writer append(CharSequence csq) throws IOException;  //以附加方式寫入字符串
· BufferedWriter 的特有方法
public void newLine() throws IOException;  //寫入一個換行符
· 初始化
FileWriter fileWriter = new FileWriter(String fileName) throws IOException;
FileWriter fileWriter = new FileWriter(String fileName,boolean append) throws IOException;
BufferedWriter bw = new BufferedWriter(Writer w);
*Code : test_io : Test_Reader_Writer.java & Test_Buffered_Reader_Writer.java & Test_LineNumberReader.java
4.轉換流
· 只能針對操作文本文件的字節流進行轉換，若操作的是圖片文件，則可能會因爲轉換爲字符流而造成數據丟失
4.1 java.io.InputStreamReader 類（Reader 類的子類）
· 將字節輸入流轉換爲字符輸入流
4.2 java.io.OutputStreamWriter 類（Writer 類的子類）
· 將字節輸出流轉換爲字符輸出流
*Code : test_io : Test_ConvertClass.java
5.其他 IO 流
5.1 java.io.ObjectInputStream 類 & java.io.ObjectOutputStream 類
· 該類只能一次讀寫（尚且不知道原因），若想一次性寫入多個對象可將所有對象存放在一個 List 中，一次寫入
· 要寫入流的對象必須實現 java.io.Serializable 接口
· 初始化
ObjectInputStream ois = new ObjectInputStream(InputStream in) throws IOException;
ObjectOutputStream oos = new ObjectOutputStream(OutputStream out) throws IOException;
· ObjectInputStream 類 常用方法
public final Object readObject() throws IOException,ClassNotFountException; //從流中讀取一個對象
· ObjectOutputStream 類 常用方法
public final void writeObject(Object obj) throws IOException;  //往流中寫入一個對象
*Code : test_io : Test_Object_Input_Output_Stream.java
5.2 java.io.DataInputStream 類 & java.io.DataOutputStream 類
· 該類主要用於存儲基本數據類型
· 使用時數據的類型讀取順序要與寫入順序相同，才能保證最終數據的正確性
· 初始化
DataInputStream dis = new DataInputStream(InputStream in);
DataOutputStream dos = new DataOutputStream(OutputStream out);
· DataInputStream 類 常用方法
public final int readInt() throws IOException;
public final String readUTF() throws IOException;
public final boolean readBoolean() throws IOException;
public final char readChar() throws IOException;
· DataOutputStream 類 常用方法
public final void writeInt(int i) throws IOException;
public final void writeUTF(String str) throws IOException;
public final void writeBoolean(boolean v) throws IOException;
public final void writeChar(char c) throws IOException;
*Code : test_io : Test_Data_Stream.java
5.3 java.io.PrintStream 類（打印流）（與 DataOutputStream 類相似）
· 該類主要用於該基本數據類型或引用數據類型的對象格式化成字符串後再輸出（調用對象的 .toString(); 方法）
· 初始化
PrintStream ps = new PrintStream(OutputStream out);
· 常用方法
public void print(String str);  //打印一個字符串（該方法有多個重載）
public void println(Object obj);  //調用該對象的 .toString(); 方法，並將結果寫入流（該方法有多個重載）
*Code : test_io : Test_PrintStream.java
5.4 標準輸入輸出流
· 標準流
輸入流 System.in : InputStream
輸出流 System.out : PrintStream
錯誤流 System.err : PrintStream
· 重定向標準流（System 類的靜態方法）
輸入流 public static void setIn(InputStream in); 
輸出流 public static void setOut(PrintStream out); 
錯誤流 public static void setErr(PrintStream err);
*Code : test_io : Test_System_In_Out_Err.java
5.5 java.io.PipedInputStream 類 & java.io.PipedOutputStream 類（管道流，一般用於線程間通信）
· PipedInputStream 類 用於從管道讀取數據到程序中
 PipedOutputStream 類 用於從程序寫數據到管道中
· 初始化
PipedInputStream pis = new PipedInputStream();
PipedOutputStream pos = new PipedOutputStream();
· 常用方法（PipedInputStream 類對象或 PipedOutputStream 類對象）
public void connect(PipedOutputStream src) throws IOException;  // PipedInputStream 類對象的方法和，連接輸出管道
public synchronized void connect(PipedInputStream snk) throws IOException;  // PipedOutputStream 類對象的方法，用於連接輸入管道
*Code : test_io : Test_PipedStream.java
5.6 java.io.ByteArrayInputStream 類 & java.io.ByteArrayOutputStream 類（字節數組緩衝區）
· ByteArrayInputStream 類只能從一個 Byte[] 數組中讀取數據
· ByteArrayOutputStream 類會在創建實例化時創建一個 Byte[] 數組的緩衝區，該緩衝區會根據存入數據的多少而自動變化，因此可以減少寫數據的次數。（如果讀取的文件非常大，就不能使用這個類，否則會造成 內存溢出 ）
· 初始化
ByteArrayInputStream bis = new ByteArrayInputStream(Byte[] arr);
ByteArrayOutputStream bos = new ByteArrayOutputStream();
· ByteArrayInputStream 類對象的常用方法
public synchronized int read();  //讀取一個字節，返回整型形式數據
· ByteArrayOutputStream 類對象的常用方法
public synchronized void write(int b);  //寫入一個字節
public synchronized byte[] toByteArray();  //將緩衝區中的所有數據轉換爲一個 byte[] 數組
*Code : test_io : Test_ByteArrayStream.java
5.7 java.io.CharArrayReader 類 & java.io.CharArrayWriter 類（字符數組緩衝區）
· 用法與 字節數組緩衝區 大致相同
· CharArrayReader 類只能從一個 char[] 數組中讀取數據
· 初始化
CharArrayReader car = new CharArrayReader(char[] chs);
CharArrayWriter caw = new CharArrayWriter();
· CharArrayReader 類對象的常用方法
public int read() throws IOException;  //讀取一個字符，返回整型形式數據
· CharArrayWriter 類對象的常用方法
public void write(int c);  //寫入一個字符
public char[] toCharArray();  //將緩衝區中的所有數據轉換爲一個 char[] 數組
*Code : test_io : Test_CharArray_Reader_Writer.java
5.8 java.io.SequenceInputStream 類（輸入合併流）
· 該類用於將多個輸入流合併成一個輸入流，讀取數據時會依次從第一個流讀到最後一個流
· 初始化
SequenceInputStream sis = new SequenceInputStream(InputStream in1,InputStream in2);  //將兩個流合併
SequenceInputStream sis = new SequenceInputStream(Enumeration<? extends InputStream> e);  //將多個流合併
· 常用方法（SequenceInputStream 類對象）
public int read(byte[] b) throws IOException;  //讀取數據到一個 byte[] 數組中，並返回讀取的字節數，當讀到文件尾時返回 -1 
public void close() throws IOException;  //關閉所有流
· 合併多個流時可將所有流添加到一個 Vector 類對象裏，並使用 SequenceInputStream 第二個構造方法
*Code : test_io : Test_SequenceInputStream.java