JAVA（三）JAVA經常使用類庫/JAVA IO

成鵬致遠 |  lcw.cnblog.com  |2014-02-01

JAVA經常使用類庫

1.StringBuffer

1. StringBuffer是使用緩衝區的，自己也是操做字符串的，可是與String類不一樣，String類的內容一旦聲明以後則不可改變，改變的只是其內存地址的指向，而StringBuffer中的內容是能夠改變的
2. 對於StringBuffer而言，自己是一個具體的操做類，因此不能你String那樣採用直接賦值的方式進行對象的實例化，必須經過構造方法完成
3. 當一個字符串的內容須要被常常改變時就要使用StringBuffer
4. StringBuffer的內容是能夠修改的，經過引用傳遞的方式完成
5. StringBuffer經常使用方法
1. 字符串鏈接操做：append()
2. 在任意位置處爲StringBuffer添加內容：insert(int offset, boolean b)
3. 字符串反轉操做：reverse()
4. 替換指定範圍的內容：replace(int start, int end, String str)
5. 字符串截取：substring(int start, int end)
6. 字符串截取：delete(int start, int end)
7. 查找指定的內容是否存在：indexOf()
8. 以上的經常使用方法，實際上對於String類中也是存在的，因此使用的時候直接根據DOC文檔查看便可
6. 小結
1. 凡是須要頻繁修改字符串內容的時候，都要使用StringBuffer類完成
2. StringBuffer類中也提供了一些方法是String類中所沒有的，包括：delete()、insert()等等，這些方法須要的時候直接經過DOC文檔進行查找

2.Runtime類

1. Runtime：運行時，是一個封裝了 JVM進程的類。每個JAVA程序實際上都是啓動了一個 JVM進程，那麼每個JVM進程都是對應這一個Runtime實例，此實例是由 JVM爲其實例化的
2. Runtime類的定義中根本就沒有構造方法，本類的構造方法被私有化了，經過 getRuntime()靜態方法就能夠取得Runtime類的實例
3. 獲得 JVM信息：每個Runtime對象都是由 JVM進行實例化，因此，能夠直接經過此類取得一些信息
4. 能夠直接使用 Runtime類運行本機的可執行程序：public Process exec(String command) throws IOException
5. exec()方法的加值值是 Process，表示一個進程的操做類，能夠經過 destroy()方法銷燬掉一個進程
6. 小結
1. Runtime類自己就是單態設計的一種應用，由於在整個 JVM中只存在一個Runtime類的對象
2. 可使用Runtime類取得 JVM的系統處，或者使用 gc()方法釋放掉垃圾空間
3. 還可使用此類運行本機的程序

3.國際化程序

1. 國際化：程序根據不一樣的語言環境找到不一樣的資源文件，以後從資源文件中取出內容，資源文件中的內容都是以 key ->value的形式保存的，因此在讀取的時候經過其 key找到對應的 value便可
2. 若是要想實現 Java程序的國際化操做必須經過如下的三個類完成
1. java.util.Locale：用於表示一個國家語言類
2. java.util.ResourceBundle：用於訪問資源文件
3. java.text.MessageFormat：格式化資源文件的佔位字符串
3. Locale類
1. Locale表示的是本地，實際上使用的是一個 ISO編碼的封裝類。
2. 對於各個國家來講都存在一個惟一的編碼，那麼這種編碼就稱爲 ISO編碼，使用Locale能夠指定好一個具體的國家編碼
1. 中國編碼：zh-CN
2. 英語-美國的編碼：eh-US
3. 法語的編碼：fr-FR
4. ResourceBundle
1. 此類是專門完成屬性文件讀取操做的，讀取的時候直接指定文件名稱便可（此文件名稱通常不須要指定後綴，後綴統一爲 *.properties）
2. 能夠根據Locale所指定的區域碼來自動選擇所須要的資源文件
3. public static final ResourceBundle getBundle(String baseName)，此方法就是指定要操做的資源文件，此方法找到的是默認的操做系統的語言Locale對象
4. public final String getString(String key)根據 key取得對應的 value
5. 資源文件命名的時候最好採用單詞首字母大寫的方式完成
5. 【注意】對於中文的資源文件雖然能夠直接通中文讀取，可是這樣作是不合理的，應該將其進行 Unicode編碼，轉換爲Java認識的16進制，這樣能夠避免一些系統所帶來的亂碼問題，此工具爲 JDK自動提供：native2ascii.exe，只要是中文，就必須進行轉碼操做
6. 處理動態文本：就必須在資源文件中進行一些動態文本的配置，設置點位符，則必須使用 MessageForm類，此類是在 java.text包中定義的
7. 在 Format類中還存在數字格式化的 Format（NumberFormat）、日期格式化的 Format（DateFormat）
8. JAVA新特性：可變參數：在 JDK1.5以後增長了新特性的操做，能夠向方法中傳遞可變的參數
9. 小結
1. 國際化程序實現的思路：程序與顯示相分離，根據不一樣的 Locale指定的區域找到不一樣的資源文件並根據其 key取得對應的 value
2. 使用資源文件的方式保存全部的信息內容，其基本原理就是依靠了 ResourceBundle類取得資源文件中的內容
3. MessageForm是 Format類的子類，之後還會有 Format其它子類的講解

