java基礎知識點總結 2

基礎類庫：>使用api(幫助文檔 java基礎類庫的說明書)
>多敲例子(上課案例 做業)
Obejct:
全部類的直接或者間接父類
若是一個類沒有繼承其餘類 默認繼承Object類
構造方法：無參數的構造方法
成員變量：無
普通方法：
> int hashCode() 返回該對象的10進制內存地址
> Class getClass() 獲取當前對象的類的字節碼文件對象
Class ----描述類的字節碼文件對象
getClass()方法是全部對象的方法---對象是由類建立的
---每一個類對應一個字節碼文件----字節碼文件被封裝成對象
---對象的類型Class
Class類的方法 獲取類名

> String toString() 返回該對象的字符串表示。
day17_basicclass.Demo1_Object1@4f1d0d
類名@16進制內存地址
*** > boolean equals(Object obj)
判斷當前引用和參數引用是否是指向同一個對象

//重寫equals方法 判斷兩個引用指向的對象是否是在描述同一個實物
//(判斷兩個對象的全部數據是否是徹底相同)
//1 方法聲明必須徹底與Object類一致 參數是Object類型

初級難點：
forfor循環嵌套
數組排序
字符串練習
字符串：String
注意1：字符串對象是常量；字符串建立以後 字符序列不能更改
注意2：建立字符串對象兩個經常使用方法:String s="1233";經過雙引號建立
String s=new String("1233");經過new

構造方法：
>1 String()
無參數的構造方法 建立一個空字符序列 相似於""
>2 String(String original)
建立一個參數字符串序列的副本字符串對象
>3 參數是byte、int、char數組 由數組或者數組是一部分建立一個字符串對象
String(byte[] bytes)
String(char[] value)
String(char[] value, int offset, int count)
String(byte[] bytes, int offset, int length)
String(int[] codePoints, int offset, int count)
String(byte[] bytes, String charsetName)
普通方法：
--- >1 boolean equals(Object anObject)
Obejct類中equals方法 判斷兩個引用是否指向一個對象
重寫後 判斷兩個引用指向的字符序列是否相同
boolean equalsIgnoreCase(String anotherString)
不區分大小寫
--- >2 char charAt(int index)
經過下標獲取字符
>3 int length()
獲取字符個數
>4 int compareTo(String s)
按編碼集逐個字符作比較
當前字符串大 返回正數、當前字符串小 返回負數 、相同返回0
int compareToIgnoreCase(String str)
不區分大小寫
>5 String concat(String str) 徹底等價於+
把參數字符串鏈接到當前字符串後面 造成一個新的字符串
>6 boolean contains(String s)
判斷當前字符串是否是包含參數字符串
>7 boolean endsWith(String suffix)
boolean startsWith(String prefix)
判斷當前字符串是否是以參數字符串開始、結尾
---- >8 byte[] getBytes()
byte[] getBytes(String charsetName)
由當前字符串和指定(默認)編碼集獲取一個字節數組
>9 char[] toCharArray()
由當前字符串獲取一個字符數組
>10 經過字符獲取下標
int indexOf(int ch) 獲取參數字符第一次出現的位置
int indexOf(int ch, int fromIndex)
int indexOf(String str)
int indexOf(String str, int fromIndex)
int lastIndexOf(int ch)
int lastIndexOf(int ch, int fromIndex)
int lastIndexOf(String str)
int lastIndexOf(String str, int fromIndex)

 

面試題：== 與equals方法的區別
>(1) == 是比較運算符 能夠判斷引用數據類型和基本數據類型
操做基本數據類型 判斷值是否相同
操做引用數據類型 判斷是否是同一個對象
equals是方法 只能操做引用數據類型的數據
>(2) == 是運算符 判斷依據沒法更改
equals是Obejct類的方法 能夠被子類重寫

---->11 String replace(char oldChar, char newChar)
使用newChar替換當前字符串中全部的oldChar
String replace(String oldStr,String newStr)
使用newStr替換當前字符串中全部的oldStr
---->12 String[] split(String regex)
使用參數字符串切割當前字符串
-----13 String substring(int beginIndex)
獲取從beginIndex開始到末尾的子串
String substring(int beginIndex, int endIndex)
獲取從beginIndex開始到endIndex-1結束的子串
14 String toUpperCase()
全部字母轉換爲大寫
String toLowerCase()
全部字母轉換爲小寫
15 String trim()
去除先後的空字符 ' '

系統輸入流監控器類：Scanner
建立建立Scannar對象： Scanner sr=new Scanner(System.in);

如下方法都是阻塞方法：(等待輸入 只有輸入內容程序才繼續執行)
String next() 獲取一個字符串
String nextLine() 獲取一行
int nextInt() 獲取一個整數
float nextFloat() 獲取一個float

System:系統
靜態的成員變量：
static PrintStream err 錯誤輸出流
static InputStream in 系統輸入流
static PrintStream out 標準輸出流

err和out注意：
err打印是紅色 out是黑色
err和out執行順序不固定(多線程)
普通方法：
static void exit(0) 結束程序運行
static long currentTimeMillis()
獲取當前時間與1970 年 1 月 1 日午夜之間的時間毫秒值差

Math：與數學運算有關的全部方法
靜態成員變量:
E:天然對數
PI:圓周率
靜態普通方法:
-->static long abs(int a) 求絕對值

>static double cbrt(double a) 求立方根
-- static double sqrt(double a) 求平方根
static double pow(double a, double b) 求a的b次方

>static double ceil(double a) 大於等於參數的最小整數
static double floor(double a) 小於等於參數的最大整數
static double rint(double a) 四捨六入 五取偶
static long round(double a) 四捨五入

--- >static double random()
返回帶正號的 double 值，[0.0,1.0)
*/

StringBuffer、StringBuilder API兼容(方法屬性徹底相同)
字符串緩衝區、字符可變序列

面試題：
String與StringBuffer、StringBuilder
相同之處：都是字符串字符序列
不一樣之處
String字符串常量：字符串對象一旦建立 字符序列不能更改
StringBuffer、StringBuilder：字符串緩衝區 字符序列能夠變化
StringBuffer、StringBuilder：API兼容(方法屬性徹底相同)
>版本不一樣：
StringBuffer jdk1.0
StringBuilder jdk1.5
>是否支持多線程
StringBuilder 線程不安全 不支持多線程 線程不一樣步 效率高
StringBuffer 線程安全 支持多線程 線程同步 效率低

