2. 程式人生 > >Java IO詳解

Java IO詳解

阿新 • • 發佈：2017-05-18
amr mst 數據丟失 網上 ria break idc png 字符串

學習Java的同學註意了！！！

學習過程中遇到什麽問題或者想獲取學習資源的話，歡迎加入Java學習交流群，群號碼：618528494 我們一起學Java！

初學Java，一直搞不懂Java裏面的io關系，在網上找了很多大多都是給個結構圖草草描述也看的不是很懂。而且沒有結合到java7 的最新技術，所以自己來整理一下，有錯的話請指正，也希望大家提出寶貴意見。

首先看個圖：（如果你也是初學者，我相信你看了真個人都不好了，想想java設計者真是煞費苦心啊！）

技術分享

這是Java io 比較基本的一些處理流，除此之外我們還會提到一些比較深入的基於io的處理類，比如console類，SteamTokenzier,Externalizable接口，Serializable接口等等一些高級用法極其原理。

一、Java io的開始：文件

1. 我們主要講的是流，流的本質也是對文件的處理，我們循序漸進一步一步從文件將到流去。

2. java 處理文件的類 File,java提供了十分詳細的文件處理方法，舉了其中幾個例子，其余的可以去

Java代碼 技術分享
  1. package com.hxw.io;
  2. import java.io.*;
  4. public class FileExample{
  5. public static void main(String[] args) {
  7. createFile();
  8. }
  10. /**
  11. * 文件處理示例
  12. */
  13. public static void createFile() {
  14. File f=new File("E:/電腦桌面/jar/files/create.txt");
  15. try{
  16. f.createNewFile(); //當且僅當不存在具有此抽象路徑名指定名稱的文件時，不可分地創建一個新的空文件。
  17. System.out.println("該分區大小"+f.getTotalSpace()/(1024*1024*1024)+"G"); //返回由此抽象路徑名表示的文件或目錄的名稱。
  18. f.mkdirs(); //創建此抽象路徑名指定的目錄，包括所有必需但不存在的父目錄。
  19. // f.delete(); // 刪除此抽象路徑名表示的文件或目錄
  20. System.out.println("文件名 "+f.getName()); // 返回由此抽象路徑名表示的文件或目錄的名稱。
  21. System.out.println("文件父目錄字符串 "+f.getParent());// 返回此抽象路徑名父目錄的路徑名字符串；如果此路徑名沒有指定父目錄，則返回 null。
  23. }catch (Exception e) {
  24. e.printStackTrace();
  25. }
  26. }
  27. }



二、字節流:

1.字節流有輸入和輸出流，我們首先看輸入流InputStream,我們首先解析一個例子（FileInputStream）。

Java代碼 技術分享
  1. package com.hxw.io;
  2. import java.io.File;
  3. import java.io.FileInputStream;
  4. import java.io.IOException;
  5. import java.io.InputStream;
  6. public class FileCount {
  7. /**
  8. * 我們寫一個檢測文件長度的小程序，別看這個程序挺長的，你忽略try catch塊後發現也就那麽幾行而已。
  9. */
  10. publicstatic void main(String[] args) {
  11. //TODO 自動生成的方法存根
  12. int count=0; //統計文件字節長度
  13. InputStreamstreamReader = null; //文件輸入流
  14. try{
  15. streamReader=newFileInputStream(new File("D:/David/Java/java 高級進階/files/tiger.jpg"));
  16. /*1.new File()裏面的文件地址也可以寫成D:\\David\\Java\\java 高級進階\\files\\tiger.jpg,前一個\是用來對後一個
  17. * 進行轉換的，FileInputStream是有緩沖區的，所以用完之後必須關閉，否則可能導致內存占滿，數據丟失。
  18. */
  19. while(streamReader.read()!=-1) { //讀取文件字節，並遞增指針到下一個字節
  20. count++;
  21. }
  22. System.out.println("---長度是： "+count+" 字節");
  23. }catch (final IOException e) {
  24. //TODO 自動生成的 catch 塊
  25. e.printStackTrace();
  26. }finally{
  27. try{
  28. streamReader.close();
  29. }catch (IOException e) {
  30. //TODO 自動生成的 catch 塊
  31. e.printStackTrace();
  32. }
  33. }
  34. }
  36. }



