RandomAccessFile多线程下载、复制文件、超大文件读写

最近在准备面试，翻了翻自己以前写的Demo，发现自己写了不少的工具包，今天整理了一下，分享给大家。

本文包含以下Demo：
1、常用方法测试
2、在文件中间插入一段新的数据
3、多线程下载文件
4、多线程复制文件
5、超大文件的读写

具体注意事项我会全部写在注释中，我就不再啰嗦介绍RandomAccessFile怎么去用，它跟普通文件读写类似，不过就是多了一个游标，可以从文件指定位置开始读取，大家可以一边参照API，一边看我的Demo执行情况，试着自己写写。
大家有好的改进意见、建议或者有什么问题欢迎留言。

RandomAccessFile常用方法

/**
 * 这个Demo是刚开始接触RandomAccessFile从网络上找到的，如今我也不记得出处
 *
 * @author ?? 2016/11/7
 * @version 1.0
 */

import java.io.RandomAccessFile;

public class RandomAccessFileDemo {
    public static void main(String[] args) throws Exception {
        RandomAccessFile file = new RandomAccessFile("file", "rw");
        // 占4个字节
        file.writeInt(20);
        // 占8个字节
        file.writeDouble(8.236598);
        // 这个长度写在当前文件指针的前两个字节处，可用readShort()读取
        file.writeUTF("这是一个UTF字符串");
        // 占1个字节
        file.writeBoolean(true);
        // 占2个字节
        file.writeShort(395);
        // 占8个字节
        file.writeLong(2325451l);
        file.writeUTF("又是一个UTF字符串");
        // 占4个字节
        file.writeFloat(35.5f);
        // 占2个字节
        file.writeChar('a');
        // 把文件指针位置设置到文件起始处
        file.seek(0);

        // 以下从file文件中读数据，要注意文件指针的位置
        System.out.println("——————从file文件指定位置读数据——————");
        System.out.println(file.readInt());
        System.out.println(file.readDouble());
        System.out.println(file.readUTF());

        // 将文件指针跳过3个字节，本例中即跳过了一个boolean值和short值。
        file.skipBytes(3);
        System.out.println(file.readLong());

        // 跳过文件中“又是一个UTF字符串”所占字节，注意readShort()方法会移动文件指针，所以不用加2。
        file.skipBytes(file.readShort());
        System.out.println(file.readFloat());

        // 以下演示文件复制操作
        System.out.println("——————文件复制（从file到fileCopy）——————");
        file.seek(0);
        RandomAccessFile fileCopy = new RandomAccessFile("fileCopy", "rw");
        // 取得文件长度（字节数）
        int len = (int) file.length();
        byte[] b = new byte[len];
        file.readFully(b);
        fileCopy.write(b);
        System.out.println("复制完成！");
        file.close();
        fileCopy.close();
    }
}

超大文件读写

import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;

/**
 * 超大文件读写
 *
 * @author ChenSS 2016/11/7
 * @version 1.0
 */
public class LargeMappedFiles {
    static int length = 0x8000000; // 128 Mb

    public static void main(String[] args) throws Exception {
        // 为了以可读可写的方式打开文件，这里使用RandomAccessFile来创建文件。
        // 注意，文件通道的可读可写要建立在文件流本身可读写的基础之上
        RandomAccessFile accessFile = new RandomAccessFile("test.dat", "rw");
        FileChannel fileChannel = accessFile.getChannel();

        // 使用MappedByteBuffer写128M的内容
        MappedByteBuffer out = fileChannel.map(FileChannel.MapMode.READ_WRITE,
                0, length);
        for (int i = 0; i < length; i++) {
            out.put((byte) 'x');
        }

        // 另一种写入方式,128M结尾追加一句话，待会再想办法读出来
        String newData = "这是最后一句话";
        // 分配字节缓冲区
        ByteBuffer buf = ByteBuffer.allocate(48);
        // clear方法将缓冲区清空。
        buf.clear();
        // 放入字符串
        buf.put(newData.getBytes());
        // 回到当前缓存的头部
        buf.flip();
        // hasRemaining告知在当前位置和限制之间是否有元素。
        while (buf.hasRemaining()) {
            fileChannel.write(buf);
        }

        System.out.println("========================");

        StringBuilder result = new StringBuilder();
        // 定义字节缓冲区
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        // 定义解码后字符存储缓冲区
        CharBuffer charBuffer = CharBuffer.allocate(1024);
        // 定义合适的字符集解码器
        CharsetDecoder decoder = Charset.forName("UTF-8").newDecoder();

        // 设置此缓冲区的位置
        fileChannel.position(length);
        while ((fileChannel.read(byteBuffer)) != -1) { // 读取字符串到缓冲区
            byteBuffer.flip();
            charBuffer.clear();
            // 对byteBuffer进行解码
            if (fileChannel.position() < fileChannel.size()) {
                decoder.decode(byteBuffer, charBuffer, false);
            } else {
                // 最后一次解码
                decoder.decode(byteBuffer, charBuffer, true);
                decoder.flush(charBuffer);
            }
            // 注意此处调用compact方法，而不是clear方法
            byteBuffer.compact();
            charBuffer.flip();
            // 将charBuffer放入返回结果中
            char[] chars = new char[charBuffer.remaining()];
            charBuffer.get(chars, 0, charBuffer.remaining());
            result.append(chars);
        }
        System.out.println(result);

        // 读取文件中间6个字节内容
        for (int i = length / 2; i < length / 2 + 6; i++) {
            System.out.print((char) out.get(i));
        }
        fileChannel.close();
        accessFile.close();
    }
}

