風(fēng)之語

調(diào)整 Java I/O 性能

這篇文章討論和闡明了提供 JavaTM I/O 性能的多種技術(shù)。大多技術(shù)圍繞調(diào)整磁盤文件 I/O,但是有些內(nèi)容也同樣適合網(wǎng)絡(luò) I/O 和窗口輸出。第一部分技術(shù)討論底層的I/O問題，然后討論諸如壓縮，格式化和串行化等高級I/O問題。然而這個(gè)討論沒有包含應(yīng)用設(shè)計(jì)問題，例如搜索算法和數(shù)據(jù)結(jié)構(gòu)，也沒有討論系統(tǒng)級的問題，例如文件高速緩沖。 

當(dāng)我們討論Java I/O時(shí),值得注意的是Java語言采取兩種截然不同的磁盤文件結(jié)構(gòu)。一個(gè)是基于字節(jié)流，另一個(gè)是字符序列。在Java語言中一個(gè)字符有兩個(gè)字節(jié)表示，而不是像通常的語言如c語言那樣是一個(gè)字節(jié)。因此，從一個(gè)文件讀取字符時(shí)需要進(jìn)行轉(zhuǎn)換。這個(gè)不同在某些情況下是很重要的，就像下面的幾個(gè)例子將要展示的那樣。 

低級 I/O I問題

加速I/O的基本規(guī)則 
緩沖 
讀寫文本文件 
格式化的代價(jià) 
隨機(jī)訪問 
高級I/O問題

壓縮 
高速緩沖 
分解 
串行化 
獲取文件信息 
更多信息 
加速I/O的基本規(guī)則

作為這個(gè)討論的開始，這里有幾個(gè)如何加速I/O的基本規(guī)則: 

避免訪問磁盤 
避免訪問底層的操作系統(tǒng) 
避免方法調(diào)用 
避免個(gè)別的處理字節(jié)和字符 
很明顯這些規(guī)則不能在所有的問題上避免，因?yàn)槿绻軌虻脑捑蜎]有實(shí)際的I/O被執(zhí)行。考慮下面的計(jì)算文件中的新行符('\n')的三部分范例。 

方法1: 讀方法
第一個(gè)方法簡單的使用FileInputStream的read方法: 



 import java.io.*;
  
  public class intro1 {
    public static void main(String args[]) {
      if (args.length != 1) {
        System.err.println("missing filename");
        System.exit(1);
      }
      try {
        FileInputStream fis =
            new FileInputStream(args[0]);
        int cnt = 0;
        int b;
        while ((b = fis.read()) != -1) {
          if (b == '\n')
            cnt++;
        }
        fis.close();
        System.out.println(cnt);
      }
      catch (IOException e) {
        System.err.println(e);
      }
    }
  }

然而這個(gè)方法觸發(fā)了大量的底層運(yùn)行時(shí)系統(tǒng)調(diào)用－－FileInputStream.read－－返回文件的下一個(gè)字節(jié)的本機(jī)方法。 
方法 2: 使用大緩沖區(qū)
第二種方法使用大緩沖區(qū)避免了上面的問題: 

 

import java.io.*;
  
 public class intro2 {
   public static void main(String args[]) {
    if (args.length != 1) {
      System.err.println("missing filename");
      System.exit(1);
    }
    try {
      FileInputStream fis =
          new FileInputStream(args[0]);
      BufferedInputStream bis =
          new BufferedInputStream(fis);
      int cnt = 0;
      int b;
      while ((b = bis.read()) != -1) {
        if (b == '\n')
          cnt++;
        }
      bis.close();
      System.out.println(cnt);
    }
    catch (IOException e) {
      System.err.println(e);
    }
  }
 }