構造方法：
StringBuffer() //建立一個沒有字符的字符串緩衝區
StringBuffer(String str) //建立一個有初始字符序列的字符串緩衝區
普通方法：
與String相同的方法：
> char charAt(int index)
經過下標獲取字符
> int indexOf(String str)
獲取參數字符串第一次出現的位置
int indexOf(String str, int fromIndex)
從fromIndex處檢索 獲取參數字符串第一次出現的位置
int lastIndexOf(String str)
倒着查找 獲取參數字符串第一次出現的位置
int lastIndexOf(String str, int fromIndex)
倒着查找 從fromIndex處開始 獲取參數字符串第一次出現的位置
> int length()獲取字符個數
> String substring(int start, int end)
獲取從start到end-1處的子串
特有：
>添加
StringBuffer append(Object obj)
把對象的字符串表示形式加到當前字符串緩衝區後面 返回當前字符串緩衝區對象
>刪除
StringBuffer delete(int start, int end)
刪除start到end-1下標處的全部字符
StringBuffer deleteCharAt(int index)
刪除index下標處的字符
> 插入
StringBuffer insert(int offset, Object obj)
把參數對象obj的字符串表示形式 插入到 offset位置處
> 替換
StringBuffer replace(int start, int end, String str)
使用str替換start到end1-處的字符
> 翻轉
StringBuffer reverse()
> 設置字符
void setCharAt(int index, char ch)
把ch設置到index位置處

當對字符串頻繁的進行"正刪改" 從建議使用字符串緩衝區

3 寫一個方法由參數字符串獲取一個新的字符串
：要求 大寫轉換爲小寫 小寫轉換爲大寫 刪除數字
public static String getNew(String str){
//由str獲取一個字符串緩衝區
//對字符串緩衝區進行操做
//由字符串緩衝區獲取一個字符串對象
}

1 寫一個方法 有參數字符串獲取一個數字組成的字符串數組
如"123kjh123hgfr98jhfgdd876"---{"123","123","98","876"}
基本思路：使用指定字符如'-'替換全部非數字字符
而後再用'-'切割
而後把其中非""的元素挑出來便可
2 寫一個方法 由參數字符串獲取一個新的字符串
如ssssddddiiiiiuuuuuusssedf--->s4d4i5u6s3edf
3 已知一個Stu類 屬性 age name sex score
//寫一個方法 public static Stu suiJi(){}
//此方法返回一個Stu對象 對象的全部屬性隨機
//要求：age取值範圍[22,29] score取值[0.0,100.0] sex取值男或者女
// name只有4個大小寫字母組成

Date: 日期類
*注意：>大部分方法 都是已過期(不易於實現國際化) 一般有替代者Calendar(日曆類)
>包名是 java.util.Date 別導錯java.sql.Date
構造方法：
*** > Date() 獲取當前時間
> Date(int year, int month, int date, int hrs, int min, int sec)
參數是年月日時分秒
year-1900
month-1 [0,11]
> Date(long date)
參數爲距離曆元(1970-1-1 00:00:00)之間的毫秒值
普通方法：
>時間前後比較
boolean after(Date when) 判斷當前時間對象 是否是在參數時間以後
boolean before(Date when) 判斷當前時間對象 是否是在參數時間以前

*** >獲取和設置時間參數
void setXxx(int value)
int getXxx()

>日期與毫秒值之間的轉換
long getTime() ; 獲取當前時間對象對應的毫秒值
void setTime(long time); 把當前時間對象設置成參數毫秒值表示的時間

> 獲取本地字符串表示形式
String toLocaleString()

1 寫一個方法 獲取參數字符串表示的時間相對於2000年1月1日過了多少天
// 字符串格式：xxxx年xx月xx號
// 建議使用：java.util.Date類
2 寫一個方法獲取參數字符串表示的時間 30天后是什麼時間
字符串格式：xxxx年xx月xx號
建議使用：java.util.Date類

Calendar:日曆類 生死決鬥
注意：>此類是 抽象類： 經過靜態方法static Calendar getInstance() 返回子類對象

普通方法：
>1 靜態方法返回子類對象
static Calendar getInstance()
>2 兩個時間作比較
boolean after(Object when)
boolean before(Object when)
>3 給指定的字段添加指定值(字段：Calendar的靜態成員變量)
void add(int field, int amount)
--->4 獲取和設置 字段的值
int get(int field)
void set(int field, int value)
--->5 實現日曆對象與日期對象之間的轉換
Date getTime() 由當前日曆對象獲取一個相同時間的日期對象
void setTime(Date date) 把當前日曆對象時間設置爲參很多天期對象對應的時間
--->6 實現毫秒值與日曆對象之間的轉換
long getTimeInMillis()
void setTimeInMillis(long millis)
Calendar:日曆類 生死決鬥
注意：>此類是 抽象類： 經過靜態方法static Calendar getInstance() 返回子類對象
// 建立一個表示2010年1月12日 的日曆對象
//建立Calendar對象只有一種方法 經過calendar的靜態方法 getInstance()
//獲取的是當前時間的日曆對象
Calendar c1=Calendar.getInstance();
//方式1： 經過set方法
c1.set(Calendar.YEAR, 2010);
c1.set(Calendar.MONTH, 1-1);
c1.set(Calendar.DAY_OF_MONTH, 12);
Demo3_Calendar.cal2Str(c1);//2010年1月12號 星期二 16:0:29

//方式2： 實現日期對象與日曆對象之間的轉換
//獲取日期對象 時間2010年1月12日
Date date=new Date(2010-1900, 1-1, 12);
//把c1設置成date表示的時間
c1.setTime(date);
Demo3_Calendar.cal2Str(c1);

//方式3：經過毫秒值與日曆對象之間的轉換
long lon=date.getTime();
//把c1設置成lon表示的時間

simpledateformat:自定義日期格式化類
實現指定格式的字符串與Date對象之間的轉換
格式化 (由日期對象獲取指定格式的字符串)
解析 (由指定格式的字符串獲取日期對象)
構造方法：
SimpleDateFormat(String pattern)
普通方法：
public final String format(Date date) 獲取參數date對象對應指定格式的字符串
public Date parse(String source) 由參數字符串 獲取一個date對象
注意：parse使用時 須要在方法聲明添加throws ParseException

 

經過特殊字符來指定字符串的模式：
y--年
M--月
d--號
E--星期
H--時
m--分
s--秒

*/

插入排序：假設前面的元素是有序的 依次拿當前元素倒着和其前面的元素做比較
//排序 把小的排在左邊
for (int i =1; i < arr.length; i++) {
//當前元素arr[i]
//定義變量記錄當前元素的值
int k=arr[i];
//倒着和其前面的元素作比較
int j;
for ( j= i-1; j >=0; j--) {
//當前面的元素大於當前元素時 前面的元素後移一位
if(arr[j]>k){// -1 -2 10 6,9,0,-3,4,5,2
arr[j+1]=arr[j];
}else{
//找到了當前元素的位置 j+1
//把當前元素放在j+1位置處
//arr[j+1]=k;
break;
}
}
arr[j+1]=k;
}