4.System類

1. System類是一些與系統相關的屬性和方法的集合在 System類中全部的屬性都是靜態的，要想引用這些屬性和方法，直接使用System類調用便可
2. System類能夠經過方法取得一個操做的計算時間：System.currentTimeMillis()
3. 還能夠列出本機的所有系統屬性：getProperties()
4. 一個對象若是不使用，則要等待進行垃圾收集，垃圾收集能夠自動調用也能夠手工調用，手工調用的時候就是調用 System.gc()或者 Runtime.getRuntiom().gc()。可是，若是一個對象在回收以前須要作一些收尾的工做，則就必須覆寫 Object類中的：protected void finalize() throws Throwable，在對象被回收以前進行調用，以處理對象回收前的若干操做，例如釋放資源等等
5. 只有強制性調用 gc()的時候才能夠發現對象被回收，固然，若是不調用，則系統也會在必定時間內自動進行回收
6. 對象生命週期：初始化->對象實例化->垃圾收集->對象終結->卸載
7. 小結
1. System類自己提供的靜態屬性都是與 IO操做有關的，在 IO操做中還將進一步涉及 System類的使用，可使用 System類取得計算的時間，以及經過 gc()方法進行垃圾收集，此方法就是包裝了 Runtime類中的 gc()方法

5.日期操做類

1. Date類是一個較爲經常使用的類，可是其操做的日期格式會有一些不符合於我的的要求，而若是要想進一步取得一些本身須要的時間，則可使用Calendar類
2. 在java.util包中定義了 Date類，Data類自己使用很是簡單，直接輸出其實例化對象便可
3. 若是但願能夠按照本身須要的格式顯示時間，可使用 Calendar類，此類能夠直接將日期精確到毫秒
4. Calendar類是一個抽象類，既然是一個抽象類則確定沒法直接使用，此時就要利用對象多態性的概念，經過向上轉型關係實例化本類對象
5. 使用 Calendar類能夠很是輕鬆取得一個完整的日期，可是在取得月份的時候要特別注意，須要增長1
6. 最好的作法是將 Date進行一些相關的格式化操做
7. 小結
1. Date類雖然直接取出的時間格式並非十分理想，可是其做用依然很大
2. 經過 Calendar類能夠完整的取得時間

6.DateFormat、SimpleDateFormat

1. DateFormat類是一個抽象類，其類自己的內部提供了能夠直接爲其實例化的操做
1. 獲得日期的 DateFormat對象：public static final DateFormat getDateInstance()
2. 獲得日期時間的 DateFormat對象：public static final DateFormat getDateTimeInstance()
2. 直接使用 DateFormat類完成Date類的轉換：public final String Format(Date date)
3. 經過DateFormat類能夠直接將 date類的顯示進行合理的格式化操做，此時採用的是默認的格式化操做，也能夠經過 Locale對象指定要顯示的區域
4. SimpleDateFormat類：功能是完成日期的顯示格式化的
1. 要想實現轉換，則必須首先準備好一個模板，經過此模板進行日期數據的提取工做
2. 在SimpleDateFormat類使用的時候，必須注意的是構造對象時要傳入匹配的模板
3. 構造方法：public SimpleDateFormat(String pattern)
4. 轉換：public Date parse(String source) throws ParseException：此時取得的是所有的時間數
5. 格式化：public final String format(Date date)：將時間從新格式化成字符串顯示
5. 小結
1. DateFormat能夠直接使用，但其自己是一個抽象類，能夠根據 Locale指定的區域不一樣獲得不一樣的日期時間顯示效果
2. SimpleDateFormat類是 DateFormat類的子類，通常狀況下來講 DateFormat類不多會直接使用，而都使用 SimpleDateFormat類完成
3. 直接使用 SimpleDateFormat類取得時間會比使用 Calendar類更加方便，並且不用去增長補零的操做，因此在開發中若是須要取得一個日期的話，則基本上都使用 SimpleDateFormat類進行操做

7.Math與Random

1. Math類，表示數學操做，Math類中的方法都是靜態方法，直接使用「類.方法名稱()」的形式調用便可
2. Math.round求四捨五入的時候其實是將小數點以後的內容所有忽略掉了，若是此時須要進行準確倍數的四捨五入，則須要使用其它的類完成：BigDecimal
3. Random類的主要功能是產生隨機數，能夠產生一個指定範圍的隨機數，Random類是定義在 java.util包中的類
4. 小結
1. Math類中的 round()方法要特別注意
2. Random類的主要功能

8.NumberFormat

1. 可使用 NumberFormat類進行本地化的數字顯示
2. 可使用 DecimalFormat指定格式化模板
3. NumberFormat表示數字的格式化類，即：能夠按照本地的風格習慣進行數字的顯示
4. MessageForm、DateFormat、NumberFormat是 Format三個經常使用的子類，若是要想進一步完成一個好的國際化程序，則確定須要同時使用這樣三個類完成，根據不一樣的國家顯示日期，或者顯示貨幣的形式
5. DecimalFormat是 NumberFormat類的子類，能夠直接指定其顯示的模板
6. DecimalFormat主要的做用是用來格式化數字使用，固然，在格式化數字的時候要比直接使用 NumberFormat更加方便，由於能夠直接指定按用戶自定義的方式進行格式化操做，與以前講解的 SimpleDateFormat相似，若是要想進行自定義格式化操做，則必須指定格式化操做的模板
7. 小結
1. NumberFormat完成的功能只是根據區域不一樣固定的數字顯示格式
2. DecimalFormat是能夠由用戶本身指定其顯示的形式，因此比較好用　

