FileInputStream fis = new FileInputStream(FILE_PATH);
FileChannel channel = fis.getChannel();

FileOutputStream fos = new FileOutputStream(FILE_PATH);
FileChannel channel = fis.getChannel();

RandomAccessFile raf = new RandomAccessFile(FILE_PATH , "rw");
FileChannel channel = raf.getChannel();

// 获取管道
RandomAccessFile raf = new RandomAccessFile(FILE_PATH, "rw");
FileChannel rafChannel = raf.getChannel();

// 准备数据
String data = "新数据，时间： " + System.currentTimeMillis();
System.out.println("原数据：\n" + "   " + data);
ByteBuffer buffer = ByteBuffer.allocate(128);
buffer.clear();
buffer.put(data.getBytes());
buffer.flip();

// 写入数据
rafChannel.write(buffer);

rafChannel.close();
raf.close();

// 重新打开管道
raf = new RandomAccessFile(FILE_PATH, "rw");
rafChannel = raf.getChannel();

// 读取刚刚写入的数据
buffer.clear();
rafChannel.read(buffer);

// 打印读取出的数据
buffer.flip();
byte[] bytes = new byte[buffer.limit()];
buffer.get(bytes);
System.out.println("读取到的数据：\n" + "   " + new String(bytes));

rafChannel.close();
raf.close();

public static void main(String[] args) throws IOException {
    RandomAccessFile fromFile = new RandomAccessFile("fromFile.txt", "rw");
    FileChannel fromChannel = fromFile.getChannel();
    
    RandomAccessFile toFile = new RandomAccessFile("toFile.txt", "rw");
    FileChannel toChannel = toFile.getChannel();
    
    long position = 0;
    long count = fromChannel.size();
    
    // 将 fromFile 文件找那个的数据转移到 toFile 中去
    System.out.println("before transfer: " + readChannel(toChannel));
    fromChannel.transferTo(position, count, toChannel);
    System.out.println("after transfer : " + readChannel(toChannel));
    
    fromChannel.close();
    fromFile.close();
    toChannel.close();
    toFile.close();
}

private static String readChannel(FileChannel channel) throws IOException {
    ByteBuffer buffer = ByteBuffer.allocate(32);
    buffer.clear();

    // 将 channel 读取位置设为 0，也就是文件开始位置
    channel.position(0);
    channel.read(buffer);
    
    // 再次将文件位置归零
    channel.position(0);

    buffer.flip();
    byte[] bytes = new byte[buffer.limit()];
    buffer.get(bytes);
    return new String(bytes);
}

public long transferTo(long position, long count,
                           WritableByteChannel target)
        throws IOException
{
    // 省略一些代码
    
    int icount = (int)Math.min(count, Integer.MAX_VALUE);
    if ((sz - position) < icount)
        icount = (int)(sz - position);

    long n;

    // Attempt a direct transfer, if the kernel supports it
    if ((n = transferToDirectly(position, icount, target)) >= 0)
        return n;

    // Attempt a mapped transfer, but only to trusted channel types
    if ((n = transferToTrustedChannel(position, icount, target)) >= 0)
        return n;

    // Slow path for untrusted targets
    return transferToArbitraryChannel(position, icount, target);
}
    
private long transferToDirectly(long position, int icount,
                                WritableByteChannel target)
    throws IOException
{
    // 省略一些代码

    long n = -1;
    int ti = -1;
    try {
        begin();
        ti = threads.add();
        if (!isOpen())
            return -1;
        do {
            n = transferTo0(thisFDVal, position, icount, targetFDVal);
        } while ((n == IOStatus.INTERRUPTED) && isOpen());
        
        // 省略一些代码
        
        return IOStatus.normalize(n);
    } finally {
        threads.remove(ti);
        end (n > -1);
    }
}

JNIEXPORT jlong JNICALL
Java_sun_nio_ch_FileChannelImpl_transferTo0(JNIEnv *env, jobject this,
                                            jint srcFD,
                                            jlong position, jlong count,
                                            jint dstFD)
{
#if defined(__linux__)
    off64_t offset = (off64_t)position;
    
    jlong n = sendfile64(dstFD, srcFD, &offset, (size_t)count);
    if (n < 0) {
        if (errno == EAGAIN)
            return IOS_UNAVAILABLE;
        if ((errno == EINVAL) && ((ssize_t)count >= 0))
            return IOS_UNSUPPORTED_CASE;
        if (errno == EINTR) {
            return IOS_INTERRUPTED;
        }
        JNU_ThrowIOExceptionWithLastError(env, "Transfer failed");
        return IOS_THROWN;
    }
    return n;

// 其他平台的代码省略
#endif
}

// 从标准输入获取数据
Scanner sc = new Scanner(System.in);
System.out.println("请输入：");
String str = sc.nextLine();
byte[] bytes = str.getBytes();

RandomAccessFile raf = new RandomAccessFile("map.txt", "rw");
FileChannel channel = raf.getChannel();

// 获取内存映射缓冲区，并向缓冲区写入数据
MappedByteBuffer mappedBuffer = channel.map(MapMode.READ_WRITE, 0, bytes.length);
mappedBuffer.put(bytes);

raf.close();
raf.close();

// 再次打开刚刚的文件，读取其中的内容
raf = new RandomAccessFile("map.txt", "rw");
channel = raf.getChannel();
System.out.println("\n文件内容：")
System.out.println(readChannel(channel));

raf.close();
raf.close();

#include <stdio.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <memory.h>
#include <unistd.h>

int main() {
    int dstfd;
    void *dst;
    char buf[64], out[64];
    int len;
    
    printf("Please input:\n");
    scanf("%s", buf);
    len = strlen(buf);

    // 打开文件
    dstfd = open("dst.txt", O_RDWR | O_CREAT | O_TRUNC, S_IRWXU);
    lseek(dstfd, len - 1, SEEK_SET);
    write(dstfd, "", 1);

    // 将文件映射到内存中
    dst = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, dstfd, 0);

    // 将输入的数据拷贝到映射内存中
    memcpy(dst, buf, len);

    munmap(dst, len);
    close(dstfd);

    // 重新打开文件，并输出文件内容
    dstfd = open("dst.txt", O_RDONLY);
    dst = mmap(NULL, len, PROT_READ, MAP_SHARED, dstfd, 0);
    bzero(out, 64);
    memcpy(out, dst, len);
    printf("\nfile content:\n%s\n", out);

    munmap(dst, len);
    close(dstfd);
    return 0;
}