在建立二維數組時 能夠先只定義二維數組的一維數組個數 能夠不定義每一個一維數組中元素的個數
如 int[][] arr=new int[3][];
在給一維數組的元素賦值時 再定義元素個數
arr[0]=new int[4];

////////////////////////////////////////////////////////////////
集合框架：給集合有關的全部類和接口組成一個體系
集合：裝引用數據類型 長度可變的容器
數組：裝相同類型 指定個數個數據的容器
集合和數組的區別：
相同之處：裝多個數據的容器(都是引用數據類型)
不一樣之處： >元素類型不一樣：
數組的元素能夠是基本數據類型和引用數據類型
集合的元素只能是引用數據類型
>長度是否可變
數組一旦建立 元素個數不能變化
集合元素個數能夠變化
>元素類型是否相同
數組中元素類型必須相同
集合中元素類型能夠不一樣
>元素是否有默認初始值
數組中元素有對應的默認初始值
集合中元素沒有默認初始值

集合框架：
兩個頂層接口 Collection、Map
Collection 單列集合的頂層接口
---List(接口) 有序列表
---ArrayList(主講)
---Vector
---Set(接口) 無序列表
---HashSet(主講)
---TreeSet
Map 雙列集合的頂層接口
---HashMap(主講)
---HashTable

注意：1 目前 看到<> 就當沒有 /看到E 就當Object
2 集合中獲取的元素都是Object類型
Collection：
-- >1 boolean add(E e) 添加元素
boolean addAll(Collection c) 把參數集合中的全部元素添加到當前集合中
-- >2 int size() 獲取元素個數
>3 void clear() 清除全部元素
boolean isEmpty() 判斷是否是空的集合
-- >4 boolean remove(Object o) 移除指定元素
boolean removeAll(Collection c) 移除當前集合中全部存在於參數集合c中的元素
-- >5 Object[] toArray() 獲取對應的數組

建立一個集合 Collection c1=new ArrayList();
裝5個字符串 5個整數
刪除含有a的字符串元素(instancof判斷元素類型)
獲取全部數字元素的平均值

Collection的實現類
ArrayList：長度可變的數組的實現(模擬長度可變的數組)
有序的 可重複的 元素能夠爲null
面試題： ArrayList與Vector 區別：
相同之處：都是單列集合Collection的實現類
都是長度可變的數組的實現
不一樣之處：>ArrayList是不一樣步 線程不安全 效率高
Vector是同步 線程安全 效率低
>ArrayList 1.2版本
Vector 1.0版本

構造方法：
ArrayList()
特有方法：(都是給下標有關)
> void add(int index, E element) 在指定下標出添加元素
> E get(int index) 經過下標獲取元素
> int indexOf(Object o) 獲取參數對象在集合中第一次出現的位置
int lastIndexOf(Object o) 倒着查找 獲取參數對象在集合中第一次出現的位置
> E remove(int index) 經過下標刪除元素 返回的是被刪除的元素
> E set(int index, E element) 把下標index處的元素設置爲element 返回被替換的元素

集合中使用機率最高的類 ArrayList
建立一個學生類：屬性：名字 性別 班級 分數
建立10個學生對象 裝入arraylist中
給全部女生分數+1
分別獲取女生和男生的平均分

HashSet: 無序 不重複 容許null做爲元素的單列集合
方法：徹底實現於 Collection
遍歷HashSet：三種：簡潔for循環 轉換爲數組遍歷數組 迭代器

研究HashSet怎麼保證元素不重複：
boolean add(obj);
>先調用參數對象obj的hashCode()方法 獲取hashCode值
若是此hashCode值惟一(與已有的元素的hashCode值都不相同) 就直接加入
>若是此hashCode值 與已有n個元素的hashCode值相同
就調用obj的equals方法與這n個元素分別比較 當都返回false 才容許加入

Generics 泛型：給集合的元素定義類型(jdk1.5的新特性)
關鍵字：<>
泛型使用：集合類型<元素類型>
泛型好處： >經過編譯器檢測 不再會出現ClassCastException異常
>獲取元素時 不須要再向下轉型
之後使用集合 必須定義泛型 zx

Map 雙列集合 增刪改查操做的都是一對數據
這一對數據：鍵值對
特色：一個鍵只能對應一個值/鍵不能重複
實現類：HashMap
HashMap與HashTable的區別：
相同之處：都是Map基於hash表的實現類 方法基本同樣
不一樣之處：>HashMap 容許null做爲值和鍵
HashTable 不----------
>HashMap 不一樣步 線程不安全 效率高
HashTable 同步 線程安全 效率低
構造方法：HashMap()
方法：
添加： V put(K key, V value)
返回值爲 鍵key原來對應的值 若是原來沒有鍵key 返回null
獲取： V get(Object key) 經過鍵獲取值
int size() 獲取鍵值對的個數
Set<K> keySet() 獲取map的全部鍵 對應的Set
Collection<V> values() 獲取map全部的值對應的Collection

判斷：
boolean containsKey(Object key)
判斷當前map是否是包含指定的鍵
boolean containsValue(Object value)
判斷當前map是否是包含指定的值
刪除：
V remove(Object key) 刪除參數鍵對應的鍵值對
void clear() 清空map

練習：建立一個Stu類 屬性 名字 學號 班級 分數
建立一個arraylist裝10個學生對象

建立一個hashmap 把list中的10個元素做爲值 把學生的學號做爲鍵 裝入map中
遍歷map
求平均分
刪除分數小於60的學生

遍歷map的方式二：
Set<Entry<K,V>> entrySet()
Entry：一個鍵值對對象
K getKey() 獲取鍵
V getValue() 獲取值

一：建立一個Stu類 屬性 名字 學號 班級 分數
建立一個arraylist裝10個學生對象
獲取每一個班級的平均分 與班級編號組成的 map

二：
經過鍵盤輸入 一行字符串 Scanner
使用map記錄每一個字符出現的次數 字符(鍵)和次數

Collections:集合工具類
Arrays:數組工具類
> static void fill(boolean[] a, boolean val)
把全部的元素賦值爲val
> static void sort(byte[] a)
從小到大排序
//當數組的元素沒有比較性時 會包異常classcastexception
>static String toString(boolean[] a)
獲取字符串表示形式

工具類的特色：全部的成員都是靜態