9.大數操做

1. 在java中有兩個大數的操做類
1. 操做整型：BigInteger
2. 操做小數：BigDecimal
2. 若是在操做的時候一個整型數據已經超過了整數的最大類型長度long的話，則此數據就沒法裝入，因此，此時要使用BigInteger類進行操做
3. BigDecimal：使用此類能夠完成大的小數操做，並且也可使用此類進行精確的四捨五入，這一點在開發中常用
4. 對於不須要任何準確計算精度的程序能夠直接使用float或double完成，可是若是須要精確計算的結果，則必須使用BigDecimal類
5. 小結
1. 使用BigDecimal能夠指定好四捨五入的精確位置

10.對象克隆技術

1. 對象克隆：對象的複製，完整的複製一個對象
2. 若是要想完成對象克隆的話，則確定依靠 Object類：方法：protected Object clone() throws CloneNotSupportedExcetion
3. 以上的方法就是對象克隆的方法，若是如今一個類的對象被克隆，則就必須在此類中明確的覆寫此方法，可是此方法不能直接調用
4. Cloneable是一個接口，可是在此接口中並無規定任何的操做方法，因此此接口實際上屬性標識接口，表示一種能力
5. 對象克隆支持：在java中支持對象的克隆操做，直接使用 Object類中的clone()方法便可
6. 對象全部的類必須實現 Cloneable接口才能夠完成對象的克隆操做
7. 小結
1. 在之後的JAVA類庫中會常常看到 Cloneable接口的出現
2. 只有實現了 Cloneable接口的對象才能夠被克隆，不然沒法克隆

11.比較器（Comparable、Comparator）

1. Array類中存在 sort()方法，此方法能夠直接對對象進行排序
2. 能夠直接使用 java.util.Arrays類進行數組的排序操做，但對象所在的類必須實現 Comparable接口，用於指定排序接口
3. 比較器的排序原理：實際上比較器的操做，就是常常聽到的二叉樹的排序算法
4. 排序的基本原理：使用第一個元素做爲根節點，以後若是後面的內容比根節點要小，則放在左子樹，若是內容比根節點的內容要大，則放在右子樹
5. 另外一種比較器：若是一個類已經開發完成，可是此類創建的初期並不實現 Comparable接口，此時確定是沒法進行對象排序操做的，因此爲了解決這樣的問題，java又定義了另外一個比較器的操做接口：Comparator
6. 小結
1. 在使用中儘量仍是使用 Comparable在須要排序的類上實現好此接口，而 Comparator須要單獨創建一個排序的類，這樣若是有不少的話，則排序的規則類就會很是的多，操做起來比較麻煩
2. 掌握一點：只要是對象排序，則在java中永遠是以 Comparable接口爲準

12.觀察者模式

1. 若是要想實現觀察者模式，則必須依靠java.util包中提供的 Observable類和 Observer接口
2. 在 Observer接口中的 update方法裏面有兩個參數
1. o：表示 Observable類的對象
2. arg：須要被觀察的內容
3. 小結
1. 此模式是一種Java自己的機制，不使用 Observer和 Observable也是能夠實現的，只是比較複雜

13.正則表達式

1. 正則表達式能夠方便的對數據進行匹配，能夠執行更加複雜的字符串驗證，拆分、替換功能
2. Pattern、Matcher兩個類爲正則的核心操做類，兩個類都定義在 java.util.regex包中
1. Pattern類的主要做用是進行正則規範（如「[0-9]」就屬於正則規範）的編寫
2. Matcher類主要是執行規範，驗證一個字符串是否符合其規範
3. 正則表達式
1. \d：表示數字，[0-9]
2. \D：表示非數字，[^0-9]
3. \w：表示字母、數字、下劃線，[a-zA-Z0-9]
4. \W：表示非字母、數字、下劃線，[^a-zA-Z0-9]
4. 要想驅動正則表達式，必須依靠Pattern類和Matcher類
5. Pattern類中沒有明確的構造方法能夠供用戶使用，那麼則確定此類的構造方法被私有化了，則能夠直接從Pattern類中取得本類的實例
1. 指定好操做的正則：public static Pattern compile(String regex)
2. 能夠爲 matcher類實例化：public Matcher matcher(CharSequence input)
3. 拆分：public String[] spilt(Charsequence input)
6. 若是要驗證一個字符串是否符合規範，則可使用Matcher類
1. 進行字符串的驗證：public boolean matcher()
2. 字符串替換：public String replaceAll(String replacement)
7. 只要使用正則的驗證的規則，那麼就能夠匹配各類複雜的字符串
8. String類對正則的支持：在 JDK1.4以後，Java對正則進行了一些擴充，在 String中開始直接支持正則的操做
1. 字符串匹配：public boolean matchers(String regex)
2. 字符串替換：public String replaceAll(String regex, String replacement)
3. 字符串拆分：public String[] split(String regex)
9. 【注意】若是有時候發現一個字符串沒法按照指定的字符拆分的話，則須要使用「\」轉義，轉義的時候兩個「\」表示一個「\」
10. 小結
1. 使用正則能夠方便的完成字符串的驗證、拆分、替換等複雜功能
2. 在開發中通常都會直接使用 String類中提供好的正則支持，而每每不多直接使用 Pattern類或者Matcher類
3. 在一些正則應用的時候，對於一些敏感的字符要進行轉義操做