文件追加内容

/**
 * 文件追加
 * @author ChenSS 2016/11/7
 * @version 1.0
 */
public class FileAppend {
    public static void main(String[] args) {
        FileAppend.append(4, "zhuangjiangtao", "file.txt");
    }

    public static void append(long skip, String str, String fileName) {
        try {
            RandomAccessFile raf = new RandomAccessFile(fileName, "rw");
            byte[] b = str.getBytes();
            long len = b.length;
            long start = len + skip;
            // 重新开辟空间
            raf.setLength(raf.length() + len);
            for (long i = raf.length() - 1; i >= start; i--) {
                raf.seek(i - len);
                byte temp = raf.readByte();
                raf.seek(i);
                raf.writeByte(temp);
            }
            raf.seek(skip);
            raf.write(b);
            raf.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

多线程复制文件

import java.io.File;
import java.io.FileNotFoundException;
import java.io.RandomAccessFile;
/**
 * 多线程复制文件
 * @author ChenSS 2016/11/7
 * @version 1.0
 */
public class UsingThreadRandom {
    public static void main(String[] args) throws Exception {
        File file = new File("aaa.jpg");
        startThread(4, file.length(), "aaa.jpg", "baabb.jpg");
    }

    /**
     * 开启多线程下载
     *
     * @param threadnum 线程数
     * @param fileLength 文件大小（用于确认每个线程下载多少东西）
     * @param sourseFilePath 源文件目录
     * @param targerFilePath 目标文件目录
     */
    public static void startThread(int threadnum, long fileLength,
            String sourseFilePath, String targerFilePath) {
        System.out.println("================");
        long modLength = fileLength % threadnum;
        long targetLength = fileLength / threadnum;
        for (int i = 0; i < threadnum; i++) {
            System.out.println((targetLength * i) + "-----"
                    + (targetLength * (i + 1)));
            new FileWriteThread((targetLength * i), (targetLength * (i + 1)),
                    sourseFilePath, targerFilePath).start();
        }
        if (modLength != 0) {
            new FileWriteThread((targetLength * 4), modLength, sourseFilePath,
                    targerFilePath).start();
        }
    }

    /**
     * 写线程：指定文件开始位置、目标位置、源文件、目标文件，
     */
    static class FileWriteThread extends Thread {
        private long begin;
        private long end;
        private RandomAccessFile soursefile;
        private RandomAccessFile targerFile;

        public FileWriteThread(long begin, long end, String sourseFilePath,
                String targerFilePath) {
            this.begin = begin;
            this.end = end;
            try {
                this.soursefile = new RandomAccessFile(sourseFilePath, "rw");
                this.targerFile = new RandomAccessFile(targerFilePath, "rw");
            } catch (FileNotFoundException e) {
            }
        }

        public void run() {
            try {
                soursefile.seek(begin);
                targerFile.seek(begin);
                int hasRead = 0;
                byte[] buffer = new byte[1024];
                while (begin < end && -1 != (hasRead = soursefile.read(buffer))) {
                    begin += hasRead;
                    targerFile.write(buffer, 0, hasRead);
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    soursefile.close();
                    targerFile.close();
                } catch (Exception e) {
                }
            }
        }
    }
}

多线程下载文件

测试方法

import java.io.File;

/**
 *
 * @author ChenSS 2016/11/7
 * @version 1.0
 */
public class Test {
    private static final int NUMBER = 10;
    // public static final String URL_DOWNLOAD =
    // "http://www.swsm.net/data/attachment/forum/201506/19/171831uzzeejjxke1jkgme.jpg";
    public static final String URL_DOWNLOAD = "https://ss0.bdstatic.com/5aV1bjqh_Q23odCf/static/superman/img/logo/bd_logo1_31bdc765.png";
    public static final String PATH_TARGET = "F:/temp/download/";

    public static void main(String[] args) {
        Loader loder = new Loader();
        File file = loder.createFile(PATH_TARGET, URL_DOWNLOAD);
        loder.startLoadThread(NUMBER, file, URL_DOWNLOAD);
    }
}

开线程，如何分线程代码逻辑

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.net.URL;
import java.net.URLConnection;

/**
 *
 * @author ChenSS 2016/11/7
 * @version 1.0
 */
public class Loader {
    /**
     * 创建目标文件(希望保存的文件和下载的同名)
     *
     * @param targetPath
     *            目标路径
     * @param sourseURL
     *            根据源URL获取文件名
     * @return
     */
    public File createFile(String targetPath, String sourseURL) {
        return new File(targetPath
                + sourseURL.substring(sourseURL.lastIndexOf("/") + 1));
    }

    /**
     * 如果出现不整除的情况(如:11字节,4个线程,每个线程3字节,多出1字节)，但是实际上RandomAccessFile的read()
     * 读到文件尾会返回-1,因此不考虑余数问题
     *
     * @param threadNum
     *            线程数量
     * @param targetFile
     *            目标文件
     * @param sourseURL
     *            源文件URL
     */
    public void startLoadThread(int threadNum, File targetFile, String sourseURL) {
        try {
            // 网络连接
            URLConnection connection = new URL(sourseURL).openConnection();
            long sourseSize = connection.getContentLengthLong();
            // 为目标文件分配空间
            this.openSpace(targetFile, sourseSize);
            // 分线程下载文件
            long avgSize = sourseSize / threadNum + 1;
            for (int i = 0; i < threadNum; i++) {
                System.out
                        .println(avgSize * i + "------" + (avgSize * (i + 1)));
                new Thread(new DownloadsTask(avgSize * i, avgSize * (i + 1),
                        targetFile, sourseURL)).start();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 为目标文件分配空间
     *
     * @param targetfile
     *            目标文件
     * @param sourseSize
     *            源文件大小
     */
    private void openSpace(File targetfile, Long sourseSize) {
        RandomAccessFile randomAccessFile = null;
        try {
            randomAccessFile = new RandomAccessFile(targetfile, "rw");
            randomAccessFile.setLength(sourseSize);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (randomAccessFile != null)
                    randomAccessFile.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

实现Runnable，线程下载逻辑

import java.io.BufferedInputStream;
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.net.URL;
import java.net.URLConnection;

/**
 *
 * @author ChenSS 2016/11/7
 * @version 1.0
 */
public class DownloadsTask implements Runnable {
    private long start;
    private long end;
    private File file;
    private String loadUrl;

    /**
     * 构造函数
     *
     * @param start
     *            开始位置
     * @param end
     *            结束位置
     * @param targetFile
     *            目标文件
     * @param loadUrl
     *            下载网址
     */
    public DownloadsTask(long start, long end, File targetFile, String loadUrl) {
        this.start = start;
        this.end = end;
        this.file = targetFile;
        this.loadUrl = loadUrl;
    }

    @Override
    public void run() {
        BufferedInputStream bufferedInputStream = null;
        RandomAccessFile randomAccessFile = null;
        try {
            URL url = new URL(loadUrl);
            URLConnection conn = url.openConnection();
            bufferedInputStream = new BufferedInputStream(conn.getInputStream());
            randomAccessFile = new RandomAccessFile(file, "rw");

            // 源文件和目标文件的指针指向同一个位置
            bufferedInputStream.skip(start);
            randomAccessFile.seek(start);

            long readLen = end - start;
            // 如果比默认长度小，就没必要按照默认长度读取文件了
            byte[] bs = new byte[(int) (2048 < readLen ? 2048 : readLen)];
            while (start < end
                    && (readLen = bufferedInputStream.read(bs)) != -1) {
                start += readLen;
                randomAccessFile.write(bs, 0, (int) readLen);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //关闭流
            try {
                if (null != bufferedInputStream)
                    bufferedInputStream.close();
                if (null != randomAccessFile)
                    randomAccessFile.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}