異常：程序運行過程當中 發生不正常的狀況
異常體系： 全部異常類組成的總體
頂層父類：Throwable
異常體系特色：
> 異常體系的類都是Throwable的子類
只有是Throwable的子類 才能稱爲異常類 才能被關鍵字 throws throw catch操做
> 全部的子類方法都繼承於Throwable 都沒有特有方法
> 異常類之間的不一樣：異常緣由(經過構造方法參數) ,異常類型(類名)
> Error和Exception的子類都是以父類的名字結尾
異常體系結構：
Throwable
---Error 錯誤 不能經過代碼邏輯來處理或者避免很是嚴重的異常狀況
處理方式：只能修改代碼
eg:> 不符合語法
> java.lang.OutOfMemoryError 內存溢出
> java.lang.NoClassDefFoundError 類找不到錯誤

---Exception 異常 能夠經過代碼邏輯來處理或者避免的異常狀況
常見的異常：>空指針異常NullPointerException
引用指向null 但調用了此引用的成員
>數組下標越界異常 ArrayIndexOutOfBoundsException
訪問到不存在的下標時
>數學運算異常 ArithmeticException
被零除等一些不符合數學運算語法
>類型轉換異常 ClassCastException
向下轉型時 把多態對象轉換爲其餘類型
>數字格式異常 NumberFormatException
把帶有非數字字符的字符串轉換爲數字時
> 解析異常 ParseException
把字符串解析爲一個對象時
> 不支持的編碼集 UnsupportedEncodingException
使用字符串表示編碼集時
> IO異常 IOException
讀寫文件時出現的異常
> 文件找不到異常 FileNotFoundException

Throwable方法：
構造方法：
Throwable() 把null做爲異常緣由
Throwable(String message) 指定異常緣由

 

異常：程序運行過程當中 發生不正常的狀況
異常體系： 全部異常類組成的總體
頂層父類：Throwable
異常體系特色：
> 異常體系的類都是Throwable的子類
只有是Throwable的子類 才能稱爲異常類 才能被關鍵字 throws throw catch操做
> 全部的子類方法都繼承於Throwable 都沒有特有方法
> 異常類之間的不一樣：異常緣由(經過構造方法參數) ,異常類型(類名)
> Error和Exception的子類都是以父類的名字結尾
異常體系結構：
Throwable
---Error 錯誤 不能經過代碼邏輯來處理或者避免很是嚴重的異常狀況
處理方式：只能修改代碼
eg:> 不符合語法
> java.lang.OutOfMemoryError 內存溢出
> java.lang.NoClassDefFoundError 類找不到錯誤

---Exception 異常 能夠經過代碼邏輯來處理或者避免的異常狀況
常見的異常：>空指針異常NullPointerException
引用指向null 但調用了此引用的成員
>數組下標越界異常 ArrayIndexOutOfBoundsException
訪問到不存在的下標時
>數學運算異常 ArithmeticException
被零除等一些不符合數學運算語法
>類型轉換異常 ClassCastException
向下轉型時 把多態對象轉換爲其餘類型
>數字格式異常 NumberFormatException
把帶有非數字字符的字符串轉換爲數字時
> 解析異常 ParseException
把字符串解析爲一個對象時
> 不支持的編碼集 UnsupportedEncodingException
使用字符串表示編碼集時
> IO異常 IOException
讀寫文件時出現的異常
> 文件找不到異常 FileNotFoundException

Throwable方法：
構造方法：
Throwable() 把null做爲異常緣由
Throwable(String message) 指定異常緣由
普通方法：
> String getMessage() 獲取異常緣由
> void printStackTrace() 經過錯誤輸出流輸出異常基本信息
// java.lang.Throwable: 文件太大了！
// at day23_Exception.Demo2_Throwable2.main(Demo2_Throwable2.java:64)
> String toString() 獲取異常的字符串表示形式: 異常類型:異常緣由

處理異常的方式：
1 拋出機制：把可能產生的異常 封裝成對象 拋給方法的調用者
拋出機制關鍵字：throws 和 throw
拋出機制格式：在方法聲明上加 throws 異常類型1, 異常類型2
eg:public static void hehe(String s) throws ParseException{}
相似於：現實生活中 把問題以書面格式交給領導/
throws ParseException 比如超市特價麪包上面的標籤

ParseException p1=new ParseException("解析出錯！", 1);//第二個參數 不用管
//new一個異常對象 不表明程序出現異常狀況

//程序出現異常狀況 須要使用關鍵字throw
throw p1;

重點：throws和throw的區別：
>位置不一樣
throws用在方法聲明上
throw用在方法體中
>後面跟的內容不同
throws 跟多個異常類型
throw 跟一個異常對象
> 做用不同
throws 用在方法聲明上 給調用者警告 此方法有可能產生那些異常
一旦產生這樣的異常 會被封裝成異常對象 自動拋給方法的調用者
throw 用在方法體中 表示程序發生一個異常狀況

注意： >1 一個方法不可能同時拋出兩個異常
一個方法一旦產生異常 而且選擇拋出機制來處理 那麼此方法的其餘代碼再也不執行
>2 子類只能拋 父類相同 、父類異常的子類異常
子類不能拋 新的 大的異常
>3 一直選擇拋出 最終異常拋給虛擬機 虛擬機統一處理方式
先經過錯誤輸出流打印 異常的全部信息 而後結束程序
拋出機制是消極的處理異常方式 提倡儘可能捕獲

2 捕獲機制
*
*/
2 捕獲機制：捕獲產生的異常對象 而後處理
捕獲機制關鍵字：try catch finally
捕獲機制格式：
try{
try代碼塊(可能產生異常的代碼塊)
}catch(定義異常引用1){
catch代碼塊1(對引用1捕獲的異常進行處理的代碼塊)
}catch(定義異常引用2){
catch代碼塊2(對引用2捕獲的異常進行處理的代碼塊)
}catch(定義異常引用3){
catch代碼塊3(對引用3捕獲的異常進行處理的代碼塊)
}finally{
finally代碼塊("不管"任何狀況都要執行的代碼塊)
}

注意：>1 不管try代碼塊是否產生異常 不管catch代碼塊如何處理異常
都要執行finally代碼塊
>2 當try代碼塊是否產生異常 try代碼塊 再也不執行 而是執行對應的catch的代碼塊
不可能同時執行兩個catch代碼塊
* >3 捕獲父類異常的catch代碼塊 必須放在捕獲子類異常的catch代碼塊後面
* finally代碼塊 通常用於關閉流 釋放資源(io)
*/