14.定時調度

1. 定時調度：每當一段時間，程序會自動執行，稱爲定時調度
2. 若是要使用定時調度，則必須保證程序始終運行着才能夠，也就是說是至關於定時調度是在程序以外又啓動了一個新的線程
3. Timer和 TimerTask兩個類完成定時調度
4. Timer類
1. Timer類是一種線程設施，能夠用來實如今某一時間或某一段時間後，安排某一個任務執行一次，或按期重複執行
2. 該功能要與 TimerTask配合使用。
3. TimerTask類用來實現由 Timer安排的一次或重複執行的某一個任務
4. 每個 Timer對象對應的是一個線程，所以計時器所執行的任務應該迅速完成，不然可能會延遲後續任務的執行，而這些後續的任務就有可能堆在一塊兒，等到該任務完成後才能快速連續執行
5. schedule()與scheduleAtFixedRate()方法的區別
1. 二者的區別在與重複執行任務時，對於時間間隔出現延遲的狀況處理
2. schedule()方法的執行時間間隔永遠是固定的，若是以前出現了延遲的狀況，以後也會繼續按照設定好的間隔時間來執行
3. scheduleAtFixedRate()方法能夠根據出現的延遲時間自動調整下一次間隔的執行時間
6. TimerTask類
1. 要想執行具體的任務，則必須使用TimerTask類，TimerTask類是一個抽象類，若是要使用該類，須要本身創建一個類來繼承此類，並實現其中的抽象方法
2. 若是如今一個 Timer類要想調度程序的話，則須要使用 TimerTask的子類
3. 完成一個具體的任務操做類，之後定時調度的是此類的操做，方法的主體就是 run()方法
7. 小結
1. 通常在 web的開發中此內容比較有用，由於要維護一個窗口不關閉才能夠一直定時操做下去

---

JAVA IO

1.File類

1. 全部的 io操做都保存在 java.io包中
2. 在整個 io包中，惟一表示與文件自己有關的類就是 File類
3. 使用 File類能夠進行建立或刪除文件等經常使用操做
4. 構造方法：public File(String pathname) ->實例化 File類的時候，必須設置好路徑，直接根據路徑找到文件
5. File類經常使用方法
1. 建立文件：public boolean createNewFile() throws IOException
2. 分隔符：File.separator
3. 刪除一個文件：public boolean delete()
4. 判斷文件是否存在：public boolean exists()
5. 全部的 JAVA IO操做並不會馬上執行，由於 JAVA是經過 JVM與底層進行交互的，因此全部的操做須要通過 JVM完成，那麼就有可能產生延遲
6. 建立文件夾：public boolean mkdir()
7. 列出指定目錄的所有文件
1. 以字符串數組的形式返回：public String[] list() ->只是列出所有的名字，包括文件夾名字和文件名字
2. 以 File數組的形式返回：pulic File[] listFiles() ->列出一個完整的路徑，這樣對於程序自己來講是很容易操做的
8. 判斷一個給定的路徑是不是目錄：public boolean isDirectory()
9. 小結
1. File類是在 java.io包中惟一與文件自己有關的
2. 可使用 File類建立、刪除等常見的文件操做
3. 在使用 File類指定路徑的時候必定要注意操做系統間的差別，儘可能使用 separator進行分割

2.RandomAccessFile

1. RandomAccessFile類的主要功能是完成隨機讀取功能，能夠讀取指定位置的內容
2. RandomAccessFile寫數據的時候能夠將一個字符串寫入，讀的時候須要一個個的以字節的形式讀取出來
3. 若是要想操做文件內容的話，可使用 RandomAccessFile完成
4. 小結
1. RandomAccessFile類的做用
2. RandomAccessFile類操做起來比較麻煩，因此在 IO中會提供專門的輸入、輸出操做

3.字節流與字符流

