java.nio.channels.FileChannel源碼是什么

142次閱讀

共計 7421 個字符，預計需要花費 19 分鐘才能閱讀完成。

本篇內容介紹了“java.nio.channels.FileChannel 源碼是什么”的有關知識，在實際案例的操作過程中，不少人都會遇到這樣的困境，接下來就讓丸趣 TV 小編帶領大家學習一下如何處理這些情況吧！希望大家仔細閱讀，能夠學有所成！

版本：JDK7

package java.nio.channels;

import java.io.; import java.nio.ByteBuffer; import java.nio.MappedByteBuffer; import java.nio.channels.spi.AbstractInterruptibleChannel; import java.nio.file.; import java.nio.file.attribute.FileAttribute; import java.nio.file.spi.*; import java.util.Set; import java.util.HashSet; import java.util.Collections;

public abstract class FileChannel extends AbstractInterruptibleChannel implements SeekableByteChannel, GatheringByteChannel, ScatteringByteChannel {
protected FileChannel() { }
* Opens or creates a file, returning a file channel to access the file.
*
* p The {[@code](https://my.oschina.net/codeo) options} parameter determines how the file is opened.
* The {[@link](https://my.oschina.net/u/393) StandardOpenOption#READ READ} and {[@link](https://my.oschina.net/u/393) StandardOpenOption#WRITE
* WRITE} options determine if the file should be opened for reading and/or
* writing. If neither option (or the {[@link](https://my.oschina.net/u/393) StandardOpenOption#APPEND APPEND}
* option) is contained in the array then the file is opened for reading.
* By default reading or writing commences at the beginning of the file.
* [@since](https://my.oschina.net/u/266547) 1.7
*/
public static FileChannel open(Path path, Set ? extends OpenOption options, FileAttribute ? ... attrs) throws IOException {
FileSystemProvider provider = path.getFileSystem().provider();
return provider.newFileChannel(path, options, attrs);
private static final FileAttribute ? [] NO_ATTRIBUTES = new FileAttribute[0];
* Opens or creates a file, returning a file channel to access the file.
* @since 1.7
*/
public static FileChannel open(Path path, OpenOption... options) throws IOException {
Set OpenOption set = new HashSet OpenOption (options.length);
Collections.addAll(set, options);
return open(path, set, NO_ATTRIBUTES);
// -- Channel operations --
* Reads a sequence of bytes from this channel into the given buffer.
*/
public abstract int read(ByteBuffer dst) throws IOException;
* Reads a sequence of bytes from this channel into a subsequence of the
* given buffers.
*/
public abstract long read(ByteBuffer[] dsts, int offset, int length)
throws IOException;
* Reads a sequence of bytes from this channel into the given buffers.
*/
public final long read(ByteBuffer[] dsts) throws IOException {
return read(dsts, 0, dsts.length);
* Writes a sequence of bytes to this channel from the given buffer.
*/
public abstract int write(ByteBuffer src) throws IOException;
* Writes a sequence of bytes to this channel from a subsequence of the given buffers.
*/
public abstract long write(ByteBuffer[] srcs, int offset, int length)
throws IOException;
* Writes a sequence of bytes to this channel from the given buffers.
*/
public final long write(ByteBuffer[] srcs) throws IOException {
return write(srcs, 0, srcs.length);
* Returns this channel s file position.
*/
public abstract long position() throws IOException;
* Sets this channel s file position.
*
* p Setting the position to a value that is greater than the file s
* current size is legal but does not change the size of the file. A later
* attempt to read bytes at such a position will immediately return an
* end-of-file indication. A later attempt to write bytes at such a
* position will cause the file to be grown to accommodate the new bytes;
* the values of any bytes between the previous end-of-file and the
* newly-written bytes are unspecified. /p
*
* 如果將位置設置在文件結束符之后，然后試圖從文件通道中讀取數據，讀方法將返回 -1 —— 文件結束標志。
* 如果將位置設置在文件結束符之后，然后向通道中寫數據，文件將撐大到當前位置并 (從當前位置開始) 寫入數據。這可能導致“文件空洞”，磁盤上物理文件中寫入的數據間有空隙。
*
* @param newPosition
* The new position, a non-negative integer counting
* the number of bytes from the beginning of the file
*/
public abstract FileChannel position(long newPosition) throws IOException;
* Returns the current size of this channel s file.
*/
public abstract long size() throws IOException;
* Truncates this channel s file to the given size. 截取一個文件
*
* p If the given size is less than the file s current size then the file
* is truncated, discarding any bytes beyond the new end of the file. If
* the given size is greater than or equal to the file s current size then
* the file is not modified. In either case, if this channel s file
* position is greater than the given size then it is set to that size.
*/
public abstract FileChannel truncate(long size) throws IOException;
* Forces any updates to this channel s file to be written to the storage
* device that contains it.
* 將通道里尚未寫入磁盤的數據強制寫到磁盤上。
* 說明：
* 1)操作系統將數據緩存在內存中，所以無法保證寫入到 FileChannel 里的數據一定會即時寫到磁盤上。
* 2)如果要保證寫入到 FileChannel 里的數據即時寫到磁盤上，需要調用 force()方法，參數表示是否將文件的元數據寫到磁盤上。
*/
public abstract void force(boolean metaData) throws IOException;
// 通道之間的數據傳輸
* Transfers bytes from this channel s file to the given writable byte channel.
*/
public abstract long transferTo(long position, long count, WritableByteChannel target) throws IOException;
* Transfers bytes into this channel s file from the given readable byte channel.
*/
public abstract long transferFrom(ReadableByteChannel src, long position, long count) throws IOException;
* Reads a sequence of bytes from this channel into the given buffer, starting at the given file position.
*
* This method does not modify this channel s position.
* If the given position is greater than the file s current size then no bytes are read.
*/
public abstract int read(ByteBuffer dst, long position) throws IOException;
* Writes a sequence of bytes to this channel from the given buffer, starting at the given file position.
*
* This method does not modify this channel s position.
* If the given position is greater than the file s current size then the file will be grown to accommodate the new bytes;
* the values of any bytes between the previous end-of-file and the newly-written bytes are unspecified.
*/
public abstract int write(ByteBuffer src, long position) throws IOException;

* A typesafe enumeration for file-mapping modes.
*
* @since 1.4
*
* @see java.nio.channels.FileChannel#map
*/
public static class MapMode {
/**
* Mode for a read-only mapping.
*/
public static final MapMode READ_ONLY = new MapMode(READ_ONLY
/**
* Mode for a read/write mapping.
*/
public static final MapMode READ_WRITE = new MapMode(READ_WRITE
/**
* Mode for a private (copy-on-write) mapping.
*/
public static final MapMode PRIVATE = new MapMode(PRIVATE
private final String name;
private MapMode(String name) {
this.name = name;
}
public String toString() {
return name;
}
* Maps a region of this channel s file directly into memory.
*
* A region of a file may be mapped into memory in one of three modes:
*
* Read-only、Read/write、Private
*
* @param mode
* One of the constants {@link MapMode#READ_ONLY READ_ONLY}, {@link
* MapMode#READ_WRITE READ_WRITE}, or {@link MapMode#PRIVATE
* PRIVATE} defined in the {@link MapMode} class, according to
* whether the file is to be mapped read-only, read/write, or
* privately (copy-on-write), respectively
*
* @param position
* The position within the file at which the mapped region
* is to start; must be non-negative
*
* @param size
* The size of the region to be mapped; must be non-negative and
* no greater than {@link java.lang.Integer#MAX_VALUE}
*
*
* @see java.nio.channels.FileChannel.MapMode
* @see java.nio.MappedByteBuffer
*/
public abstract MappedByteBuffer map(MapMode mode, long position, long size) throws IOException;

正文完