Throwable
---Error
---Exception
---運行時異常 (未檢測異常)：繼承RuntimeException的異常
---編譯時異常(已檢測異常)： 沒有繼承RuntimeException的異常
區別：>1 是否爲 RuntimeException的子類
運行時異常是 RuntimeException的子類
編譯時異常不是 RuntimeException的子類
>2 編譯器是否檢測
運行時異常編譯器不檢測 (若是有可能產生運行時異常 不捕獲也不拋出 編譯器不會報錯)
編譯時異常編譯器會檢測(若是有可能產生編譯時異常 不捕獲也不拋出 編譯器會報錯)
>3 是否默認拋出
運行時異常若是不捕獲 默認拋出
>4 出現機率不一樣
運行時異常出現的機率高
編譯時異常只有在特定狀況下才會出現

自定義異常：
異常之間的區別：異常緣由(經過構造方法的參數列表傳遞)和異常類名

MiaoTiaoBaoExcption
1 建立類 繼承異常體系中的類 稱爲異常類
2 經過構造方法的參數列表傳遞異常緣由
3 經過調用父類的有參數的構造方法 傳遞錯誤緣由
4 在方法中產生一個自定義異常狀況

集合重點：
>每種集合類的特色
>每種集合類的遍歷方式

集合概念：裝引用數據類型的容器
集合和數組的區別：
相同之處：都是容器 能夠裝多個數據
>1 是否能夠裝基本數據類型
集合只能裝引用數據類型
數組能夠裝基本數據類型和引用數據類型
>2 元素類型是否必須相同
集合中元素的類型能夠不一樣
數組中元素的類型必須相同
>3 元素個數是否可變
集合的元素個數可變
數組一旦建立 元素個數固定
>4 元素是否有默認初始值
集合中元素沒有默認初始值
數組中元素有默認初始值
集合框架：
集合框架頂層接口：Collection(單列集合頂層接口) Map(雙列集合頂層接口)
Collection(單列集合頂層接口)
普通方法：
>添加： boolean add(E e)
boolean addAll(Collection<E> c)
>刪除： boolean remove(Object o)
boolean removeAll(Collection<E> c)
void clear()
>獲取： Iterator<E> iterator() 獲取迭代器
int size()
Object[] toArray()
>判斷： boolean isEmpty()
boolean contains(Object o)
Iterator接口中的方法：
boolean hasNext()
E next()
遍歷方式： 1 簡潔for循環 2 轉換爲數組 遍歷數組 3迭代器
>for(E e:c1){}
>Object[] arr=c1.toArray();
for(int index=0;index<arr.length;index++){}
>Iterator<E> it=c1.iterator();
while(it.hasNext){
E e=it.next();
}
子接口---List(有序列表)
---ArrayList
特有普通方法
>添加： void add(int index, E element) 把參數對象添加到index位置處
>刪除： E remove(int index) 移除index位置處的元素
>獲取： E get(int index) 獲取index位置處的元素
int lastIndexOf(Object o) 倒着檢索 獲取第一次出現o元素的下標
int indexOf(Object o) 獲取第一次出現o元素的下標
>設置： E set(int index, E element) 把index位置處的元素替換爲element
遍歷方式： 1 簡潔for循環 2 轉換爲數組 遍歷數組 3迭代器 4經過下標獲取元素
>for(int index=0;index<array.size();index++){
E e=array.get(index);
}

---Vector
ArrayList與Vector的區別：
相同之處：都是模擬長度可變數組的Collection的實現類
不一樣之處：>版本不一樣：Vector1.0 ArrayList1.2
>是否同步 Vector 線程安全 同步 但效率低
ArrayList 線程不安全 不一樣步 但效率高
子接口---Set(無序 但不重複集合)
---HashSet
沒有特有方法：
遍歷方式： 1 簡潔for循環 2 轉換爲數組 遍歷數組 3迭代器
HashSet保證不重複的原理：
set.add(obj)
>先定義obj的hashCode()方法 獲取hashcode值 若是此hashcode值惟一
直接加入
>若是有n個元素與此hashcode值相同 則調用obj的equals方法與此n個元素分別比較
只有當都返回false 才容許加入
Map(雙列集合頂層接口)
---HashMap(鍵值對 鍵不能重複 容許null值和null鍵)
HashMap和HashTable的區別：
相同之處：都是基於hash表的Map的實現類
不一樣之處： > HashMap容許有null值和null鍵 但HashTable不容許
> HashMap線程不安全 效率高 HashTable線程安全 效率低

普通方法：
添加： V put(K key,V value);
刪除： V remove(Object key)
獲取： V get(Object key)
Set<K> keySet()
Collection<V> values()
Set<Map.Entry<K,V>> entrySet()
int size()
判斷： boolean containsKey(Object key)
boolean containsValue(Object value)
boolean isEmpty()
File :文件(文件、文件夾)
靜態成員變量：separator \
構造方法：
File(File parent, String child)
File(String pathname)
File(String parent, String child)
普通方法：
> 建立新文件(不能建立文件夾)
boolean createNewFile()
boolean mkdir()
boolean mkdirs()

> 判斷
boolean isDirectory() 判斷是否是目錄
boolean isFile() 判斷是否是標準文件
> 獲取
String getPath() 獲取建立文件時構造方法的參數
String getName() 獲取文件名(不帶目錄)
String getAbsolutePath() 獲取絕對路徑(帶盤符)
String getParent() 獲取父目錄路徑
File getParentFile() 獲取父目錄對象
long length() 獲取當前文件所佔的字節數
File[] listFiles() 獲取當前目錄下的直接子文件
> 刪除
boolean delete()
IO流： 對計算機中數據傳輸的抽象(抽取共同的數據和方法)
流：一組有序的 有起點的 有終點的字節集合
IO流：
>按方向分類： 參照物爲內存
輸入流：把外部存儲設備上的信息 讀到內存中
輸出流：把內存中的信息 寫到外部存儲設備上
把A文件中的信息複製到B文件中
>經過輸入流 把A文件中的信息 讀到內存中
>再經過輸出流 把內存中的信息 寫到B文件中
>按基本單位分類
字節流：每次存在一個字節 以byte爲單位
字符流： 字節流+編碼表
全部的文件均可以用字節流操做 但只有純文本文件 能夠用字符流
>按關聯的對象分類
節點流：關聯文件的流
過濾流/裝飾流： 關聯的是其餘流 具備更多的方法和屬性
文件：源文件 目的文件

InputStream :字節輸入流
----FileInputStream
OutputStream :字節輸出流

注意：導包：java.io.*
InputStream :字節輸入流
----FileInputStream
構造方法：
FileInputStream(String name)
FileInputStream(File file)
普通方法：
int read() 一次讀一個字節
int read(byte[] b) 一次讀一個字節數組
讀取到文件末尾時 返回-1
void close() 關閉流釋放資源
InputStream :字節輸入流
----FileInputStream
OutputStream :字節輸出流
----FileOutputStream