BufferedInputStream.read 從輸入緩沖區(qū)獲取下一個(gè)字節(jié)，僅僅只訪問了一次底層系統(tǒng)。 
方法 3: 直接緩沖
第三種方法避免使用 BufferedInputStream 而直接緩沖，因此排除了 read 方法的調(diào)用: 



 import java.io.*;
  
  public class intro3 {
    public static void main(String args[]) {
      if (args.length != 1) {
        System.err.println("missing filename");
        System.exit(1);
      }
      try {
        FileInputStream fis =
            new FileInputStream(args[0]);
        byte buf[] = new byte[2048];
        int cnt = 0;
        int n;
        while ((n = fis.read(buf)) != -1) {
          for (int i = 0; i < n; i++) {
            if (buf[i] == '\n')
              cnt++;
          }
        }
        fis.close();
        System.out.println(cnt);
      }
      catch (IOException e) {
        System.err.println(e);
      }
    }
  }

對于一個(gè)1 MB 的輸入文件，以秒為單位的執(zhí)行時(shí)間是: 

 
 intro1    6.9
 intro2    0.9
 intro3    0.4

或者說在最慢的方法和最快的方法間是17比1的不同。 

這個(gè)巨大的加速并不能證明你應(yīng)該總是使用第三種方法，即自己做緩沖。這可能是一個(gè)錯(cuò)誤的傾向特別是在處理文件結(jié)束事件時(shí)沒有仔細(xì)的實(shí)現(xiàn)。在可讀性上它也沒有其它方法好。但是記住時(shí)間花費(fèi)在哪兒了以及在必要的時(shí)候如何矯正是很有用。 

方法2 或許是對于大多應(yīng)用的 "正確" 方法. 

緩沖

方法 2 和 3 使用了緩沖技術(shù), 大塊文件被從磁盤讀取，然后每次訪問一個(gè)字節(jié)或字符。緩沖是一個(gè)基本而重要的加速I/O 的技術(shù),而且有幾個(gè)類支持緩沖(BufferedInputStream 用于字節(jié), BufferedReader 用于字符)。 

一個(gè)明顯得問題是: 緩沖區(qū)越大I/O越快嗎？典型的Java緩沖區(qū)長1024 或者 2048 字節(jié)，一個(gè)更大的緩沖區(qū)有可能加速 I/O但是只能占很小的比重，大約5 到10%。 

方法4: 整個(gè)文件
緩沖的極端情況是事先決定整個(gè)文件的長度，然后讀取整個(gè)文件: 



  import java.io.*;
  
  public class readfile {
    public static void main(String args[]) {
      if (args.length != 1) {
        System.err.println("missing filename");
        System.exit(1);
      }
      try {
        int len = (int)(new File(args[0]).length());
        FileInputStream fis =
            new FileInputStream(args[0]);
        byte buf[] = new byte[len];
        fis.read(buf);
        fis.close();
        int cnt = 0;
        for (int i = 0; i < len; i++) {
          if (buf[i] == '\n')
            cnt++;
        }
        System.out.println(cnt);
      }
      catch (IOException e) {
        System.err.println(e);
      }
    }
  }

這個(gè)方法很方便，在這里文件被當(dāng)作一個(gè)字節(jié)數(shù)組。但是有一個(gè)明顯得問題是有可能沒有讀取一個(gè)巨大的文件的足夠的內(nèi)存。 
緩沖的另一個(gè)方面是向窗口終端的文本輸出。缺省情況下， System.out ( 一個(gè)PrintStream) 是行緩沖的，這意味著在遇到一個(gè)新行符后輸出緩沖區(qū)被提交。對于交互來說這是很重要的，在那種情況下你可能喜歡在實(shí)際的輸出前顯示一個(gè)輸入提示。 

方法 5: 關(guān)閉行緩沖
行緩沖可以被禁止，像下面的例子那樣: 



  import java.io.*;
  
  public class bufout {
    public static void main(String args[]) {
      FileOutputStream fdout =
          new FileOutputStream(FileDescriptor.out);
      BufferedOutputStream bos =
          new BufferedOutputStream(fdout, 1024);
      PrintStream ps =
          new PrintStream(bos, false);
  
      System.setOut(ps);
  
      final int N = 100000;
  
      for (int i = 1; i <= N; i++)
        System.out.println(i);
  
      ps.close();
    }
  }

