Java RandomAccessFile随机访问类

淩亂°似流年 2022-07-19 01:17 180阅读 0赞

# Java RandomAccessFile随机访问类 #

--------------------

## 介绍 ##

Java的RandomAccessFile提供对文件的读写功能，与普通的输入输出流不一样的是RamdomAccessFile可以任意的访问文件的任何位置。RandomAccessFile的对象包含一个记录指针，用于标识当前流的读写位置，这个位置可以向前移动，也可以向后移动。
    
    
    
    RandomAccessFile类最大的特点在于其具有可读与可写的功能并且可以任意访问文件任何位置,不像其他IO流通常只具备其中一种方法。从其继承结构就可以知道其拥有了很多读取和写入各种数据类型的方法。
    
    
    
    Instances of this class support both reading and writing to a random access file. A random access file behaves like a large array of bytes stored in the file system. There is a kind of cursor,or index into the implied array, called the file pointer;input operations read bytes starting at the file pointer and advance the file pointer past the bytes read. If the random access file is created in read/write mode, then output operations are also available;output operations write bytes starting at the file pointer and advance the file pointer past the bytes written. Output operations that write past the current end of the implied array cause the array to be extended. The file pointer can be read by the getFilePointer method and set by the seek
    method.

--------------------

## RandomAccessFile类核心方法 ##

public class RandomAccessFile implements DataOutput, DataInput, Closeable {
    
        /**
         * Creates a random access file stream to read from, and optionally to
         * write to, the file specified by the File argument.  A new 
         * FileDescriptor object is created to represent this file connection.
         *
         *
         */
        public RandomAccessFile(File file, String mode)
            throws FileNotFoundException
        {
    
        }
    
        /**
         * Returns the unique java.nio.channels.FileChannel FileChannel
         * object associated with this file.
         */
        public final FileChannel getChannel() {
            // ... 省略代码
        }
    
        /**
         * Returns the current offset in this file.
         *
         */
        public native long getFilePointer() throws IOException;
    
        /**
         * Opens a file and returns the file descriptor.  The file is
         * opened in read-write mode if the O_RDWR bit in mode
         * is true, else the file is opened as read-only.
         * If the name refers to a directory, an IOException
         * is thrown.
         */
        private native void open(String name, int mode)
            throws FileNotFoundException;
    
        // 'Read' primitives
    
        private native int read0() throws IOException;
    
        private native int readBytes0(byte b[], int off, int len) throws IOException;  
    
        /**
         * Attempts to skip over n bytes of input discarding the
         * skipped bytes.
         * 
         *
         * This method may skip over some smaller number of bytes, possibly zero.
         * This may result from any of a number of conditions; reaching end of
         * file before n bytes have been skipped is only one
         * possibility. This method never throws an EOFException.
         * The actual number of bytes skipped is returned.  If n
         * is negative, no bytes are skipped.
         */
        public int skipBytes(int n) throws IOException {
    
            // ...省略代码
            /* return the actual number of bytes skipped */
    
        }
    
        // 'Write' primitives
    
        private native void write0(int b) throws IOException;
    
        private native void writeBytes0(byte b[], int off, int len) throws IOException;
    
        /**
         * Writes b.length bytes from the specified byte array
         * to this file, starting at the current file pointer.
         */
        public void write(byte b[]) throws IOException {
            writeBytes(b, 0, b.length);
        }
    
        // 'Random access' stuff
    
    
        /**
         * Sets the file-pointer offset, measured from the beginning of this
         * file, at which the next read or write occurs.  The offset may be
         * set beyond the end of the file. Setting the offset beyond the end
         * of the file does not change the file length.  The file length will
         * change only by writing after the offset has been set beyond the end
         * of the file.
         *
         */
        public native void seek(long pos) throws IOException;
    
        /**
         * Returns the length of this file.
         */
        public native long length() throws IOException;
    
        /**
         * Sets the length of this file.
         *
         * If the present length of the file as returned by the
         * length method is greater than the newLength
         * argument then the file will be truncated.  In this case, if the file
         * offset as returned by the getFilePointer method is greater
         * than newLength then after this method returns the offset
         * will be equal to newLength.
         *
         * If the present length of the file as returned by the
         * length method is smaller than the newLength
         * argument then the file will be extended.  In this case, the contents of
         * the extended portion of the file are not defined.
         */
        public native void setLength(long newLength) throws IOException;
    
    
        /**
         * Reads the next line of text from this file.  This method successively
         * reads bytes from the file, starting at the current file pointer,
         * until it reaches a line terminator or the end
         * of the file.  Each byte is converted into a character by taking the
         * byte's value for the lower eight bits of the character and setting the
         * high eight bits of the character to zero.  This method does not,
         * therefore, support the full Unicode character set.
         * 
         * This method blocks until a newline character is read, a carriage
         * return and the byte following it are read (to see if it is a newline),
         * the end of the file is reached, or an exception is thrown.
         */
    
        public final String readLine() throws IOException {
            // ... 省略
        }
    
    }

## 使用RandomAccessFile文件拷贝 ##

public void testRandomAccessFile() throws Exception {
    
        RandomAccessFile randomAccessFile = new RandomAccessFile(new File("e:/nio/2.jpg"), "r");
        FileOutputStream outputStream = new FileOutputStream(new File("e:/nio/2copy.jpg"));
        FileChannel outChannel = outputStream.getChannel();
        FileChannel fileChannel = randomAccessFile.getChannel();
    
        //基于FileChannel管道来拷贝文件
        outChannel.transferFrom(fileChannel, 0, fileChannel.size());
    
        outputStream.close();
        randomAccessFile.close();

## \} ##

## 总结 ##

RandomAccessFile不属于InputStream和OutputStream类.RandomAccessFile的工作方式是，把DataInputStream和DataOutputStream结合起来，再加上它自己的一些方法，比如定位用的getFilePointer( )，在文件里移动用的seek( )，以及判断文件大小的length( )、skipBytes()跳过多少字节数。
    
    RandomAccessFile最大特点：
    1、拥有一个文件指针可以任意移动
    2、拥有读取和写入方法

## 参考 ##

1、[http://blog.csdn.net/akon\_vm/article/details/7429245][http_blog.csdn.net_akon_vm_article_details_7429245]

[http_blog.csdn.net_akon_vm_article_details_7429245]: http://blog.csdn.net/akon_vm/article/details/7429245