注意：導包：java.io.*
InputStream :字節輸入流
----FileInputStream
構造方法：
FileInputStream(String name)
FileInputStream(File file)
普通方法：
int read() 一次讀一個字節
int read(byte[] b) 一次讀一個字節數組
讀取到文件末尾時 返回-1
void close() 關閉流釋放資源

OutputStream :字節輸出流
----FileOutputStream
構造方法：
FileOutputStream(File file) //關聯目的文件對象
FileOutputStream(String name)
FileOutputStream(File file, boolean append)
FileOutputStream(String name, boolean append)
普通方法：
void close() 關閉流釋放資源
void write(byte[] b)
void write(int b)
void write(byte[] b, int off, int len)
字符流： 讀進來 寫出去
Reader: 字符輸入流的父類
---FileReader
構造方法：
FileReader(File file)
FileReader(String fileName)
普通方法：
int read() 一次讀取一個字符
int read(char[] cbuf) 一次讀取一個字符數組
void close() 關閉流釋放資源

Writer:字符輸出流的父類
---FileWriter
構造方法：
FileWriter(File file)
FileWriter(String fileName)
FileWriter(String fileName, boolean append)
FileWriter(File file, boolean append)
普通方法：
void close()
void write(char[] cbuf)
void write(int c)
void write(String str)
普通方法：
void close()
void write(char[] cbuf)
void write(int c)
void write(String str) 一次寫一個字符串
void flush() 把內容從緩衝區刷新到目的文件
BufferedInputStream 高效字節輸入流
BufferedOutputStream 高效字節輸出流
沒有特有方法：

BufferedWriter 高效字符輸出流
特有方法：
BufferedReader 高效字符輸入流
特有方法： String readLine() 逐行讀取 讀取的內容中沒有互換
到達文件末尾返回null

 

除了FileOutputStream 其餘全部輸出流 必須刷新

過濾流/裝飾流：直接關聯的不是文件 是其餘流
讓被關聯的流具備一些本類不具備的方法

以stream結尾的是 字節流
以reader、writer結尾的是 字符流
轉換流：(字符流)
InputStreamReader：把字節輸入流 轉換爲字符輸入流
OutputStreamWriter：把字節輸出流轉換爲字符輸出流

構造方法：
InputStreamReader(InputStream in, String charsetName)使用指定編碼集
OutputStreamWriter(OutputStream out, String charsetName)
InputStreamReader(InputStream in) 使用默認編碼集
OutputStreamWriter(OutputStream out)

沒有特有方法：全部方法和filewriter 和filereader徹底同樣
不要使用scanner 只使用System.in //static InputStream in
寫一個方法 把鍵盤輸入的數字 字母 和其餘字符 分別寫到三個不一樣的文件中

進程： 本電腦上正在運行的程序 一個程序對應一個進程
線程： 運行的程序中 正在執行的代碼塊
java默認執行 main方法中的代碼塊---main方法的代碼塊對應一個
一個進程至少一個線程在執行 ：
一個進程只有一個線程在執行---單線程
一個進程有多個線程在執行(一個程序有多個代碼塊同時執行)--多線程、線程併發
多線程原理：cpu在時間輪片內在多個線程之間隨機的切換
時間輪片： 時間單位 25ms
進程是線程的執行空間 進程比如 正在開工的工廠
線程是進程的基本單位 線程比如 正在運行的流水線

***java的垃圾處理機制：
垃圾：不存在更多引用的對象
Object: void finalize():當垃圾回收器肯定不存在對該對象的更多引用時，
由對象的垃圾回收器調用此方法。
System: static void gc(): 運行垃圾回收器。
垃圾回收和主方法(主線程)不是同一個線程：
系統會不定時的啓動垃圾回收器 垃圾回收器會經過判斷對象是否是存在更多引用
來判斷對象是否是垃圾 若是是垃圾就調用對象的finalize方法 銷燬對象釋放內存
程序員能夠經過System.gc()來啓動垃圾回收器 來主動干涉垃圾回收機制

線程類：Thread
建立線程方式一：
將類聲明爲 Thread 的子類。
該子類應重寫 Thread 類的 run 方法。
接下來能夠分配並啓動該子類的實例。
>1 建立一個類繼承Thread類
>2 重寫run方法 方法中寫線程任務
>3 建立此線程類的對象
>4 調用線程對象的方法 實現多線程

Thread類的方法：
void start() 開啓線程；java虛擬機會自動調用此線程的run方法

寫三個線程 分別隨機打印100個 數字 小寫字母 大寫字母

Thread類
構造方法：
Thread() 默認線程名字：Thread-編號
Thread(String name) 指定線程名字

Thread(Runnable target)
Thread(Runnable target, String name)
普通方法：
String getName() 獲取線程名字
void setName(String name) 設置線程名字
void start() 開啓線程；Java 虛擬機調用該線程的 run 方法。
void run() 方法體是線程任務
static void sleep(long millis) 線程休眠執行毫秒
static Thread currentThread() 獲取當前正在執行的線程對象

思考一下：
怎麼實現 經過多線程來模擬 三個學生分別給一個老師每人交5本做業
老師獲得一本做業 就打印一下老師的已收到的做業數

建立線程方法二：
聲明實現 Runnable 接口的類。
該類而後實現 run 方法。
而後能夠分配該類的實例，
在建立 Thread 時做爲一個參數來傳遞並啓動

>1 建立一個類 實現Runnable接口
>2 實現run方法 方法體是線程任務
>3 建立實現類對象
>4 建立Thread對象 經過參數列表關聯實現類對象
>5 開啓線程
繼承Thread類 子類要重寫run方法 start方法調用時 虛擬機調用的是線程類的重寫後的run方法
實現Runnable接口 建立的Thread類的對象 start方法調用時 虛擬機調用的是實現類的run方法
void join() 等待該線程終止。
在a線程任務中 調用b線程的join方法 a線程會等待b線程執行完畢 再繼續執行
(a線程任務中要使用b線程的執行結果時 )
*/
死鎖方式一：使用join方法
兩個線程對象互相調用對方的join方法
同步代碼塊：synchronized
線程安全問題：多個線程有多行代碼操做共享數據時 發生結果沒法預期的現象
前提： > 多線程
> 多個線程之間有共享數據
> 線程有多行代碼操做共享數據
根本緣由：A線程在操做共享數據時 B線程對共享數據進行修改
A線程的先後操做共享數據的結果不一致