1. 流：在程序中全部的數據都是流的方式進行傳輸或保存的，程序須要數據的時候要使用輸入流讀取數據，而當程序須要將數據保存起來的時候，就要使用輸出流完成
2. 程序中的輸入輸出都是以流的形式保存的，流中保存的實際上全都是字節文件
3. 在 java.io包中操做文件內容的主要有兩大類：字節流、字符流，兩類都分爲輸入和輸出操做
1. 在字節流中輸出數據主要是使用 OutputStream完成，輸入使的是 InputStream
2. 在字符流中輸出數據主要是使用 Writer類完成，輸入主要是使用 Reader類完成
3. 實際上四個操做類都是抽象類
4. 在 JAVA中 IO操做也是有相應步驟的，以文件操做爲例，主要的操做流程以下：
1. 使用 File類打開一個文件
2. 經過字節流或字符流的子類，指定輸出的位置
3. 進行讀/寫操做
4. 關閉輸入/輸出
5. 使用 File類操做的時候必定要有路徑的問題，注意分隔符
6. IO操做屬於資源操做，對於資源操做，操做的最後都必須關閉，不然就有可能出現未知的錯誤
7. 字節流
1. 字節流主要是操做 byte類型數據，以 byte數組爲準，主要操做類就是 OutputStream、InputStream
2. Byte是字節，確定是字節流操做，全部的數據基本上均可以直接使用 byte數組表示出來
3. OutputStream
1. OutputStream是整個 IO包中字節輸出流的最大父類
2. OutputStream是一個抽象類，若是要想使用此類的話，則首先必須子類實例化對象，那麼若是如今要操做的是一個文件，則可使用：FileOutputStream類，經過向上轉型以後，能夠爲 OutputStream實例化
3. Closeable：表示能夠關閉的操做，由於程序運行到最後確定要關閉
4. Flushable：表示刷新，清空內存中的數據
4. InputStream
1. 經過 InputStream能夠從文件中把內容讀取進來
2. InputStream自己也是一個抽象類，必須依靠其子類，若是如今是從文件中讀取，子類確定是 FileInputStream
3. 知道文件大小：直接使用 File類便可：public long length()
8. 字符流
1. 在程序中一個字符等於2個字節，JAVA提供了Reader、Writer兩個專門操做字符流的類
2. Writer
1. Writer自己也是一個抽象類，若是要想使用此類，則確定要使用其子類，此時若是是向文件中寫入內容，因此應該使用 FileWriter的子類
2. 字符流的操做比字節流操做好在一點：就是能夠直接輸出字符串了，不用再像以前那樣進行轉換操做了
3. Reader
1. Reader是使用字符的方式從文件之中取出數據
2. Reader自己也是抽象類，若是如今要從文件中讀取內容，則能夠直接使用 FileReader子類
9. 字節流與字符流的區別
1. 字節流和字符流使用是很是類似的
2. 字節流在操做的時候自己是不會用到緩衝區（內存）的，是與文件自己直接操做的
3. 字符流在操做的時候是使用到緩衝區的
10. 【問題】開發中使用字節流好仍是字符流好：在全部的硬盤上保存文件或是進行傳輸的時候都是以字節的方式進行的。包括圖片也是按字節完成，而字符是隻有在內存中才會造成的，因此使用字節的操做是最多的
11. 小結
1. 掌握流的概念
2. 掌握字節流和字符流操做文件的基本步驟
1. 本章是以文件爲例，實際之後的全部操做均可以經過此段代碼完成，只是替換子類而已
3. 字節流和字符流的區別
1. 字節流：沒有使用緩衝區
2. 字符流：使用了緩衝區
4. 邊讀邊寫的方式在開發中很是有用處

4.字節-字符轉換流

1. 在整個 IO包中，實際上就是分爲字節流和字符流，可是除了這兩個流以外，還存在了一組字節流-字符流的轉換
2. OutputStreamWriter：是Writer的子類，將輸出的字符流變爲字節流，即：將一個字符流的輸出對象變爲字節流的輸出對象
3. InputStreamReader：是Reader的子類，將輸入的字節流變爲字符流：即：將一個字節流的輸入對象變爲字符流的輸入對象
4. 若是以文件操做爲例
1. 則在內存中的字符數據須要經過 OutputStreamWriter變爲字節流才能保存在文件之中，讀取的時候須要將讀入的字節流經過 InputStreamReader變爲字符流
3. 雖然只是以文件操做爲例，由於 OutputStreamWriter中接收的類型是 OutputStream，只要是字節輸出流均可以使用字符的形式操做
4. 而InputStreamReader()中接收的類型是 InputStream，只要是字節的輸入流均可以使用字符的輸入流操做
5. FileWriter和FileReader的說明
1. 從 JDK文檔中能夠知道 FileOutputStream是 OutputStream的直接子類，FileOutputStream也是 InputStream的直接子類
2. 可是在字符流文件的兩個操做類卻有一些特殊
3. FileWriter並不直接是Writer的子類，而是 OutputStreamWriter的子類，而 FileReader也是直接是 Reader的子類，是 InputStreamReader的子類
4. 那麼從這兩個類的繼承關係就可清楚的發現，無論是使用字節流仍是字符流實際上最終都是以字節的形式操做輸入輸出流的
5. 也就是說：最後無論如何，雖然是以字符的輸出流形式操做了字節的輸出流，可是實際上仍是以字節的形式輸出，而字符的輸入流，雖然以字符的形式操做，可是實際仍是使用的字節流
6. 也就是說：傳輸或者是從文件讀取數據的時候，文件裏真正保存的數據永遠是字節
6. 小結
1. 必定要掌握兩個轉換類的做用
2. 必定要明白，操做的終端點實際上都是以字節的形式進行的
3. FileWriter和FileReader兩個子類的定義，中間使用了轉換類

5.內存操做流

