The class demostrates the use of java.io.RandomAccessFile

From http://www.java2s.com/Code/Java/File-Input-Output/TheclassdemostratestheuseofjavaioRandomAccessFile.htm

 


 
/*
 * Copyright (c) 2004 David Flanagan.  All rights reserved.
 * This code is from the book Java Examples in a Nutshell, 3nd Edition.
 * It is provided AS-IS, WITHOUT ANY WARRANTY either expressed or implied.
 * You may study, use, and modify it for any non-commercial purpose,
 * including teaching and use in open-source projects.
 * You may distribute it non-commercially as long as you retain this notice.
 * For a commercial use license, or to purchase the book, 
 * please visit http://www.davidflanagan.com/javaexamples3.
 */

import java.io.IOException;
import java.io.RandomAccessFile;

/**
 * This class represents a list of strings saved persistently to a file, along
 * with an index that allows random access to any string in the list. The static
 * method writeWords() creates such an indexed list in a file. The class
 * demostrates the use of java.io.RandomAccessFile
 */
public class WordList {
  // This is a simple test method
  public static void main(String args[]) throws IOException {
    // Write command line arguments to a WordList file named "words.data"
    writeWords("words.data", args);

    // Now create a WordList based on that file
    WordList list = new WordList("words.data");
    // And iterate through the elements of the list backward
    // This would be very inefficient to with sequential-access streams
    for (int i = list.size() 1; i >= 0; i--)
      System.out.println(list.get(i));
    // Tell the list we're done with it.
    list.close();
  }

  // This static method creates a WordList file
  public static void writeWords(String filename, String[] wordsthrows IOException {
    // Open the file for read/write access ("rw"). We only need to write,
    // but have to request read access as well
    RandomAccessFile f = new RandomAccessFile(filename, "rw");

    // This array will hold the positions of each word in the file
    long wordPositions[] new long[words.length];

    // Reserve space at the start of the file for the wordPositions array
    // and the length of that array. 4 bytes for length plus 8 bytes for
    // each long value in the array.
    f.seek(4L (* words.length));

    // Now, loop through the words and write them out to the file,
    // recording the start position of each word. Note that the
    // text is written in the UTF-8 encoding, which uses 1, 2, or 3 bytes
    // per character, so we can't assume that the string length equals
    // the string size on the disk. Also note that the writeUTF() method
    // records the length of the string so it can be read by readUTF().
    for (int i = 0; i < words.length; i++) {
      wordPositions[i= f.getFilePointer()// record file position
      f.writeUTF(words[i])// write word
    }

    // Now go back to the beginning of the file and write the positions
    f.seek(0L)// Start at beginning
    f.writeInt(wordPositions.length)// Write array length
    for (int i = 0; i < wordPositions.length; i++)
      // Loop through array
      f.writeLong(wordPositions[i])// Write array element
    f.close()// Close the file when done.
  }

  // These are the instance fields of the WordList class
  RandomAccessFile f; // the file to read words from

  long[] positions; // the index that gives the position of each word

  // Create a WordList object based on the named file
  public WordList(String filenamethrows IOException {
    // Open the random access file for read-only access
    f = new RandomAccessFile(filename, "r");

    // Now read the array of file positions from it
    int numwords = f.readInt()// Read array length
    positions = new long[numwords]// Allocate array
    for (int i = 0; i < numwords; i++)
      // Read array contents
      positions[i= f.readLong();
  }

  // Call this method when the WordList is no longer needed.
  public void close() throws IOException {
    if (f != null)
      f.close()// close file
    f = null// remember that it is closed
    positions = null;
  }

  // Return the number of words in the WordList
  public int size() {
    // Make sure we haven't closed the file already
    if (f == null)
      throw new IllegalStateException("already closed");
    return positions.length;
  }

  // Return the string at the specified position in the WordList
  // Throws IllegalStateException if already closed, and throws
  // ArrayIndexOutOfBounds if i is negative or >= size()
  public String get(int ithrows IOException {
    // Make sure close() hasn't already been called.
    if (f == null)
      throw new IllegalStateException("already closed");
    f.seek(positions[i])// Move to the word position in the file.
    return f.readUTF()// Read and return the string at that position.
  }
}

posted @ 2009-01-05 03:27  N/A2011  阅读(336)  评论(0编辑  收藏  举报