這個(gè)程序輸出整數(shù)1到100000缺省輸出，比在缺省的行緩沖情況下快了三倍。 

緩沖也是下面將要展示的例子的重要部分，在那里，緩沖區(qū)被用于加速文件隨機(jī)訪問。 

讀寫文本文件

早些時(shí)候曾提到從文件里面讀取字符的方法調(diào)用的消耗可能是重大的。這個(gè)問題在計(jì)算文本文件的行數(shù)的另一個(gè)例子中也可以找到。: 

 

 import java.io.*;

  public class line1 {
    public static void main(String args[]) {
      if (args.length != 1) {
        System.err.println("missing filename");
        System.exit(1);
      }
      try {
        FileInputStream fis =
            new FileInputStream(args[0]);
        BufferedInputStream bis =
            new BufferedInputStream(fis);
        DataInputStream dis =
            new DataInputStream(bis);
        int cnt = 0;
        while (dis.readLine() != null)
          cnt++;
        dis.close();
        System.out.println(cnt);
      }
      catch (IOException e) {
        System.err.println(e);
      }
    }
  }

這個(gè)程序使用老的DataInputStream.readLine 方法，該方法是使用用讀取每個(gè)字符的 read 方法實(shí)現(xiàn)的。一個(gè)新方法是: 



 import java.io.*;

  public class line2 {
    public static void main(String args[]) {
      if (args.length != 1) {
        System.err.println("missing filename");
        System.exit(1);
      }
      try {
        FileReader fr = new FileReader(args[0]);
        BufferedReader br = new BufferedReader(fr);
        int cnt = 0;
        while (br.readLine() != null)
          cnt++;
        br.close();
        System.out.println(cnt);
      }
      catch (IOException e) {
        System.err.println(e);
      }
    }
  }

這個(gè)方法更快。例如在一個(gè)有200,000行的 6 MB文本文件上，第二個(gè)程序比第一個(gè)快大約20%。 

但是即使第二個(gè)程序不是更快的，第一個(gè)程序依然有一個(gè)重要的問題要注意。第一個(gè)程序在JavaTM 2編譯器下引起了不贊成警告，因?yàn)镈ataInputStream.readLine太陳舊了。它不能恰當(dāng)?shù)膶⒆止?jié)轉(zhuǎn)換為字符，因此在操作包含非ASCII字符的文本文件時(shí)可能是不合適的選擇。(Java語言使用Unicode字符集而不是ASCII) 

這就是早些時(shí)候提到的字節(jié)流和字符流之間的區(qū)別。像這樣的一個(gè)程序: 



 import java.io.*;
  
  public class conv1 {
    public static void main(String args[]) {
      try {
        FileOutputStream fos =
            new FileOutputStream("out1");
        PrintStream ps = 
            new PrintStream(fos);
        ps.println("\uffff\u4321\u1234");
        ps.close();
      }
      catch (IOException e) {
        System.err.println(e);
      }
    }
  }

向一個(gè)文件里面寫，但是沒有保存實(shí)際的Unicode字符輸出。Reader/Writer I/O 類是基于字符的，被設(shè)計(jì)用來解決這個(gè)問題。OutputStreamWriter 應(yīng)用于字節(jié)編碼的字符。 
一個(gè)使用PrintWriter寫入U(xiǎn)nicode字符的程序是這樣的: 

 

 import java.io.*;

  public class conv2 {
    public static void main(String args[]) {
      try {
        FileOutputStream fos =
            new FileOutputStream("out2");
        OutputStreamWriter osw =
            new OutputStreamWriter(fos, "UTF8");
        PrintWriter pw =
            new PrintWriter(osw);
        pw.println("\uffff\u4321\u1234");
        pw.close();
      }
      catch (IOException e) {
        System.err.println(e);
      }
    }
  }

這個(gè)程序使用UTF8編碼，具有ASCII文本是本身而其他字符是兩個(gè)或三個(gè)字節(jié)的特性。 