1. 以前的輸入和輸出都是從文件中來的，固然，也能夠將輸出的位置設置在內存之上
2. 此時就要使用 ByteArrayInputStream、ByteArrayOutputStream來完成輸入、輸出功能了
3. ByteArrayInputStream：主要完成將內容寫入到內存之中
4. ByteArrayOutputStream：主要將內存中的數據輸出
5. 此時操做的時候應該之內存爲操做點
7. 若是要想把一個字符變爲小寫，則能夠經過包裝類：Character
8. 小結
1. 內存操做流的操做對象必定是之內存爲準，不要以程序爲準
2. 實際上此時能夠經過向上轉型的關係爲 OutputStream或 InputStream實例化
3. 這樣的操做能夠很好的體現對象的多態性，經過實例化其子類的不一樣，完成的功能也不一樣，也就至關於輸出位置也就不一樣，若是是文件，則使用 FileXxx，若是是內存，則使用 ByteArrayXxx
4. 內存輸出流是 JAVA開發中也常常要使用到，要重點掌握

6.管道流

1. 管道流的主要做用是能夠進行兩個線程間的通信，分爲管道輸出流（PipedOutputStream）、管道輸入流（PipedInputStream）
2. 若是要想進行管道輸出，則必須把輸出流連在輸入流之上，在PipedOutputStream類上有一個方法用於鏈接管道：public void connect(PipedInputStream snk) throws IOException
4. 要想實現管道流，則可使用 PipedInputStream和 PipedOutputStream
5. 小結
1. 在 JAVA開發中不多直接去開發多線程程序

7.打印流

1. 在整個 IO包中，打印流是輸出信息最方便的類，主要包含字節打印流（PrintStream）和字符打印流（PrintWriter）
2. 在打印流類中定義了不少的 print()或 println()方法，System.out.println()，此方法能夠打印任何數據類型
3. 構造方法：public PrintStream(OutputStream out) ->參數指定輸出位置
4. 在 JDK1.5以後，JAVA又對 PrintStream類進行了擴充，增長了格式化的輸出方式，直接使用 printf()方法就能夠完成操做
5. 小結
1. PrintStream能夠方便的完成輸出的功能
2. 在之後的輸出中基本上都使用 PrintStream完成，由於比較方便一些
3. PrintStream屬於裝飾設計模式

8.System類對 IO類的支持

1. System.out和 System.err的區別
1. System.out和 System.err都是 PrintStream的實例化對象，並且二者均可以輸出錯誤信息，可是通常來說 System.out是將信息顯示給用戶看，是正常的信息顯示，而 System.err的信息正好相反是不但願用戶看到的，會直接在後臺打印，是專門顯示錯誤的
2. System.in其實是一個鍵盤的輸入流，其自己是 InputStream類型的對象，那麼，此時就能夠利用此方式完成從鍵盤讀取數據的功能
1. 指定了輸入數據的長度，若是如今輸入的數據超過了長度範圍，則只能輸入部分數據
2. 指定的 byte數組長度是奇數的話，則還有可能出現中文亂碼的問題
3. 最好的輸入方式
1. 最好的輸入方式是將所有輸入的數據暫放到一塊內存之中，以後一次性的從內存中讀取出數據，這樣全部數據只讀了一次，則不會形成亂碼，並且也不會受長度的限制
2. 若是要想實現以上的功能，則只能經過 BufferReader類完成
4. 重定向
1. 爲 System.out輸出重定向：使用 setOut()方法完成
2. 爲 System.err輸出重定向：使用 setErr()方法完成
3. 爲 System.in輸出重定向：使用 setIn()方法完成
4. 對於重定向操做，基本上都在 System.out上使用，以把信息展示給用戶觀看
5. 小結
1. 三個常量的使用
1. System.out：是但願用戶能夠看見的信息，用 IDE（Eclipse）的話錯誤信息是用黑顏色顯示的
2. System.err：是不但願用戶能夠看見的信息，用 IDE（Eclipse）的話錯誤信息是用紅顏色顯示的
3. System.in：對應鍵盤輸
2. 以上三個常量的輸入、輸出均可以重定向，可是通常只建議修改 setOut的重定向
3. System.in 讀取的時候會出現中文亂碼問題，則能夠經過 BufferReader完成讀取功能

9.BufferedReader類

1. 若是想接收任意長度的數據，並且避免亂碼產生，就可使用 BufferedReader
2. public class BufferedReader extends Reader　->由於輸入的有可能出現中文，因此，此處使用字符流完成
3. BufferedReader是從緩衝區中讀取內容，全部的輸入的字節數據都將放在緩衝區之中
4. System.in自己表示的是 InputSteam（字節流），如今要求接收的是一個字符流，則須要將字節流變爲字符流才能夠，InputStreamReader
6. 小結
1. 掌握 BufferedReader類的做用
2. 可使用 BufferedReader接收輸入的數據

10.Scanner類