我們一步一步來，首先，上面的程序存在問題是，每讀取一個自己我都要去用到FileInputStream，我輸出的結果是“---長度是： 64982 字節”，那麽進行了64982次操作！可能想象如果文件十分龐大，這樣的操作肯定會出大問題，所以引出了緩沖區的概念。可以將streamReader.read()改成streamReader.read(byte[]b)此方法讀取的字節數目等於字節數組的長度，讀取的數據被存儲在字節數組中，返回讀取的字節數，InputStream還有其他方法mark,reset,markSupported方法，例如：

markSupported 判斷該輸入流能支持mark 和 reset 方法。

mark用於標記當前位置；在讀取一定數量的數據(小於readlimit的數據)後使用reset可以回到mark標記的位置。

FileInputStream不支持mark/reset操作；BufferedInputStream支持此操作；

mark(readlimit)的含義是在當前位置作一個標記，制定可以重新讀取的最大字節數，也就是說你如果標記後讀取的字節數大於readlimit，你就再也回不到回來的位置了。

通常InputStream的read()返回-1後，說明到達文件尾，不能再讀取。除非使用了mark/reset。

2.FileOutputStream 循序漸進版， InputStream是所有字節輸出流的父類，子類有ByteArrayOutputStream,FileOutputStream,ObjectOutputStreanm,這些我們在後面都會一一說到。先說FileOutputStream

我以一個文件復制程序來說，順便演示一下緩存區的使用。(Java I/O默認是不緩沖流的，所謂“緩沖”就是先把從流中得到的一塊字節序列暫存在一個被稱為buffer的內部字節數組裏，然後你可以一下子取到這一整塊的字節數據，沒有緩沖的流只能一個字節一個字節讀，效率孰高孰低一目了然。有兩個特殊的輸入流實現了緩沖功能，一個是我們常用的BufferedInputStream.)

Java代碼 技術分享
  1. package com.hxw.io;
  2. import java.io.*;
  4. public class FileCopy {
  6. public static void main(String[] args) {
  7. // TODO自動生成的方法存根
  8. byte[] buffer=new byte[512]; //一次取出的字節數大小,緩沖區大小
  9. int numberRead=0;
  10. FileInputStream input=null;
  11. FileOutputStream out =null;
  12. try {
  13. input=new FileInputStream("D:/David/Java/java 高級進階/files/tiger.jpg");
  14. out=new FileOutputStream("D:/David/Java/java 高級進階/files/tiger2.jpg"); //如果文件不存在會自動創建
  16. while ((numberRead=input.read(buffer))!=-1) { //numberRead的目的在於防止最後一次讀取的字節小於buffer長度，
  17. out.write(buffer, 0, numberRead); //否則會自動被填充0
  18. }
  19. } catch (final IOException e) {
  20. // TODO自動生成的 catch 塊
  21. e.printStackTrace();
  22. }finally{
  23. try {
  24. input.close();
  25. out.close();
  26. } catch (IOException e) {
  27. // TODO自動生成的 catch 塊
  28. e.printStackTrace();
  29. }
  31. }
  32. }
  34. }

3.讀寫對象：ObjectInputStream 和ObjectOutputStream ，該流允許讀取或寫入用戶自定義的類，但是要實現這種功能，被讀取和寫入的類必須實現Serializable接口，其實該接口並沒有什麽方法，可能相當於一個標記而已，但是確實不合缺少的。實例代碼如下：

Java代碼 技術分享
  1. package com.hxw.io;
  3. import java.io.*;
  5. public class ObjetStream {
  7. /**
  8. * @param args
  9. */
  10. public static void main(String[] args) {
  11. // TODO自動生成的方法存根
  12. ObjectOutputStream objectwriter=null;
  13. ObjectInputStream objectreader=null;
  15. try {
  16. objectwriter=new ObjectOutputStream(new FileOutputStream("D:/David/Java/java 高級進階/files/student.txt"));
  17. objectwriter.writeObject(new Student("gg", 22));
  18. objectwriter.writeObject(new Student("tt", 18));
  19. objectwriter.writeObject(new Student("rr", 17));
  20. objectreader=new ObjectInputStream(new FileInputStream("D:/David/Java/java 高級進階/files/student.txt"));
  21. for (int i = 0; i < 3; i++) {
  22. System.out.println(objectreader.readObject());
  23. }
  24. } catch (IOException | ClassNotFoundException e) {
  25. // TODO自動生成的 catch 塊
  26. e.printStackTrace();
  27. }finally{
  28. try {
  29. objectreader.close();
  30. objectwriter.close();
  31. } catch (IOException e) {
  32. // TODO自動生成的 catch 塊
  33. e.printStackTrace();
  34. }
  36. }
  38. }
  40. }
  41. class Student implements Serializable{
  42. private String name;
  43. private int age;
  45. public Student(String name, int age) {
  46. super();
  47. this.name = name;
  48. this.age = age;
  49. }
  51. @Override
  52. public String toString() {
  53. return "Student [name=" + name + ", age=" + age + "]";
  54. }
  57. }