格式化的代價(jià)
實(shí)際上向文件寫數(shù)據(jù)只是輸出代價(jià)的一部分。另一個(gè)可觀的代價(jià)是數(shù)據(jù)格式化。考慮一個(gè)三部分程序，它像下面這樣輸出一行: 

 
The square of 5 is 25

方法 1
第一種方法簡單的輸出一個(gè)固定的字符串，了解固有的I/O開銷: 



  public class format1 {
    public static void main(String args[]) {
      final int COUNT = 25000;

      for (int i = 1; i <= COUNT; i++) {
        String s = "The square of 5 is 25\n";
        System.out.print(s);
      }
    }
  }

方法2
第二種方法使用簡單格式"+": 



 public class format2 {
    public static void main(String args[]) {
      int n = 5;
  
      final int COUNT = 25000;


      for (int i = 1; i <= COUNT; i++) {
        String s = "The square of " + n + " is " +
            n * n + "\n";
        System.out.print(s);
      }
    }
  }

方法 3
第三種方法使用java.text包中的 MessageFormat 類: 



 import java.text.*;
  
 public class format3 {
   public static void main(String args[]) {
     MessageFormat fmt =
      new MessageFormat("The square of {0} is {1}\n");
      Object values[] = new Object[2];


    int n = 5;


    values[0] = new Integer(n);
    values[1] = new Integer(n * n);
  
    final int COUNT = 25000;


    for (int i = 1; i <= COUNT; i++) {
      String s = fmt.format(values);
      System.out.print(s);
     }
    }
  }

這些程序產(chǎn)生同樣的輸出。運(yùn)行時(shí)間是: 

 
 format1   1.3
 format2   1.8
 format3   7.8

或者說最慢的和最快的大約是6比1。如果格式?jīng)]有預(yù)編譯第三種方法將更慢，使用靜態(tài)的方法代替: 

方法 4
MessageFormat.format(String, Object[]) 



  import java.text.*;
  
  public class format4 {
    public static void main(String args[]) {
      String fmt = "The square of {0} is {1}\n";
      Object values[] = new Object[2];


      int n = 5;


      values[0] = new Integer(n);
      values[1] = new Integer(n * n);
  
      final int COUNT = 25000;


      for (int i = 1; i <= COUNT; i++) {
        String s =
            MessageFormat.format(fmt, values);
        System.out.print(s);
      }
    }
  }

這比前一個(gè)例子多花費(fèi)1/3的時(shí)間。 

第三個(gè)方法比前兩種方法慢很多的事實(shí)并不意味著你不應(yīng)該使用它，而是你要意識(shí)到時(shí)間上的開銷。 

在國際化的情況下信息格式化是很重要的，關(guān)心這個(gè)問題的應(yīng)用程序通常從一個(gè)綁定的資源中讀取格式然后使用它。 

隨機(jī)訪問

RandomAccessFile 是一個(gè)進(jìn)行隨機(jī)文件I/O(在字節(jié)層次上)的類。這個(gè)類提供一個(gè)seek方法，和 C/C++中的相似,移動(dòng)文件指針到任意的位置，然后從那個(gè)位置字節(jié)可以被讀取或?qū)懭搿?nbsp;