經過技術解決線程安全問題： 當一個線程在操做共享數據時 其餘線程不能使用共享數據
同步代碼塊：
synchronized(任意對象){
操做共享數據的全部代碼
}
同步代碼塊小括號中的對象：能夠是任意類型的對象 鎖對象
使用同步代碼塊時注意：
> 1 同步代碼塊 必須包括了全部操做共享數據的代碼
> 2 全部線程 的 鎖對象必須惟一
*/

同步方法：當一個方法的整個方法體都是同步時 能夠把此方法定義爲同步方法
有synchronized修飾符
同步方法的鎖是 當前對象 this

線程章的重點：
> 建立線程兩種方式步驟和區別
> 同步代碼塊
> 兩種死鎖

死鎖狀況二：兩個線程 兩個同步代碼塊互相嵌套 內外鎖交替

內部類： 當A類依賴於B類的存在而存在時 把A類定義爲B類的內部類
內部類是外部類的成員
類的成員：成員變量 普通方法 構造方法 內部類 靜態代碼塊 構造代碼塊(給成員變量賦值)
內部類： 當A類依賴於B類的存在而存在時 把A類定義爲B類的內部類
內部類是外部類的成員
類的成員：成員變量 普通方法 構造方法 內部類 靜態代碼塊 構造代碼塊(給成員變量賦值)

xml: extended markup language
可擴展的標記語言
做用: 非編程語言 是描述性語言
用於存儲有關係的數據
用於存儲軟件配置信息(初始數據的加載)
語法: xml的代碼 就是標籤
<標籤名 屬性名="屬性值" 屬性名="屬性值">數據</標籤名>
<標籤名 屬性名="屬性值" 屬性名="屬性值">：起始標籤
數據 :存儲和描述的數據
</標籤名> ：結束標籤

起始標籤和結束標籤的相同之處區別： 標籤名字相同
不一樣之處：>位置不一樣 一前一後
>是否有屬性 起始標籤中能夠加屬性
>格式不一樣 結束標籤面前有/
語法要求:
> xml文件必須有兩部分組成 聲明區和數據區
聲明區： 對整個xml文件進行說明 格式<?xml version="1.0" encoding="gbk" ?>
數據區： 有且只有一個根標籤
> 標籤名和屬性名 都是自定義的
標籤和屬性命名：由數字 字母 下劃線 漢字組成 不能以數字開頭 不能包含空格 : . ?
> 起始標籤中能夠寫多個屬性 屬性格式：屬性名=屬性值
屬性值 規範寫法使用""括起來
> xml中區分大小寫
> 標籤之間能夠合理嵌套： <a><b>額呵呵呵</b><c>二哥哥哥</c></a>
> 註釋格式：<!--註釋的內容-->
> xml是純文本語言 使用能夠操做文本的軟件 均可以做爲xml的編輯工具
xml文件的後綴名必須是.xml 全部瀏覽器中內置有xml的解析器
> 對xml有特殊含義的字符 須要經過字符實體來表示：字符實體格式：&xxxx;
&gt; 大於號
&lt; 小於號
&quot; 雙引號
&amp; 單與

xml的解析：從xml文件中 對數據進行增刪改查

方式一：DOM解析： document object model 文檔對象模型
核心：把xml文件自己和其全部的元素 都封裝成對象 這些有關係的對象造成了dom樹
全部對象類型的頂層接口：Node(節點)
文檔自己： Document(文檔)
標籤： Element
屬性： Attr
文本內容： Text

方式二：SAX解析： simple api xml 簡單的xml解析類庫
核心： 按照順序 以事件監聽的機制對xml文件中的數據進行快速讀取

特色：
Dom解析：優勢：支持對xml文檔增刪改查
缺點：全部的元素都對應一個對象 對象建立在內存中 佔內存
SAX解析：優勢：支持快速讀取
缺點：不支持對xml的正刪改

*/

xml文檔解析： 查詢
對xml操做 必須先獲取Document對象 步驟固定：
Document： NodeList getElementsByTagName(String tagname)
經過標籤名獲取標籤集合

NodeList： int getLength() 獲取元素個數
Node item(int index) 經過下標獲取元素

Element： String getAttribute(String name) 經過屬性名獲取屬性值
NodeList getElementsByTagName(String name) 獲取指定名稱的全部子標籤

Node: String getNodeName() 獲取節點名稱(屬性名和標籤名)
String getTextContent() 獲取標籤的文本內容
short getNodeType() 獲取節點類型

Node getParentNode() 獲取父標籤
NodeList getChildNodes() 獲取全部的子標籤

增刪改查：create delete update read
curd
添加： Document: Element createElement(String tagName) 建立標籤
Element : void setAttribute(String name, String value) 給標籤添加屬性
Node : void setTextContent(String textContent) 給標籤設置文本內容
: Node appendChild(Node newChild) 把參數標籤添加到當前標籤下面
通常狀況：只有最低層的標籤 才設置文本內容

在紅方標籤下添加一個子標籤
<中野司令 name="徐向前">
<軍長 id="5" name="張大彪">
<師長 name="孫德勝" number="10007">騎兵師</師長>
</軍長>
</中野司令>

刪除：
Node : Node removeChild(Node oldChild) 經過父標籤刪除子標籤
Element: void removeAttribute(String name) 刪除屬性
Node:全部元素的父接口
---Document：文檔自己
---Element：標籤
---Text ：文本內容
---Attr ：屬性
增刪改查：create delete update read curd

查詢：
Node: String getNodeName() 獲取當前標籤的名字
NodeList getChildNodes() 獲取全部的子標籤
Node getParentNode() 獲取父標籤
String getTextContent() 獲取文本內容
其餘方法
boolean hasAttributes() 判斷是否是含有屬性
booleen hasChildNodes() 判斷是否是含有子標籤
NamedNodeMap getAttributes()

Document: NodeList getElementsByTagName(標籤名); 經過標籤名獲取標籤集合
Element: String getAttribute(屬性名); 經過屬性名獲取屬性值
NodeList getElementsByTagName(標籤名); 經過標籤名獲取指定的子標籤集合

添加：
Document: Element createElement(標籤名);建立標籤
Node: void setTextContext(文本內容); 添加文本內容
Node appendChild(子標籤) ; 把參數子標籤添加到當前標籤下
Element： void setAttribute(屬性名,屬性值); 添加屬性

刪除： Node: Node removeChild(Node oldChild);由父標籤刪除子標籤
void setTextContext(" "); 刪除文本內容
Element: void removeAttribute(String name) 刪除屬性