運行後系統輸出：

Student [name=gg, age=22]

Student [name=tt, age=18]

Student [name=rr, age=17]

4.有時沒有必要存儲整個對象的信息，而只是要存儲一個對象的成員數據，成員數據的類型假設都是Java的基本數據類型，這樣的需求不必使用到與Object輸入、輸出相關的流對象，可以使用DataInputStream、DataOutputStream來寫入或讀出數據。下面是一個例子：（DataInputStream的好處在於在從文件讀出數據時，不用費心地自行判斷讀入字符串時或讀入int類型時何時將停止，使用對應的readUTF()和readInt()方法就可以正確地讀入完整的類型數據。）

Java代碼 技術分享
  1. package com.hxw;
  2. public class Member {
  3. private String name;
  4. private int age;
  5. public Member() {
  6. }
  7. public Member(String name, int age) {
  8. this.name = name;
  9. this.age = age;
  10. }
  11. public void setName(String name){
  12. this.name = name;
  13. }
  14. public void setAge(int age) {
  15. this.age = age;
  16. }
  17. public String getName() {
  18. return name;
  19. }
  20. public int getAge() {
  21. return age;
  22. }
  23. }



打算將Member類實例的成員數據寫入文件中，並打算在讀入文件數據後，將這些數據還原為Member對象。下面的代碼簡單示範了如何實現這個需求。

Java代碼 技術分享
  1. package com.hxw;
  2. import java.io.*;
  3. public class DataStreamDemo
  4. {
  5. public static void main(String[]args)
  6. {
  7. Member[] members = {newMember("Justin",90),
  8. newMember("momor",95),
  9. newMember("Bush",88)};
  10. try
  11. {
  12. DataOutputStreamdataOutputStream = new DataOutputStream(new FileOutputStream(args[0]));
  14. for(Member member:members)
  15. {
  16. //寫入UTF字符串
  17. dataOutputStream.writeUTF(member.getName());
  18. //寫入int數據
  19. dataOutputStream.writeInt(member.getAge());
  20. }
  22. //所有數據至目的地
  23. dataOutputStream.flush();
  24. //關閉流
  25. dataOutputStream.close();
  27. DataInputStreamdataInputStream = new DataInputStream(new FileInputStream(args[0]));
  29. //讀出數據並還原為對象
  30. for(inti=0;i<members.length;i++)
  31. {
  32. //讀出UTF字符串
  33. String name =dataInputStream.readUTF();
  34. //讀出int數據
  35. int score =dataInputStream.readInt();
  36. members[i] = newMember(name,score);
  37. }
  39. //關閉流
  40. dataInputStream.close();
  42. //顯示還原後的數據
  43. for(Member member : members)
  44. {
  45. System.out.printf("%s\t%d%n",member.getName(),member.getAge());
  46. }
  47. }
  48. catch(IOException e)
  49. {
  50. e.printStackTrace();
  51. }
  52. }
  53. }



5.PushbackInputStream類繼承了FilterInputStream類是iputStream類的修飾者。提供可以將數據插入到輸入流前端的能力(當然也可以做其他操作)。簡而言之PushbackInputStream類的作用就是能夠在讀取緩沖區的時候提前知道下一個字節是什麽，其實質是讀取到下一個字符後回退的做法，這之間可以進行很多操作，這有點向你把讀取緩沖區的過程當成一個數組的遍歷，遍歷到某個字符的時候可以進行的操作，當然，如果要插入，能夠插入的最大字節數是與推回緩沖區的大小相關的，插入字符肯定不能大於緩沖區吧！下面是一個示例。