seek方法訪問底層的運(yùn)行時(shí)系統(tǒng)因此往往是消耗巨大的。一個(gè)更好的代替是在RandomAccessFile上建立你自己的緩沖，并實(shí)現(xiàn)一個(gè)直接的字節(jié)read方法。read方法的參數(shù)是字節(jié)偏移量（>= 0）。這樣的一個(gè)例子是: 

 

 import java.io.*;
  
  public class ReadRandom {
    private static final int DEFAULT_BUFSIZE = 4096;
  
    private RandomAccessFile raf;
    private byte inbuf[];
    private long startpos = -1;
    private long endpos = -1;
    private int bufsize;
  
    public ReadRandom(String name) 
     throws FileNotFoundException {
      this(name, DEFAULT_BUFSIZE);
    }
  
    public ReadRandom(String name, int b)
        throws FileNotFoundException {
      raf = new RandomAccessFile(name, "r");
      bufsize = b;
      inbuf = new byte[bufsize];
    }
  
    public int read(long pos) {
      if (pos < startpos || pos > endpos) {
        long blockstart = (pos / bufsize) * bufsize;
        int n;
        try {
          raf.seek(blockstart);
          n = raf.read(inbuf);
        }
        catch (IOException e) {
          return -1;
        }
        startpos = blockstart;
        endpos = blockstart + n - 1;
        if (pos < startpos || pos > endpos)
          return -1;
      }
  
      return inbuf[(int)(pos - startpos)] & 0xffff;
    }
  
    public void close() throws IOException {
      raf.close();
    }
  
    public static void main(String args[]) {
      if (args.length != 1) {
        System.err.println("missing filename");
        System.exit(1);
      }
  
      try {
        ReadRandom rr = new ReadRandom(args[0]);
        long pos = 0;
        int c;
        byte buf[] = new byte[1];
        while ((c = rr.read(pos)) != -1) {
          pos++;
          buf[0] = (byte)c;
          System.out.write(buf, 0, 1);
        }
        rr.close();
      }
      catch (IOException e) {
        System.err.println(e);
      }
    }
  }

這個(gè)程序簡單的讀取字節(jié)序列然后輸出它們。 

如果有訪問位置，這個(gè)技術(shù)是很有用的，文件中的附近字節(jié)幾乎在同時(shí)被讀取。例如，如果你在一個(gè)排序的文件上實(shí)現(xiàn)二分法查找，這個(gè)方法可能很有用。如果你在一個(gè)巨大的文件上的任意點(diǎn)做隨機(jī)訪問的話就沒有太大價(jià)值。 

壓縮

Java提供用于壓縮和解壓字節(jié)流的類，這些類包含在java.util.zip 包里面，這些類也作為 Jar 文件的服務(wù)基礎(chǔ) ( Jar 文件是帶有附加文件列表的 Zip 文件)。 

下面的程序接收一個(gè)輸入文件并將之寫入一個(gè)只有一項(xiàng)的壓縮的 Zip 文件: 



 import java.io.*;
 import java.util.zip.*;
  
  public class compress {
    public static void doit(
                            String filein, 
                            String fileout
                            ) {
      FileInputStream fis = null;
      FileOutputStream fos = null;
      try {
        fis = new FileInputStream(filein);
        fos = new FileOutputStream(fileout);
        ZipOutputStream zos =
            new ZipOutputStream(fos);
        ZipEntry ze = new ZipEntry(filein);
        zos.putNextEntry(ze);
        final int BUFSIZ = 4096;
        byte inbuf[] = new byte[BUFSIZ];
        int n;
        while ((n = fis.read(inbuf)) != -1)
          zos.write(inbuf, 0, n);
        fis.close();
        fis = null;
        zos.close();
        fos = null;
      }
      catch (IOException e) {
        System.err.println(e);
      }
      finally {
        try {
          if (fis != null)
            fis.close();
          if (fos != null)
            fos.close();
        }
        catch (IOException e) {
        }
      }
    }
  public static void main(String args[]) {
    if (args.length != 2) {
     System.err.println("missing filenames");
     System.exit(1);
    }
   if (args[0].equals(args[1])) {
     System.err.println("filenames are identical");
     System.exit(1);
      }
      doit(args[0], args[1]);
    }
  }