1 html概念：
hyper text markup language
超文本標記語言
做用：把數據以指定的樣式經過瀏覽器顯示到頁面上
原理：經過標籤封裝數據 經過屬性控制樣式
基本語法：<標籤名 屬性名=屬性值 屬性名=屬性值>數據</標籤名>
<標籤名 屬性名=屬性值 屬性名=屬性值>：起始標籤
</標籤名> ：結束標籤
屬性名=屬性值 ：屬性
2 html文件組成
>html文件 後綴名爲.html/.htm
>html文件 根標籤 是<html></html>
html標籤中有兩個子標籤head標籤和body標籤
head標籤中 是對當前html文件進行描述的信息 如<title></title>
body標籤中 是當前頁面的顯示數據
3 html代碼注意事項
>html非嚴謹語言 不區分大小寫
>html註釋 <!--註釋的內容-->
>html中的標籤 基本都是以起始標籤和結束標籤
有些標籤沒有要封裝的數據 效果單一----內部閉合標籤
如<br/>換行標籤 <hr/>水平線標籤
>html起始標籤中能夠加屬性控制樣式
屬性：屬性名=屬性值 屬性值能夠有雙引號/單引號括起來 或者不括
建議使用雙引號
> 標籤之間能夠合理嵌套 <p>數據0<font color="red">數據1</font></p>
>html代碼規範：子標籤縮進對其
>html中標籤和屬性是預約義的(那些標籤有哪些屬性是定義好的)
4 文本標籤：
文本塊標籤：
> <br/> 換行標籤
> <h1>標題標籤</h1> hn的n取值1到6
效果：換行 加粗 居左 後面有空行 1到6字體由大到小
屬性：align 水平對其方式 值：left(默認) right center
> <hr/> 水平線標籤
效果：水平線
屬性：size 粗細 值：像素px
color 顏色 值：英文單詞/#6個16進製表示三原色
width 左右寬度 值：像素px/百分百
align 水平對其方式 值：left right center(默認)
> <pre>格式化標籤</pre>
效果：保留數據的原有格式
> <p>段落標籤</P>
效果：先後有空行
屬性：align 水平對其方式 值：left(默認) right center
> <center>居中標籤</center>
文本行標籤：
> <font>文本標籤</font>
效果：封裝數據
屬性：color：文字顏色　值：英文單詞/#6個16進製表示三原色
　　　size: 文字大小 值：1-7 -2---+4
face: 字體樣式
> 特殊效果的文本標籤
b標籤 基礎
i標籤 斜體
u標籤 下劃線
s標籤 中劃線
sup標籤 上標
sub標籤 下標

內部類分爲4種，成員內部類，局部內部類，靜態內部類，匿名內部類
成員內部類：做爲外部類的一個成員存在，與外部類的屬性，方法並列。
注意：1.成員內部類不能定義靜態變量。內存加載狀況。*************************************
2.訪問外部成員時默認外部 類名.this.(外部的)成員，若
沒有重名的，能夠直接（外部類）成員名。
3.訪問內部類成員變量默認有this.同普通類一致。
4.外部類靜態方法訪問內部類，和外部類外部訪問內部類同樣（注意靜態方法的獨立加載區域）
方法爲：Out out=new Out();Inner inner=out.new Inner();建立外部類對象，利用
外部類對象建立內部類對象。使用對象對內部類的成員完成調用。
5.外部類非靜態方法使用內部類，與普通類之間相互調用一致。
成員內部類優勢：
1.內部類能夠訪問外部類全部屬性。
2.可用內部類定義外部類沒法使用的屬性，實現比private小的權限。（內部類屬於編譯時的概念，
一旦編譯成功，就是兩個徹底不一樣的類，造成2個字節碼文件.class）
3.能夠實現類的多繼承。外部類繼承一個類A，內部類繼承另一個類B，便可實現內部類同時繼承
外部類、A、B三個類。
局部內部類：在方法中定義的內部類，與局部變量相似,不能用範圍修飾符修飾，範圍爲定義它的代碼塊。比較複雜，先無論。
靜態內部類：靜態內部類定義在類中，內部可有靜態和非靜態成員，可用範圍修飾符(但不能用private)。
1.內部類可訪問外部類的靜態成員，不能訪問非靜態成員。
2.外部類訪問內部類靜態成員：內部類.靜態成員。外部類訪問內部類的非靜態成員：與普通
類之間調用方法一致。外部類外建立內部類對象：外部類名.內部類名 引用名=new 外部類名.內部類名 ();******************
匿名內部類：一個類用於繼承其餘類或實現接口，並不須要增長額外的方法（加了也不能用），只要對繼承的方法實現或重寫。
1.只是爲了得到一個對象，不須要知道其實際類型（多態引用）。
2.沒有類名，也沒有構造方法。

內部類：實現較高封閉等級，實現多繼承。
序列化流：(過濾流/裝飾流:關聯的是其餘流)
(節點流：關聯的是文件)

ObjectInputStream： 反序列化流:把存儲對象信息的文件讀到內存中 重構成對象
ObjectOutputStream： 序列化流:把內存中對象的信息寫入外部存儲設備中(文件)
---實現數據的持久化存儲
構造方法： ObjectOutputStream(OutputStream out)
ObjectInputStream(InputStream in)
void writeObject(Object obj) 一次寫一個對象
Object readObject() 到達文件末尾 拋出一個EOFException異常

注意事項：
>1 明確序列化流和反序列化流 各自的做用 字節類型的過濾流
>2 序列化流存在的對象必須實現接口Serializable
>3 讀寫方式：逐個對象的讀寫
Object readObject()讀到文件末尾時 排除一個EOFException異常
只能經過判斷是否是捕獲到EOFException異常 來判斷是否是到達文件末尾

正則表達式：爲字符串定義正確規則的字符串
正則的優勢：代碼簡潔 缺點：可讀性差
使用一些特殊字符來表示指定的含義
a 表示 字符a
[] 表示字符取值範圍 [abd] a或者b或者c
^ 在[]中表示取反 [^abc] 處理abc覺得的全部任意一個字符
- 在[]中表示 到 [a-zA-Z] a到z A到Z
[a-z[0-9]] 等價於 [a-z0-9]
[a-z&&[b-f]] 等價於[b-f]

. 表示任意字符
\d [0-9]
\D [^0-9]
\w [a-zA-Z_0-9]
\W [^a-zA-Z_0-9]

^ 單詞開始
$ 單詞結束

x? x次數<=1
x* x次數>=0
x+ x次數>=1
x{n} x次數=n
x{n,} x次數>=n
x{n,m} n<=x次數 <=m
[\u4e00-\u9fa5]漢字

boolean matches(String regex) 判斷當前字符串是否是匹配參數正則 String replaceAll(String regex, String str) 使用str替換符合指定規則的全部子串 String[] split(String regex, int limit)