Java代碼 技術分享
  1. package com.hxw.io;
  3. import java.io.ByteArrayInputStream; //導入ByteArrayInputStream的包
  4. import java.io.IOException;
  5. import java.io.PushbackInputStream;
  7. /**
  8. * 回退流操作
  9. * */
  10. public class PushBackInputStreamDemo {
  11. public static void main(String[] args) throws IOException {
  12. String str = "hello,rollenholt";
  13. PushbackInputStream push = null; // 聲明回退流對象
  14. ByteArrayInputStream bat = null; // 聲明字節數組流對象
  15. bat = new ByteArrayInputStream(str.getBytes());
  16. push = new PushbackInputStream(bat); // 創建回退流對象，將拆解的字節數組流傳入
  17. int temp = 0;
  18. while ((temp = push.read()) != -1) { // push.read()逐字節讀取存放在temp中，如果讀取完成返回-1
  19. if (temp == ‘,‘) { // 判斷讀取的是否是逗號
  20. push.unread(temp); //回到temp的位置
  21. temp = push.read(); //接著讀取字節
  22. System.out.print("(回退" + (char) temp + ") "); // 輸出回退的字符
  23. } else {
  24. System.out.print((char) temp); // 否則輸出字符
  25. }
  26. }
  27. }
  28. }



6.SequenceInputStream:有些情況下，當我們需要從多個輸入流中向程序讀入數據。此時，可以使用合並流，將多個輸入流合並成一個SequenceInputStream流對象。SequenceInputStream會將與之相連接的流集組合成一個輸入流並從第一個輸入流開始讀取，直到到達文件末尾，接著從第二個輸入流讀取，依次類推，直到到達包含的最後一個輸入流的文件末尾為止。 合並流的作用是將多個源合並合一個源。其可接收枚舉類所封閉的多個字節流對象。

Java代碼 技術分享
  1. package com.hxw.io;
  3. import java.io.*;
  4. import java.util.Enumeration;
  5. import java.util.Vector;
  7. public class SequenceInputStreamTest {
  8. /**
  9. * @param args
  10. * SequenceInputStream合並流，將與之相連接的流集組合成一個輸入流並從第一個輸入流開始讀取，
  11. * 直到到達文件末尾，接著從第二個輸入流讀取，依次類推，直到到達包含的最後一個輸入流的文件末尾為止。
  12. * 合並流的作用是將多個源合並合一個源。可接收枚舉類所封閉的多個字節流對象。
  13. */
  14. public static void main(String[] args) {
  15. doSequence();
  16. }
  18. private static void doSequence() {
  19. // 創建一個合並流的對象
  20. SequenceInputStream sis = null;
  21. // 創建輸出流。
  22. BufferedOutputStream bos = null;
  23. try {
  24. // 構建流集合。
  25. Vector<InputStream> vector = new Vector<InputStream>();
  26. vector.addElement(new FileInputStream("D:\text1.txt"));
  27. vector.addElement(new FileInputStream("D:\text2.txt"));
  28. vector.addElement(new FileInputStream("D:\text3.txt"));
  29. Enumeration<InputStream> e = vector.elements();
  31. sis = new SequenceInputStream(e);
  33. bos = new BufferedOutputStream(new FileOutputStream("D:\text4.txt"));
  34. // 讀寫數據
  35. byte[] buf = new byte[1024];
  36. int len = 0;
  37. while ((len = sis.read(buf)) != -1) {
  38. bos.write(buf, 0, len);
  39. bos.flush();
  40. }
  41. } catch (FileNotFoundException e1) {
  42. e1.printStackTrace();
  43. } catch (IOException e1) {
  44. e1.printStackTrace();
  45. } finally {
  46. try {
  47. if (sis != null)
  48. sis.close();
  49. } catch (IOException e) {
  50. e.printStackTrace();
  51. }
  52. try {
  53. if (bos != null)
  54. bos.close();
  55. } catch (IOException e) {
  56. e.printStackTrace();
  57. }
  58. }
  59. }
  60. }



7.PrintStream 說這個名字可能初學者不熟悉，如果說System.out.print()你肯定熟悉，System.out這個對象就是PrintStream，這個我們不做過多示例

三、字符流（顧名思義，就是操作字符文件的流）

1.java 使用Unicode存儲字符串，在寫入字符流時我們都可以指定寫入的字符串的編碼。前面介紹了不用拋異常的處理字節型數據的流ByteArrayOutputStream，與之對應的操作字符類的類就是CharArrayReader,CharArrayWriter類，這裏也會用到緩沖區，不過是字符緩沖區，一般講字符串放入到操作字符的io流一般方法是