下一個(gè)程序執(zhí)行相反的過程，將一個(gè)假設(shè)只有一項(xiàng)的Zip文件作為輸入然后將之解壓到輸出文件: 


 import java.io.*;
 import java.util.zip.*;
  
  public class uncompress {
    public static void doit(
                            String filein, 
                            String fileout
                            ) {
      FileInputStream fis = null;
      FileOutputStream fos = null;
      try {
        fis = new FileInputStream(filein);
        fos = new FileOutputStream(fileout);
        ZipInputStream zis = new ZipInputStream(fis);
        ZipEntry ze = zis.getNextEntry();
        final int BUFSIZ = 4096;
        byte inbuf[] = new byte[BUFSIZ];
        int n;
        while ((n = zis.read(inbuf, 0, BUFSIZ)) != -1)
          fos.write(inbuf, 0, n);
        zis.close();
        fis = null;
        fos.close();
        fos = null;
      }
      catch (IOException e) {
        System.err.println(e);
      }
      finally {
        try {
          if (fis != null)
            fis.close();
          if (fos != null)
            fos.close();
        }
        catch (IOException e) {
        }
      }
    }
    public static void main(String args[]) {
      if (args.length != 2) {
     System.err.println("missing filenames");
     System.exit(1);
      }
    if (args[0].equals(args[1])) {
     System.err.println("filenames are identical");
     System.exit(1);
      }
      doit(args[0], args[1]);
    }
  }

壓縮是提高還是損害I/O性能很大程度依賴你的硬件配置，特別是和處理器和磁盤驅(qū)動(dòng)器的速度相關(guān)。使用Zip技術(shù)的壓縮通常意味著在數(shù)據(jù)大小上減少50%，但是代價(jià)是壓縮和解壓的時(shí)間。一個(gè)巨大(5到10 MB)的壓縮文本文件，使用帶有IDE硬盤驅(qū)動(dòng)器的300-MHz Pentium PC從硬盤上讀取可以比不壓縮少用大約1/3的時(shí)間。 

壓縮的一個(gè)有用的范例是向非常慢的媒介例如軟盤寫數(shù)據(jù)。使用高速處理器(300 MHz Pentium)和低速軟驅(qū)(PC上的普通軟驅(qū))的一個(gè)測試顯示壓縮一個(gè)巨大的文本文件然后在寫入軟盤比直接寫入軟盤快大約50% 。 

高速緩存

關(guān)于硬件的高速緩存的詳細(xì)討論超出了本文的討論范圍。但是在有些情況下軟件高速緩存能被用于加速I/O。考慮從一個(gè)文本文件里面以隨機(jī)順序讀取一行的情況，這樣做的一個(gè)方法是讀取所有的行，然后把它們存入一個(gè)ArrayList (一個(gè)類似Vector的集合類): 


 import java.io.*;
 import java.util.ArrayList;
  
  public class LineCache {
    private ArrayList list = new ArrayList();
  
    public LineCache(String fn) throws IOException {
      FileReader fr = new FileReader(fn);
      BufferedReader br = new BufferedReader(fr);
      String ln;
      while ((ln = br.readLine()) != null)
        list.add(ln);
      br.close();
    }
  
    public String getLine(int n) {
      if (n < 0)
        throw new IllegalArgumentException();
  
      return (n < list.size() ? 
       (String)list.get(n) : null);
    }
  
    public static void main(String args[]) {
      if (args.length != 1) {
        System.err.println("missing filename");
        System.exit(1);
      }
      try {
        LineCache lc = new LineCache(args[0]);
        int i = 0;
        String ln;
        while ((ln = lc.getLine(i++)) != null)
          System.out.println(ln);
      }
      catch (IOException e) {
        System.err.println(e);
      }
    }
  } 

getLine 方法被用來獲取任意行。這個(gè)技術(shù)是很有用的，但是很明顯對一個(gè)大文件使用了太多的內(nèi)存，因此有局限性。一個(gè)代替的方法是簡單的記住被請求的行最近的100行，其它的請求直接從磁盤讀取。這個(gè)安排在局域性的訪問時(shí)很有用，但是在真正的隨機(jī)訪問時(shí)沒有太大作用。 

分解