1. 在 JDK1.5以後 JAVA提供了專門的輸入數據類，此類能夠完成 BufferReader類的功能，也能夠方便的對輸入數據進行驗證，此類放在 java.util包中，此類是個工具類
2. 若是要想輸入空格的話，則就必須修改分隔符，將分隔符變成「\n」
3. Scanner這個類雖然能夠接收各類類型，可是對於日期型的數據卻沒法接收
4. 若是要想接收 Date類型的數據，則只能經過字符串轉型，可是在接收的時候依然可使用 Scanner類中提供的方法進行驗證
1. 進行驗證：public String next(Pattern pattern)
2. 進行接收：public String next(String pattern)
5. 還能夠直接從文件中讀取信息
6. 在使用 Scanner讀文件的時候，要考慮到換行的功能
7. 小結
1. 掌握 Scanner類的做用：方便的讀取數據
2. 在讀取操做的時候必定要注意分隔符的影響

11.數據操做流

1. 在 IO包中，提供了兩個與平臺無關的數據操做流
1. 數據輸出流：DataOutputStream
2. 數據輸入流：DataInputStream
2. 一般數據輸出流會按照必定的格式將數據輸出，再經過數據輸入流按照必定的格式將數據讀入
3. 若是要想使用數據操做流，則確定要由用戶本身指定數據的保存格式，必須按指定好的格式保存數據，纔可使用數據輸入流將數據讀取出來
4. DataOutputStream繼承自 FilterOutputStream類（FilterOutputStream是 OutputStream的子類）同時實現了 DataOutput接口，在 DataOutput接口定義了一系列的寫入各類數據的方法
5. DataOutputStream接口定義了一系列的 writeXxx()的操做，能夠寫入各類數據類型的數據
6. 要想使用 DataOutputStream寫入數據的話，則必須指定好數據的輸出格式
7. 小結
1. 隨機讀取訪問很類似
2. 兩個接口：DataOutput接口、DataInput接口，這兩個接口的操做彼此對應，並且之後還要使用

12.合併流

1. 合併流：從概念上講就是內容合併在一塊兒了
2. 合併流的主要功能就是將兩個文件的內容合併成一個文件
3. 主要操做的是內容
4. SequenceInputStream類直接繼承自 InputStream

13.壓縮流

1. ZIP是一種常見的壓縮形式，在 Java中要想實現 ZIP的壓縮須要導入 java.util.zip包，可使用此包中的 ZipFile、ZipOutputStream、ZipInputStream、ZipEntry幾個類完成操做
2. 在 JAVA IO中不只能夠實現 ZIP壓縮格式的輸入、輸出，也能夠實現 JAR及 GZIP文件格式的壓縮
3. ZipEntry：在每個壓縮文件中都會存在多個子文件，那麼這每個的子文件在 JAVA中就使用 ZipEntry表示
4. 在實例化 ZipEntry的時候，要設置名稱，此名稱實際上就是壓縮文件中每個元素的名稱
5. 若是要想完成一個文件或文件夾的壓縮，要使用 ZipOutputStream類完成，ZipOutputStream是 OutputStream的子類，就是一個字節的輸出流，此類的功能就是 ZIP格式輸出的
6. 在壓縮文件中，每個壓縮的內容均可以用一個 ZipEntry表示，因此在進行壓縮以前必須經過 puNextEntry設置一個 ZipEntry便可
7. ZipFile：是一個專門表示壓縮文件的類
8. 在 Java中，每個壓縮文件均可以使用 ZipFile表示，還可使用 ZipFile根據壓縮後的文件名稱找到每個壓縮文件中的 ZipEntry並將其進行解壓縮操做
9. ZipFile在實例化的時候必須接收 File類的實例，此 File類的實例是指向一個壓縮的 *.zip文件
10. ZipEntry對象，能夠找到每個 ZipEntry的輸入流，可是 ZipInputStream並不能獲得每個輸入流，因此須要使用 ZipFile，可是 ZipInputStream在取得每個 ZipEntry的時候，不須要每個 ZipEntry的名稱
11. 小結
1. 壓縮文件中每個壓縮實體都使用 ZipEntry保存，一個壓縮文件中可能包含一個或多個的 ZipEntry對象
2. 在 JAVA中能夠進行zip/jar/gz三種格式的壓縮支持，操做流程基本是同樣的
3. ZipOutputStream能夠進行壓縮的輸出，可是輸出的位置不必定是文件
4. ZipFile表示每個壓縮文件，能夠獲得每個壓縮實體的輸入流

14.回退流

1. 回退：給了用戶第二次讀的機會
2. 在 JAVA IO中全部的數據都是採用順序的讀取方式，即，對於一個輸入流來說都是採用從頭至尾順序讀取的，若是在輸入流中某個不須要的內容被讀取進來，則只能經過程序將這些不須要的內容處理掉，爲了解決這樣的讀取問題，在 Java中提供了一種回退輸入流（PusbackInputStream、PushbackReader）能夠把讀取進來的某些數據從新退回到輸入流的緩衝區中
3. 使用 InputStream要使用 read()方法不斷讀取，是採用順序的讀取方式
4. 回退操做一樣分爲字節和字符流
5. 對於回退操做來講，提供了三個 unread()的操做方法，這三個操做方法與 InputStream類中的 read()方法是一一對應的

15.字符編碼