CharArrayReaderreader=mew CharArrayReader(str.toCharArray()); 一旦會去到CharArrayReader實例就可以使用CharArrayReader訪問字符串的各個元素以執行進一步讀取操作。不做例子

2.我們用FileReader ，PrintWriter來做示範

Java代碼 技術分享
  1. package com.hxw.io;
  3. import java.io.FileNotFoundException;
  4. import java.io.FileReader;
  5. import java.io.IOException;
  6. import java.io.PrintWriter;
  7. import java.nio.CharBuffer;
  9. public class Print {
  11. /**
  12. * @param args
  13. */
  14. public static void main(String[] args) {
  15. // TODO自動生成的方法存根
  16. char[] buffer=new char[512]; //一次取出的字節數大小,緩沖區大小
  17. int numberRead=0;
  18. FileReader reader=null; //讀取字符文件的流
  19. PrintWriter writer=null; //寫字符到控制臺的流
  21. try {
  22. reader=new FileReader("D:/David/Java/java 高級進階/files/copy1.txt");
  23. writer=new PrintWriter(System.out); //PrintWriter可以輸出字符到文件，也可以輸出到控制臺
  24. while ((numberRead=reader.read(buffer))!=-1) {
  25. writer.write(buffer, 0, numberRead);
  26. }
  27. } catch (IOException e) {
  28. // TODO自動生成的 catch 塊
  29. e.printStackTrace();
  30. }finally{
  31. try {
  32. reader.close();
  33. } catch (IOException e) {
  34. // TODO自動生成的 catch 塊
  35. e.printStackTrace();
  36. }
  37. writer.close(); //這個不用拋異常
  38. }
  40. }
  42. }



3.相對我們前面的例子是直接用FileReader打開的文件，我們這次使用鏈接流，一般比較常用的都用鏈接流，所謂鏈接流就是就多次對流的封裝，這樣能更好的操作個管理數據，（比如我們利用DataInputStream（BufferedInputStream(FileInputStream)）將字節流層層包裝後，我們可以讀取readByte(),readChar()這樣更加具體的操作，註意，該流屬於字節流對字符進行操作，）字符流用CharArrayReader就可以了。下面的示例我們將用到j2se 5中的一個可變參數進行一個小度擴展。使用BufferedWriter 和BufferedReader用文件級聯的方式進行寫入，即將多個文件寫入到同一文件中（自帶緩沖區的輸出輸出流BufferedReader和BufferedWriter,該流最常用的屬readLine()方法了，讀取一行數據，並返回String）。

Java代碼 技術分享
  1. package com.hxw.io;
  3. import java.io.BufferedReader;
  4. import java.io.BufferedWriter;
  5. import java.io.FileReader;
  6. import java.io.FileWriter;
  7. import java.io.IOException;
  8. import java.util.Iterator;
  10. public class FileConcatenate {
  12. /**
  13. * 包裝類進行文件級聯操作
  14. */
  15. public static void main(String[] args) {
  16. // TODO自動生成的方法存根
  17. try {
  18. concennateFile(args);
  19. } catch (IOException e) {
  20. // TODO自動生成的 catch 塊
  21. e.printStackTrace();
  22. }
  23. }
  24. public static voidconcennateFile(String...fileName) throws IOException{
  25. String str;
  26. //構建對該文件您的輸入流
  27. BufferedWriter writer=new BufferedWriter(new FileWriter("D:/David/Java/java 高級進階/files/copy2.txt"));
  28. for(String name: fileName){
  29. BufferedReader reader=new BufferedReader(new FileReader(name));
  31. while ((str=reader.readLine())!=null) {
  32. writer.write(str);
  33. writer.newLine();
  34. }
  35. }
  36. }
  38. }



4.Console類,該類提供了用於讀取密碼的方法，可以禁止控制臺回顯並返回char數組，對兩個特性對保證安全有作用，平時用的不多，了解就行。

5.StreamTokenizer 類，這個類非常有用，它可以把輸入流解析為標記（token）, StreamTokenizer 並非派生自InputStream或者OutputStream，而是歸類於io庫中，因為StreamTokenizer只處理InputStream對象。

首先給出我的文本文件內容：

‘水上漂‘

青青草

"i love wyhss"

{3211}

23223 3523

i love wyh ，。

. ,

下面是代碼：