分解 是指將字節(jié)或字符序列分割為像單詞這樣的邏輯塊的過程。Java 提供StreamTokenizer 類, 像下面這樣操作: 

 
 import java.io.*;
  
  public class token1 {
    public static void main(String args[]) {
     if (args.length != 1) {
       System.err.println("missing filename");
       System.exit(1);
      }
      try {
        FileReader fr = new FileReader(args[0]);
        BufferedReader br = new BufferedReader(fr);
        StreamTokenizer st = new StreamTokenizer(br);
        st.resetSyntax();
        st.wordChars('a', 'z');
        int tok;
        while ((tok = st.nextToken()) !=
            StreamTokenizer.TT_EOF) {
          if (tok == StreamTokenizer.TT_WORD)
            ;// st.sval has token
        }
        br.close();
      }
      catch (IOException e) {
        System.err.println(e);
      }
    }
  }

這個(gè)例子分解小寫單詞 (字母a-z)。如果你自己實(shí)現(xiàn)同等地功能，它可能像這樣： 
 

 import java.io.*;
  
  public class token2 {
    public static void main(String args[]) {
      if (args.length != 1) {
        System.err.println("missing filename");
        System.exit(1);
      }
      try {
        FileReader fr = new FileReader(args[0]);
        BufferedReader br = new BufferedReader(fr);
        int maxlen = 256;
        int currlen = 0;
        char wordbuf[] = new char[maxlen];
        int c;
        do {
          c = br.read();
          if (c >= 'a' && c <= 'z') {
            if (currlen == maxlen) {
              maxlen *= 1.5;
              char xbuf[] =
                  new char[maxlen];
              System.arraycopy(
                  wordbuf, 0,
                  xbuf, 0, currlen);
              wordbuf = xbuf;
            }
            wordbuf[currlen++] = (char)c;
          }
          else if (currlen > 0) {
            String s = new String(wordbuf,
                0, currlen);
          // do something with s
            currlen = 0;
          }
        } while (c != -1);
        br.close();
      }
      catch (IOException e) {
        System.err.println(e);
      }
    }
  }

第二個(gè)程序比前一個(gè)運(yùn)行快大約 20%，代價(jià)是寫一些微妙的底層代碼。 
StreamTokenizer 是一種混合類，它從字符流(例如 BufferedReader)讀取, 但是同時(shí)以字節(jié)的形式操作，將所有的字符當(dāng)作雙字節(jié)(大于 0xff) ，即使它們是字母字符。 

串行化

串行化 以標(biāo)準(zhǔn)格式將任意的Java數(shù)據(jù)結(jié)構(gòu)轉(zhuǎn)換為字節(jié)流。例如，下面的程序輸出隨機(jī)整數(shù)數(shù)組: 


  import java.io.*;
  import java.util.*;
  
  public class serial1 {
    public static void main(String args[]) {
      ArrayList al = new ArrayList();
      Random rn = new Random();
      final int N = 100000;
  
      for (int i = 1; i <= N; i++)
        al.add(new Integer(rn.nextInt()));
  
      try {
        FileOutputStream fos =
            new FileOutputStream("test.ser");
        BufferedOutputStream bos =
            new BufferedOutputStream(fos);
        ObjectOutputStream oos =
            new ObjectOutputStream(bos);
        oos.writeObject(al);
        oos.close();
      }
      catch (Throwable e) {
        System.err.println(e);
      }
    }
  }

而下面的程序讀回?cái)?shù)組: 
 
 import java.io.*;
 import java.util.*;
  
  public class serial2 {
    public static void main(String args[]) {
      ArrayList al = null;
  
      try {
        FileInputStream fis =
            new FileInputStream("test.ser");
        BufferedInputStream bis =
            new BufferedInputStream(fis);
        ObjectInputStream ois =
            new ObjectInputStream(bis);
        al = (ArrayList)ois.readObject();
        ois.close();
      }
      catch (Throwable e) {
        System.err.println(e);
      }
    }
  }