1. 在計算機世界裏，任何的文字都是以指定的　編碼方式存在的，在 JAVA程序的開發中最多見的是如下的幾種：、GBK/GB23十二、unicode、UTF
1. ISO8859-1：編碼屬於單字節編碼，最多隻能表示 0~255的字符範圍，主要在英文上應用
2. GBK/GB2312：中文的國標編碼，專門用來表示漢字，是雙字節編碼，GBK包括中文繁體，字庫更大
3. unicode：java中就是使用此編碼式，也是最標準的一種編碼，是使用16進製表示的編碼，但此編碼不兼容ISO8859-1編碼
4. UTF：因爲 nnicode不支持 ISO8859-1編碼，並且容易佔用更多的空間，並且對於英文字母也須要使用兩個字節編碼，這樣使用 unicode不便於傳輸和存儲，所以產生了 utf編碼，utf編碼兼容了 ISO8859-1編碼，同時也能夠用來表示全部的語言字符，不過 utf編碼是不定長編碼，每個字符的長度從 1~6個字節不等，通常在中文網頁中使用此編碼，由於這樣能夠節省空間
2. 若是沒有處理好編碼的事情，則確定在程序中出現亂碼
3. 亂碼產生的根本緣由就是字符編碼不統一形成的
4. 小結
1. 瞭解幾種經常使用的編碼特色
2. 理解亂碼是如何產生的

16.對象序列化

1. 什麼叫對象序列化：一個對象產生以後其實是在內存中爲其開闢了一個存儲空間，方便存儲信息
2. 對象序列化：就是把一個對象變爲二進制的數據流的一種方法，經過對象序列化能夠方便的實現對象的傳輸或存儲
3. 若是一個類的對象想被序列化，則對象所在的類必須實現 java.io.Serializable接口
4. Serializable接口中沒有一個方法，此接口屬於一個標識接口，表示具有了某種能力
5. 被序列化了的對象，變爲二進制 byte流
6. 對象的序列化和反序列化
1. 要想完成的輸入或輸出，還必須依靠對象輸出流（ObjectOutputStream）和對象輸入流（ObjectInputStream）
2. 使用對象輸出流輸出序列化對象的步驟，有時也稱爲序列化，而使用對象輸入讀入對象的過程，有時也稱爲反序列化
4. 對象序列化依靠：ObjectOutputStream，對象反序列化依靠：ObjectInputStream
5. ObjectOutputStream類的使用形式與 PrintStream很是的類似，在實例化時也須要傳入一個 OutputStream的子類對象，以後根據傳和的 OutputStream子類的對象不一樣，輸出的位置也不一樣（裝飾模式）
7. SerialVersionUID：在對象進行序列化或反序列化操做的時候，要考慮 JDK版本的問題，若是序列化的 JDK版本和反序列化的 JDK版本不統一則就有可能形成異常，因此在序列化操做中引入了一個 SerialVersionUID的常量，能夠經過此常量來驗證版本的一致性，在進行反序列化時，JVM會把傳來的字節流中的 SerialVersionUID與本地相應實體（類）的　SerialVersionUID進行比較，若是相同就認爲是一致的，要以進行反序列化，不然就會出現序列化版本不一致的異常
8. 【問題】對象序列化到底序列化了哪些東西：全部的對象擁有各自的屬性值，可是全部的方法都是公共的，因此序列化對象的時候實際上序列化的就是屬性
9. Externalizable接口
1. 使用Serializable接口能夠方便的序列化一個對象，可是在序列化操做中也提供了另一種序列化機制：Externalizable接口
2. 被 Serializable接口聲明的類其對象的內容都將被序列化，若是如今用戶但願能夠本身指定序列化的內容，則可讓一個類實現 Externalizable接口
3. 寫入方法：void writeExternal(ObjectOutput put) throws IOException
4. 讀取方法：void readExternal(ObjectInput in) throws IOExcetion,ClassNotFoundExceteption
5. 在使用 Externalizable接口的時候須要在被序列化的類中定義一個無參構造函數，由於此接口在進行反序列化的時候，會先用類中的無參構造方法爲其進行實例化，以後再將內容分別設置到屬性之中
10. transient關鍵字：當使用 Serializable接口實現序列化操做時，若是一個對象中的某個屬性不但願被序列化的話，則可使用 transient關鍵字進行聲明
11. transient + Serializable接口完成能夠取代 Externalizable接口的功能
12. 序列化一組對象
1. 對象輸出時只提供了一個對象的輸出操做（writeObject(Object obj)），並無提供多個對象的輸出，因此若是如今要同時序列化多個對象的時候就可使用對象數組進行操做，由於數組屬於引用數據類型，因此能夠直接使用 Object類型進行接收
2. 若是要保存多個對象，則最好使用對象數組的形式完成
3. 數組保存的數據有限，因此爲了解決這樣的問題，Java中引入了類集框架解決數組的存儲限制問題
13. 小結
1. 對象序列化的做用：對象序列化並不必定都向文件中保存，也有可能面向於其它的輸入或輸出
2. 被序列化的類必須實現 Serializable接口，若是某個屬性不但願被保存下來，則可使用 transient關鍵字聲明
3. ObjectOutputStream序列化對象，ObjectInputStream反序列化對象
4. Externalizable接口的做用：開發人員手工實現序列化的操做
5. 使用序列化保存一組對象的時候要使用對象數組的形式操做