Java代碼 技術分享
  1. package com.hxw.io;
  2. import java.io.BufferedReader;
  3. import java.io.FileReader;
  4. import java.io.IOException;
  5. import java.io.StreamTokenizer;
  7. /**
  8. * 使用StreamTokenizer來統計文件中的字符數
  9. * StreamTokenizer 類獲取輸入流並將其分析為“標記”，允許一次讀取一個標記。
  10. * 分析過程由一個表和許多可以設置為各種狀態的標誌控制。
  11. * 該流的標記生成器可以識別標識符、數字、引用的字符串和各種註釋樣式。
  12. *
  13. * 默認情況下，StreamTokenizer認為下列內容是Token: 字母、數字、除C和C++註釋符號以外的其他符號。
  14. * 如符號"/"不是Token，註釋後的內容也不是，而"\"是Token。單引號和雙引號以及其中的內容，只能算是一個Token。
  15. * 統計文章字符數的程序，不是簡單的統計Token數就萬事大吉，因為字符數不等於Token。按照Token的規定，
  16. * 引號中的內容就算是10頁也算一個Token。如果希望引號和引號中的內容都算作Token，應該調用下面的代碼：
  17. * st.ordinaryChar(‘\‘‘);
  18. * st.ordinaryChar(‘\"‘);
  19. */
  20. public class StreamTokenizerExample {
  22. /**
  23. * 統計字符數
  24. * @param fileName 文件名
  25. * @return 字符數
  26. */
  27. public static void main(String[] args) {
  28. String fileName = "D:/David/Java/java 高級進階/files/copy1.txt";
  29. StreamTokenizerExample.statis(fileName);
  30. }
  31. public static long statis(String fileName) {
  33. FileReader fileReader = null;
  34. try {
  35. fileReader = new FileReader(fileName);
  36. //創建分析給定字符流的標記生成器
  37. StreamTokenizer st = new StreamTokenizer(new BufferedReader(
  38. fileReader));
  40. //ordinaryChar方法指定字符參數在此標記生成器中是“普通”字符。
  41. //下面指定單引號、雙引號和註釋符號是普通字符
  42. st.ordinaryChar(‘\‘‘);
  43. st.ordinaryChar(‘\"‘);
  44. st.ordinaryChar(‘/‘);
  46. String s;
  47. int numberSum = 0;
  48. int wordSum = 0;
  49. int symbolSum = 0;
  50. int total = 0;
  51. //nextToken方法讀取下一個Token.
  52. //TT_EOF指示已讀到流末尾的常量。
  53. while (st.nextToken() !=StreamTokenizer.TT_EOF) {
  54. //在調用 nextToken 方法之後，ttype字段將包含剛讀取的標記的類型
  55. switch (st.ttype) {
  56. //TT_EOL指示已讀到行末尾的常量。
  57. case StreamTokenizer.TT_EOL:
  58. break;
  59. //TT_NUMBER指示已讀到一個數字標記的常量
  60. case StreamTokenizer.TT_NUMBER:
  61. //如果當前標記是一個數字，nval字段將包含該數字的值
  62. s = String.valueOf((st.nval));
  63. System.out.println("數字有："+s);
  64. numberSum ++;
  65. break;
  66. //TT_WORD指示已讀到一個文字標記的常量
  67. case StreamTokenizer.TT_WORD:
  68. //如果當前標記是一個文字標記，sval字段包含一個給出該文字標記的字符的字符串
  69. s = st.sval;
  70. System.out.println("單詞有： "+s);
  71. wordSum ++;
  72. break;
  73. default:
  74. //如果以上3中類型都不是，則為英文的標點符號
  75. s = String.valueOf((char) st.ttype);
  76. System.out.println("標點有： "+s);
  77. symbolSum ++;
  78. }
  79. }
  80. System.out.println("數字有 " + numberSum+"個");
  81. System.out.println("單詞有 " + wordSum+"個");
  82. System.out.println("標點符號有： " + symbolSum+"個");
  83. total = symbolSum + numberSum +wordSum;
  84. System.out.println("Total = " + total);
  85. return total;
  86. } catch (Exception e) {
  87. e.printStackTrace();
  88. return -1;
  89. } finally {
  90. if (fileReader != null) {
  91. try {
  92. fileReader.close();
  93. } catch (IOException e1) {
  94. }
  95. }
  96. }
  97. }
  100. }



運行結果為：

標點有： ‘

單詞有： 水上漂

標點有： ‘

單詞有： 青青草

標點有： "

單詞有： i

單詞有： love

單詞有： wyh

單詞有： ss

標點有： "

標點有： {

數字有：3211.0

標點有： }

數字有：23223.0

數字有：35.23

單詞有： i

單詞有： love

單詞有： wyh

單詞有： ，。

數字有：0.0

標點有： ,

數字有 4個

單詞有 10個

標點符號有： 7個

Total= 21

我們從其中可以看到很多東西：

1.一個單獨的小數點“.”是被當做一個數字來對待的，數字的值為0.0；

2.一串漢字只要中間沒有符號（空格回車 分號等等）都是被當做一個單詞的。中文的標點跟中文的漢字一樣處理

3.如果不對引號化成普通字符，一個引號內的內容不論多少都被當做是一個標記。

4.該類能夠識別英文標點

5. java io裏面還有其他接口類似Serializable接口的子接口Externalizable接口，比Serializable復雜一些，這裏不再介紹。還有關於java對象版本化的東西感興趣的可以百度。java nio的東西這裏沒有涉及，後續會結合到線程再發一篇文章專門解析這個東西。

學習Java的同學註意了！！！

學習過程中遇到什麽問題或者想獲取學習資源的話，歡迎加入Java學習交流群，群號碼：618528494 我們一起學Java！

Java IO詳解

相關推薦

Java IO詳解

amr mst 數據丟失 網上 ria break idc png 字符串 學習Java的同學註意了！！！ 學習過程中遇到什麽問題或者想獲取學習資源的話，歡迎加入Java學習交流群，群號碼：618528494 我們一起學Java！ 初學Java，一直搞不懂Java裏

[紙上談兵]Java IO詳解(四) Reactor模式

一、 Reactor中文解釋 Reactor模式翻譯成中文有的說是反應器，有的說是反應堆模式。 中文解釋 反應：因為事件所引發的迴應。名詞. 器： 容器, 例如:用來存放水之類的物體. 堆:   例如: 土堆.可以理解為土彙集到一起。 那麼 反應器：這個我個人理解，存放反應的容器

[紙上談兵]Java IO詳解(三)NIO

一、概述 Java NIO 一種基於通道和緩衝區的 I/O 方式，它可以使用Native函式庫直接分配堆外記憶體，然後通過一個儲存在 Java 堆的 DirectByteBuffer 物件作為這塊記憶體的引用進行操作，避免了在Java堆和Native堆中來回複製資料。 Java NIO是一種同步

[紙上談兵]Java IO詳解(二)BIO

一、java io分類 java io目前包括了BIO(同步阻塞),NIO(同步非阻塞),AIO(非同步非阻塞)三種。如果不太瞭解同步、非同步、阻塞、非阻塞，看我前面的文章 二、JAVA BIO BIO比較簡單，我先簡單說一下socket中關於埠的兩個方法。 socket.getLo

[紙上談兵]Java IO詳解(一)基礎

宣告：這個文章只是從其他文章抄過來加上自己的理解組成的文章。可能會存在各種問題，還請指正. 關於IO這塊，對於我來講一直是個知識肓區，尤其在同步、非同步、阻塞、非阻塞這塊，有一點認識，但很不清晰，所以寫這篇文章，它不能讓我100%理解，但我希望以後可以在這個文章基礎上繼續加深對io的理解. 一、作業

Java IO詳解（三)------位元組輸入輸出流

