java实现文件拷贝的七种方式

最新推荐文章于 2024-06-18 06:15:00 发布
最新推荐文章于 2024-06-18 06:15:00 发布
阅读量3k 收藏 43
点赞数 5
分类专栏： java 文章标签： java stream io NIO
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zjx2016/article/details/104160069
版权

文章目录

1. 通过字节流实现文件的拷贝
  /**
     * 通过字节流实现文件的拷贝
     * @param sourcePath 源文件路径
     * @param targetPath 目标文件路径
     */
    public static void copyFileByStream(String sourcePath,String targetPath){
        //源文件路径
        File source = new File(sourcePath);
        //目标文件路径
        File target = new File(targetPath);

        //如果源文件不存在则不能拷贝
        if(!source.exists()){
            return;
        }
        //如果目标文件目录不存在则创建
        if(!target.getParentFile().exists()){
            target.getParentFile().mkdirs();
        }

        try {
            //实现文件的拷贝
            InputStream inputStream = new FileInputStream(source);
            OutputStream outputStream = new FileOutputStream(target);
            int temp = 0;
            //每次读取1024个字节
            byte[] data = new byte[1024];
            //将每次读取的数据保存到字节数组里面，并且返回读取的个数
            while ((temp = inputStream.read(data)) != -1){
                //输出数组
                outputStream.write(data,0,temp);
            }

            inputStream.close();
            outputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
2. 通过字符流实现文件拷贝

使用字符流只能拷贝文本文件

    /**
     * 通过字符流实现文件的拷贝
     *
     * @param sourcePath 源文件路径
     * @param targetPath 目标文件路径
     */
    public static void copyFileByReaderAndWriter(String sourcePath, String targetPath) {
        //源文件路径
        File source = new File(sourcePath);
        //目标文件路径
        File target = new File(targetPath);

        //如果源文件不存在则不能拷贝
        if (!source.exists()) {
            return;
        }
        //如果目标文件目录不存在则创建
        if (!target.getParentFile().exists()) {
            target.getParentFile().mkdirs();
        }

        FileReader in = null;
        FileWriter out = null;
        try {
            //字符输入流和字符输出流
            in = new FileReader(source);
            out = new FileWriter(target);

            char[] c = new char[1024];
            int temp = 0;
            //每次读取1024个字符
            while ((temp = in.read(c)) != -1) {
                //输出到文件
                out.write(c, 0, temp);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭流
            try {
                if (in != null) {
                    in.close();
                }
                if (out != null) {
                    out.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
3. 通过字节缓冲流实现文件拷贝
/**
     * 通过字节缓冲流实现文件的拷贝
     *
     * @param sourcePath 源文件路径
     * @param targetPath 目标文件路径
     */
    public static void copyFileByBuffered(String sourcePath, String targetPath){
        //源文件路径
        File source = new File(sourcePath);
        //目标文件路径
        File target = new File(targetPath);

        //如果源文件不存在则不能拷贝
        if (!source.exists()) {
            return;
        }
        //如果目标文件目录不存在则创建
        if (!target.getParentFile().exists()) {
            target.getParentFile().mkdirs();
        }

        InputStream in = null;
        OutputStream out = null;
        try {
            //字节缓冲输入流和字节缓冲输出流
            in = new BufferedInputStream(new FileInputStream(source));
            out = new BufferedOutputStream(new FileOutputStream(target));

            byte[] b = new byte[1024];
            int temp = 0;
            //每次读取一个1024的字节数组
            while((temp = in.read(b)) != -1){
                //输出到文件
                out.write(b,0,temp);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            //关闭流
            try {
                if (in != null) {
                    in.close();
                }
                if (out != null) {
                    out.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
4. 通过字符缓冲流拷贝文件

字符缓冲流只能读取文本文件

 /**
     * 通过字符缓冲流实现文件的拷贝
     *
     * @param sourcePath 源文件路径
     * @param targetPath 目标文件路径
     */
    public static void copyFileByBufferedChar(String sourcePath, String targetPath){
        //源文件路径
        File source = new File(sourcePath);
        //目标文件路径
        File target = new File(targetPath);

        //如果源文件不存在则不能拷贝
        if (!source.exists()) {
            return;
        }
        //如果目标文件目录不存在则创建
        if (!target.getParentFile().exists()) {
            target.getParentFile().mkdirs();
        }

        BufferedReader in = null;
        BufferedWriter out = null;

        try {
            //字符缓冲输入流和字符缓冲输出流
            in = new BufferedReader(new FileReader(source));
            out = new BufferedWriter(new FileWriter(target));

            //读取文件（每次读取一行）
            String temp = null;
            while((temp = in.readLine()) != null){
                //输出到文件
                out.write(temp);
            }

        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            //关闭流
            try {
                if (in != null) {
                    in.close();
                }
                if (out != null) {
                    out.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
5. 通过JAVA NIO 非直接缓冲区拷贝文件
   /**
     * 通过JAVA NIO 非直接缓冲区拷贝文件
     *
     * @param sourcePath 源文件路径
     * @param targetPath 目标文件路径
     */
    public static void copyFileByChannel(String sourcePath, String targetPath) {
        FileChannel outChannel = null;
        FileChannel inChannel = null;

        FileInputStream fis = null;
        FileOutputStream fos = null;

        try {
            fis = new FileInputStream(sourcePath);
            fos = new FileOutputStream(targetPath);

            //获取通道
            inChannel = fis.getChannel();
            outChannel = fos.getChannel();

            //分配指定大小的缓冲区
            ByteBuffer buf = ByteBuffer.allocate(1024);

            while (inChannel.read(buf) != -1) {
                //转换为读取数据模式
                buf.flip();
                //写入到磁盘
                outChannel.write(buf);
                //清空缓冲区
                buf.clear();
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //关闭流
            try {
                if (outChannel != null) {
                    outChannel.close();
                }
                if (inChannel != null) {
                    inChannel.close();
                }
                if (fis != null) {
                    fis.close();
                }
                if (fos != null) {
                    fos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
6. 通过JAVA NIO 直接缓冲区拷贝文件
/**
     * 通过JAVA NIO 直接缓冲区拷贝文件（内存映射文件）
     *
     * @param sourcePath 源文件路径
     * @param targetPath 目标文件路径
     */
    public static void copyFileByChannelBufferd(String sourcePath, String targetPath) {
        FileChannel inChannel = null;
        FileChannel outChannel = null;
        try {
            //获取通道,StandardOpenOption.READ表示可读，StandardOpenOption.WRITE表示可写，StandardOpenOption.CREATE表示可以创建
            inChannel = FileChannel.open(Paths.get(sourcePath), StandardOpenOption.READ);
            outChannel = FileChannel.open(Paths.get(targetPath), StandardOpenOption.WRITE, StandardOpenOption.READ, StandardOpenOption.CREATE);

            //创建内存映射文件
            MappedByteBuffer inMapped = inChannel.map(FileChannel.MapMode.READ_ONLY, 0, inChannel.size());
            MappedByteBuffer outMapped = outChannel.map(FileChannel.MapMode.READ_WRITE, 0, inChannel.size());

            //直接操作内存映射文件
            byte[] buf = new byte[inMapped.limit()];
            inMapped.get(buf);
            outMapped.put(buf);

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭流
            try {
                if (outChannel != null) {
                    outChannel.close();
                }
                if (inChannel != null) {
                    inChannel.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
7. 通过JAVA NIO 通道传输拷贝文件

方式一

 /**
     *  通过JAVA NIO 通道传输拷贝文件
     *
     * @param sourcePath 源文件路径
     * @param targetPath 目标文件路径
     */
    public static void copyFileByChannelTransfer(String sourcePath, String targetPath) {
        FileChannel inChannel = null;
        FileChannel outChannel = null;
        try {
            //获取通道
            inChannel = FileChannel.open(Paths.get(sourcePath), StandardOpenOption.READ);
            outChannel = FileChannel.open(Paths.get(targetPath),StandardOpenOption.WRITE,StandardOpenOption.READ,StandardOpenOption.CREATE);

            inChannel.transferTo(0,inChannel.size(),outChannel);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //关闭流
            try {
                if (outChannel != null) {
                    outChannel.close();
                }
                if (inChannel != null) {
                    inChannel.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

方式二

 /**
     *  通过JAVA NIO 通道传输拷贝文件
     *
     * @param sourcePath 源文件路径
     * @param targetPath 目标文件路径
     */
    public static void copyFileByChannelTransfer2(String sourcePath, String targetPath) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        FileChannel inChannel = null;
        FileChannel outChannel = null;
        try {
            fis = new FileInputStream(sourcePath);
            fos = new FileOutputStream(targetPath);

            //获取通道
            inChannel = fis.getChannel();
            outChannel = fos.getChannel();

            inChannel.transferTo(0,inChannel.size(),outChannel);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //关闭流
            try {
                if (outChannel != null) {
                    outChannel.close();
                }
                if (inChannel != null) {
                    inChannel.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
使用示例
        String source = "e:\\demo\\纵天神帝.txt";
        String target = "e:\\demo\\";
        long time1 = System.currentTimeMillis();
        copyFileByStream(source, target + "1.txt");
        System.out.println("通过字节流实现文件的拷贝耗时：" + (System.currentTimeMillis() - time1));

        long time2 = System.currentTimeMillis();
        copyFileByReaderAndWriter(source, target + "2.txt");
        System.out.println("通过字符流实现文件的拷贝耗时：" + (System.currentTimeMillis() - time2));

        long time3 = System.currentTimeMillis();
        copyFileByBuffered(source, target + "3.txt");
        System.out.println("通过字节缓冲流实现文件的拷贝耗时：" + (System.currentTimeMillis() - time3));

        long time4 = System.currentTimeMillis();
        copyFileByBufferedChar(source, target + "4.txt");
        System.out.println("通过字符缓冲流实现文件的拷贝耗时：" + (System.currentTimeMillis() - time4));

        long time5 = System.currentTimeMillis();
        copyFileByChannel(source, target + "5.txt");
        System.out.println("通过JAVA NIO通道（非直接缓冲区）实现文件的拷贝耗时：" + (System.currentTimeMillis() - time5));

        long time6 = System.currentTimeMillis();
        copyFileByChannelBufferd(source, target + "6.txt");
        System.out.println("通过JAVA NIO通道（直接缓冲区）实现文件的拷贝耗时：" + (System.currentTimeMillis() - time6));

        long time7 = System.currentTimeMillis();
        copyFileByChannelTransfer(source, target + "7.txt");
        System.out.println("通过JAVA NIO通道传输实现文件的拷贝耗时：" + (System.currentTimeMillis() - time7));

        long time8 = System.currentTimeMillis();
        copyFileByChannelTransfer(source, target + "8.txt");
        System.out.println("通过JAVA NIO通道传输2实现文件的拷贝耗时：" + (System.currentTimeMillis() - time8));

通过测试发现，使用JAVA NIO通道传输、JAVA NIO通道直接缓冲区以及字节缓冲流拷贝文件效率最高

zhaojiaxing0216
关注
  • 5
    点赞
  • 踩
  • 43
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java实现文件复制
05-26
使用java创建文件并复制到另一个文件中
Java有几种文件拷贝方式？哪一种最高效？
weixin_42022756的博客
07-28 625
典型回答 Java 有多种比较典型的文件拷贝实现方式，比如： 利用 java.io 类库，直接为源文件构建一个 FileInputStream 读取，然后再为目标文件构建一个 FileOutputStream，完成写入工作。 public static void copyFileByStream(File source, File dest) throws IOException { try (InputStream is = new FileInputStream(source
Java 面试题：Java 的文件拷贝方式有几种？哪一种最高效？
最新发布
栗筝i的博客
06-18 1646
在Java编程中，文件操作是常见且重要的任务之一，其中文件拷贝（File Copy）是一种基本操作。Java提供了多种方式来实现文件拷贝，每种方式在性能、易用性和灵活性上各有优劣。了解并选择最适合的文件拷贝方法，对于提高程序的性能和效率至关重要。
java 传输 大文件_java高效实现大文件拷贝功能
weixin_31600439的博客
02-12 1264
在java中，FileChannel类中有一些优化方法可以提高传输的效率，其中transferTo( )和 transferFrom( )方法允许将一个通道交叉连接到另一个通道，而不需要通过一个缓冲区来传递数据。只有FileChannel类有这两个方法，因此 channel-to-channel 传输中通道之一必须是 FileChannel。不能在sock通道之间传输数据，不过socket 通道实...
Java实现文件的拷贝
DXGD_ic的博客
05-01 4258
前言 大多数应用程序都需要实现与设备之间的数据传输，例如键盘可以输入数据，显示器可以显示程序的运行结果等。在Java中，将这种通过不同输入输出设备（键盘，内存，显示器，网络等）之间的数据传输抽象表述为“流”，程序允许通过流的方式与输入输出设备进行数据传输。Java中的“流”都位于java.io包里，称位IO（输入输出）流 例如文件的拷贝就需要通过输入输出流来实现，以下案例可供参考 一、步骤 在eclipse中新建Java项目命名为FileCopy，并在当前目录下创建文件夹source和target，然后在
java 文件的拷贝_Java实现文件拷贝的4种方法.
weixin_29612723的博客
02-22 261
使用 java 进行文件拷贝 相信很多人都会用,,不过效率上是否最好呢?最近看了看NIO决定试一试 java NIO 到底有什么性能的提升.第一种方法:古老的方式public static long forJava(File f1,File f2) throwsException{long time=newDate().getTime();int length=2097152;FileInput...
Java实现文件拷贝的方法
kecongxiao的博客
09-13 444
java有两种文件流的 字符流：Reader/Writer 字节流：InputStream/OutputStream 如果文件不是普通的文本类型的话，就不能使用字符流了，所以通用的文件流还是字节流。这里使用字节流实现文件拷贝。 使用java.io.File中的方法 public static void copyByFileStreams(File source, File dest){ Fi
java文件复制代码片断(java实现文件拷贝)
09-04
本文将深入探讨如何使用Java实现文件的高效复制，主要涉及以下几个关键知识点： 1. **Java文件操作**： Java 提供了 `java.io` 包，其中包含了许多类来处理文件操作，如 `File` 类用于表示文件和目录，`...
java高效实现大文件拷贝功能
08-26
"java高效实现大文件拷贝功能" java高效实现大文件拷贝功能是指通过使用Java语言实现大文件的高效拷贝。这种方法可以极其快速地传输大量的数据，特别是在底层操作系统提供本地支持的时候。 在Java中，FileChannel...
java代码实现文件的拷贝
08-06
Java.io 包几乎包含了所有操作输入、输出需要的类。所有这些流类代表了输入源和输出目标。 Java.io 包中的流支持很多种格式，比如：基本类型、对象、本地化字符集等等
文件复制（java代码实现）
03-21
1）在FileCopy类中，建立copy方法，实现文件复制的内容； 2）程序中需要考虑输入输出异常处理； 3）在dos控制台窗口环境下，通过命令行参数运行程序。
用java实现文件拷贝
09-02
Java实现文件拷贝的小程序 本资源是一个使用Java语言实现文件拷贝的小程序，具有很实用的功能。下面是对这个小程序的详细解释和知识点总结： 文件拷贝的基本概念 文件拷贝是将一个文件的内容复制到另一个文件中，...
java复制文件的4种方式及拷贝文件到另一个目录下的实例代码
08-27
在 Java 中没有一个内置的复制文件的方法，但是有多种方式可以实现文件复制操作。下面我们将介绍 Java 复制文件的 4 种方式。 使用 FileInputStream 和 FileOutputStream 复制文件 这是最经典的方式将一个文件的...
JAVA实现文件拷贝进度条同步显示
11-02
文件拷贝的同时，进度条同步显示拷贝进度。只需要修改源文件地址与目标文件地址即可
Java实现文件拷贝的4种方法
weixin_34198762的博客
12-26 157
2019独角兽企业重金招聘Python工程师标准>>> ...
Java文件夹复制
来杯咖啡，随便聊聊。
05-14 272
利用Java复制文件到处都可以用到，这里总结了一个类供大家参考。里面总共有两个方法： public static boolean copyFile(String srcFileName, String destFileName,boolean overlay); public static boolean copyDirectory(String srcDirName, String dest...
java实现文件拷贝（附完整源码）
05-26
以下是Java实现文件拷贝的完整源码示例： ```java import java.io.*; public class FileCopy { public static void copyFile(String srcPath, String destPath) { File srcFile = new File(srcPath); File ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值