注意我們使用緩沖提高I/O操作的速度。 
有比串行化更快的輸出大量數(shù)據(jù)然后讀回的方法嗎？可能沒有，除非在特殊的情況下。例如，假設(shè)你決定將文本輸出為64位的整數(shù)而不是一組8字節(jié)。作為文本的長整數(shù)的最大長度是大約20個(gè)字符，或者說二進(jìn)制表示的2.5倍長。這種格式看起來不會(huì)快。然而，在某些情況下，例如位圖，一個(gè)特殊的格式可能是一個(gè)改進(jìn)。然而使用你自己的方案而不是串行化的標(biāo)準(zhǔn)方案將使你卷入一些權(quán)衡。 

除了串行化實(shí)際的I/O和格式化開銷外(使用DataInputStream和 DataOutputStream), 還有其他的開銷，例如在串行化恢復(fù)時(shí)的創(chuàng)建新對象的需要。 

注意DataOutputStream 方法也可以用于開發(fā)半自定義數(shù)據(jù)格式，例如: 

 

 import java.io.*;
  import java.util.*;
  
  public class binary1 {
    public static void main(String args[]) {
      try {
        FileOutputStream fos =
            new FileOutputStream("outdata");
        BufferedOutputStream bos =
            new BufferedOutputStream(fos);
        DataOutputStream dos =
            new DataOutputStream(bos);
        Random rn = new Random();
        final int N = 10;
        dos.writeInt(N);
        for (int i = 1; i <= N; i++) {
          int r = rn.nextInt();
          System.out.println(r);
          dos.writeInt(r);
        }
        dos.close();
      }
      catch (IOException e) {
        System.err.println(e);
      }
    }
  }

和: 



 import java.io.*;
  
  public class binary2 {
    public static void main(String args[]) {
      try {
        FileInputStream fis =
            new FileInputStream("outdata");
        BufferedInputStream bis =
            new BufferedInputStream(fis);
        DataInputStream dis =
            new DataInputStream(bis);
        int N = dis.readInt();
        for (int i = 1; i <= N; i++) {
          int r = dis.readInt();
          System.out.println(r);
        }
        dis.close();
      }
      catch (IOException e) {
        System.err.println(e);
      }
    }
  }

這些程序?qū)?0個(gè)整數(shù)寫入文件然后讀回它們。 

獲取文件信息

迄今為止我們的討論圍繞單一的文件輸入輸出。但是加速I/O性能還有另一方面－－和得到文件特性有關(guān)。例如，考慮一個(gè)打印文件長度的小程序: 


 import java.io.*;
  
  public class length1 {
    public static void main(String args[]) {
      if (args.length != 1) {
        System.err.println("missing filename");
        System.exit(1);
      }
      File f = new File(args[0]);
      long len = f.length();
      System.out.println(len);
    }
  }

Java運(yùn)行時(shí)系統(tǒng)自身并不知道文件的長度，因此必須向底層的操作系統(tǒng)查詢以獲得這個(gè)信息，對于文件的其他信息這也成立，例如文件是否是一個(gè)目錄，文件上次修改時(shí)間等等。 java.io包中的File 類提供一套查詢這些信息的方法。這些方法總體來說在時(shí)間上開銷很大因此應(yīng)該盡可能少用。 
下面是一個(gè)查詢文件信息的更長的范例，它遞歸整個(gè)文件系統(tǒng)寫出所有的文件路徑: 

 
 import java.io.*;
  
  public class roots {
    public static void visit(File f) {
      System.out.println(f);
    }
  
    public static void walk(File f) {
      visit(f);
      if (f.isDirectory()) {
        String list[] = f.list();
        for (int i = 0; i < list.length; i++)
          walk(new File(f, list[i]));
      }
    }
  
    public static void main(String args[]) {
      File list[] = File.listRoots();
      for (int i = 0; i < list.length; i++) {
        if (list[i].exists())
          walk(list[i]);
        else
          System.err.println("not accessible: "
              + list[i]);
      }
    }
  }

這個(gè)范例使用 File 方法，例如 isDirectory 和 exists,穿越目錄結(jié)構(gòu)。每個(gè)文件都被查詢一次它的類型 (普通文件或者目錄)。

posted on 2006-01-16 02:32 風(fēng) 閱讀(1464) 評論(2)  編輯  收藏