那麼這篇部落格我們講的是位元組輸入輸出流：InputStream、OutputSteam(下圖紅色長方形框內)，紅色橢圓框內是其典型實現（FileInputSteam、FileOutStream） 　　    1、位元組輸出流：OutputStream

Java IO詳解（六)------序列化與反序列化（物件流）

1、什麼是序列化與反序列化？ 序列化：指把堆記憶體中的 Java 物件資料，通過某種方式把物件儲存到磁碟檔案中或者傳遞給其他網路節點（在網路上傳輸）。這個過程稱為序列化。通俗來說就是將資料結構或物件轉換成二進位制串的過程 　　反序列化：把磁碟檔案中

java io詳解六：序列化與反序列化（物件流）

1、什麼是序列化與反序列化？ 　　序列化：指把堆記憶體中的 Java 物件資料，通過某種方式把物件儲存到磁碟檔案中或者傳遞給其他網路節點（在網路上傳輸）。這個過程稱為序列化。通俗來說就是將資料結構或物件轉換成二進位制串的過程 　　反序列化：把磁碟檔案中的物件資料或者把網路節點上的物件資料，恢

java io詳解四：字元輸入輸出流

那麼這篇部落格我們講的是位元組輸入輸出流：Reader、Writer(下圖紅色長方形框內)，紅色橢圓框內是其典型實現（FileReader、FileWriter） 　　 ①、為什麼要使用字元流？ 　　因為使用位元組流操作漢字或特殊符號語言的時候容易亂碼，因為漢字不止一個位元組，為了解決這

java io詳解三：位元組輸入輸出流

這篇部落格我們講的是位元組輸入輸出流：InputStream、OutputSteam(下圖紅色長方形框內)，紅色橢圓框內是其典型實現（FileInputSteam、FileOutStream） 　　    1、位元組輸出流：OutputStream

java io詳解二：流的分類

一、根據流向分為輸入流和輸出流： 　　注意輸入流和輸出流是相對於程式而言的。 　　輸出：把程式(記憶體)中的內容輸出到磁碟、光碟等儲存裝置中 　　　　        輸入：讀取外部資料（磁碟、光碟等儲存裝置的資料）到程式（記憶體）中 　

java io詳解一：File類

File 類：檔案和目錄路徑名的抽象表示。 注意：File 類只能操作檔案的屬性，檔案的內容是不能操作的。   1、File 類的欄位   　　我們知道，各個平臺之間的路徑分隔符是不一樣的。 　　①、對於UNIX平臺，絕對路徑名的字首始終為"/" 。

java io詳解五：包裝流

我們在 Java IO 流的分類介紹  這篇部落格中介紹知道： 　　根據功能分為節點流和包裝流（處理流） 　　　　節點流：可以從或向一個特定的地方(節點)讀寫資料。如FileReader. 　　　　處理流：是對一個已存在的流的連線和封裝，通過所封裝的流的功能呼叫實現資料讀寫。如

Java IO詳解（兩種設計模式的分析）

一。引子（概括地介紹Java的ＩＯ） 　　無論是哪種程式語言，輸入跟輸出都是重要的一部分，Java也不例外，而且Java將輸入／輸出的功能和使用範疇做了很大的擴充。它採用了流的 機制來實現輸入／輸出，所謂流，就是資料的有序排列，而流可以是從某個源（稱為流源或Source

【Java基礎之五】Java中IO詳解

1.Java IO簡介 可能學過計算機組裝與維修的同學都知道I/O裝置，翻譯過來也就是Input/Output（輸入輸出裝置），在硬體中鍵盤、滑鼠 屬於 輸入裝置，顯示器、印表機等屬於輸出裝置，這裡輸入輸出參考物是計算機本身。 java.io包從巨集觀上來

java io 層次結構圖 io詳解

Java中IO結構總圖 Java 流在處理上分為字元流和位元組流。字元流處理的單元為 2 個位元組的 Unicode 字元，分別操作字元、字元陣列或字串，而位元組流處理單元為 1 個位元組，操作位元組和位元組陣列。 Java 內用 Unicode 編碼儲

java final詳解

inline mon 技術 但是 common src strac 都是 機制 final關鍵字 可用於聲明屬性、方法、和類 final類： final 類 不可被繼承，沒有子類，包括其中的方法默認都是final方法； final 類的方法不可被重寫，但是其中沒有被f

Java synchronized詳解

ret 內置 etc 優先權 one lan string 作用域 靜態成員函數 轉自：http://www.cnblogs.com/devinzhang/archive/2011/12/14/2287675.html 第一篇： 使用synchronized 在編寫一個

Java 反射詳解

什麽 tco type 性能 bob 參數 bject 今天 erl 　　反射反射，程序員的快樂，今天你快樂了嗎？如果你不快樂，沒關系，接下來讓你快樂起來！ 一、什麽是反射？　　通過百度百科我們可以知道，Java反射就是在運行狀態中，對於任意一個類，都能夠知道這個類的所有屬

Java代理詳解

.get tle 理由 總結 ins 創建 set ota ble 一、概述 　　代理模式是Java常用的設計模式之一，實現代理模式要求代理類和委托類(被代理的類)具有相同的方法(提供相同的服務)，代理類對象自身並不實現真正的核心邏輯，而是通過調用委托類對象的相關方法來處