精华内容
下载资源
问答
  • java文件复制方法Java copy file is a very common operation. But java.io.File class doesn’t have any shortcut method to copy a file from source to destination. Here we will learn about four different ...

    java文件复制方法

    Java copy file is a very common operation. But java.io.File class doesn’t have any shortcut method to copy a file from source to destination. Here we will learn about four different ways we can copy file in java.

    Java复制文件是非常常见的操作。 但是java.io.File类没有任何快捷方式将文件从源复制到目标。 在这里,我们将学习四种在java中复制文件的方法。

    Java复制文件 (Java Copy File)

    1. Java Copy File – Stream

      Java复制文件–流

    This is the conventional way of file copy in java. Here we create two Files – source and destination. Then we create InputStream from source and write it to the destination file using OutputStream for java copy file operation.

    这是Java中文件复制的常规方式。 在这里,我们创建两个文件-源文件和目标文件。 然后,我们从源创建InputStream并使用OutputStream进行java复制文件操作,将其写入目标文件。

    Here is the method that can be used for java copy file using streams.

    这是可用于使用流的Java复制文件的方法。

    private static void copyFileUsingStream(File source, File dest) throws IOException {
        InputStream is = null;
        OutputStream os = null;
        try {
            is = new FileInputStream(source);
            os = new FileOutputStream(dest);
            byte[] buffer = new byte[1024];
            int length;
            while ((length = is.read(buffer)) > 0) {
                os.write(buffer, 0, length);
            }
        } finally {
            is.close();
            os.close();
        }
    }
    1. Java Copy File – java.nio.channels.FileChannel

      Java复制文件– java.nio.channels.FileChannel

    Java NIO classes were introduced in Java 1.4 and FileChannel can be used to copy file in java. According to transferFrom() method javadoc, this way of copy file is supposed to be faster than using Streams for java copy files.

    Java NIO类是在Java 1.4中引入的,FileChannel可用于在Java中复制文件。 根据transferFrom()方法javadoc,这种复制文件的方式应该比使用Streams进行Java复制文件要快。

    Here is the method that can be used to copy a file using FileChannel.

    这是可以使用FileChannel复制文件的方法。

    private static void copyFileUsingChannel(File source, File dest) throws IOException {
        FileChannel sourceChannel = null;
        FileChannel destChannel = null;
        try {
            sourceChannel = new FileInputStream(source).getChannel();
            destChannel = new FileOutputStream(dest).getChannel();
            destChannel.transferFrom(sourceChannel, 0, sourceChannel.size());
           }finally{
               sourceChannel.close();
               destChannel.close();
       }
    }
    1. Java Copy File – Apache Commons IO FileUtils

      Java复制文件– Apache Commons IO FileUtils

    Apache Commons IO FileUtils.copyFile(File srcFile, File destFile) can be used to copy file in java. If you are already using Apache Commons IO in your project, it makes sense to use this for code simplicity. Internally it uses Java NIO FileChannel, so you can avoid this wrapper method if you are not already using it for other functions.

    Apache Commons IO FileUtilscopyFile(File srcFile,File destFile)可用于在Java中复制文件。 如果您已经在项目中使用Apache Commons IO,则使用它来简化代码是很有意义的。 它在内部使用Java NIO FileChannel,因此如果尚未将其用于其他功能,则可以避免使用该包装器方法。

    Here is the method for using apache commons io for java copy file operation.

    这是将apache commons io用于Java复制文件操作的方法。

    private static void copyFileUsingApacheCommonsIO(File source, File dest) throws IOException {
        FileUtils.copyFile(source, dest);
    }
    1. Java Copy File – Files class

      Java复制文件–文件类

    If you are working on Java 7 or higher, you can use Files class copy() method to copy file in java. It uses File System providers to copy the files.

    如果您使用的是Java 7或更高版本,则可以使用Files类的copy()方法在Java中复制文件。 它使用文件系统提供程序来复制文件。

    private static void copyFileUsingJava7Files(File source, File dest) throws IOException {
        Files.copy(source.toPath(), dest.toPath());
    }

    Now to find out which is the fastest method, I wrote a test class and executed above methods one-by-one for copy file of 1 GB. In each call, I used different files to avoid any benefit to later methods because of caching.

    现在,找出哪种方法最快,我编写了一个测试类,并针对1 GB的副本文件逐个执行了上述方法。 在每个调用中,我都使用了不同的文件,以避免由于缓存而对以后的方法产生任何好处。

    package com.journaldev.files;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.nio.channels.FileChannel;
    import java.nio.file.Files;
    
    import org.apache.commons.io.FileUtils;
    
    public class JavaCopyFile {
    
        public static void main(String[] args) throws InterruptedException, IOException {
            File source = new File("/Users/pankaj/tmp/source.avi");
            File dest = new File("/Users/pankaj/tmp/dest.avi");
    
            //copy file conventional way using Stream
            long start = System.nanoTime();
            copyFileUsingStream(source, dest);
            System.out.println("Time taken by Stream Copy = "+(System.nanoTime()-start));
            
            //copy files using java.nio FileChannel
            source = new File("/Users/pankaj/tmp/sourceChannel.avi");
            dest = new File("/Users/pankaj/tmp/destChannel.avi");
            start = System.nanoTime();
            copyFileUsingChannel(source, dest);
            System.out.println("Time taken by Channel Copy = "+(System.nanoTime()-start));
            
            //copy files using apache commons io
            source = new File("/Users/pankaj/tmp/sourceApache.avi");
            dest = new File("/Users/pankaj/tmp/destApache.avi");
            start = System.nanoTime();
            copyFileUsingApacheCommonsIO(source, dest);
            System.out.println("Time taken by Apache Commons IO Copy = "+(System.nanoTime()-start));
            
            //using Java 7 Files class
            source = new File("/Users/pankaj/tmp/sourceJava7.avi");
            dest = new File("/Users/pankaj/tmp/destJava7.avi");
            start = System.nanoTime();
            copyFileUsingJava7Files(source, dest);
            System.out.println("Time taken by Java7 Files Copy = "+(System.nanoTime()-start));        
        }
    }

    Here is the output of the above program, note that I commented above code to make sure every time only one method is used for java file copy operation.

    这是上面程序的输出,请注意,我注释了上面的代码,以确保每次仅将一种方法用于Java文件复制操作。

    Time taken by Stream Copy = 44582575000
    Time taken by Channel Copy = 104138195000
    Time taken by Apache Commons IO Copy = 108396714000
    Time taken by Java7 Files Copy = 89061578000

    From the output, it’s clear that Stream Copy is the best way to copy File in Java. But it’s a very basic test. If you are working on a performance intensive project, then you should try out different methods for java copy file and note down the timings to figure out the best approach for your project.

    从输出中可以明显看出,Stream Copy是用Java复制File的最佳方法。 但这是一个非常基本的测试。 如果您正在处理一个性能密集型项目,则应尝试使用Java复制文件的不同方法,并记下时间安排,以找到适合您项目的最佳方法。

    You should also play around different ways of java copy files based on your average size of the file.

    您还应该根据文件的平均大小来尝试不同的Java复制文件方式。

    I have created a YouTube video for 4 ways to copy the file in java, you can watch it to learn more.

    我已经创建了一种YouTube视频,提供了4种方法来复制Java文件,您可以观看它以了解更多信息。

    演示地址

    翻译自: https://www.journaldev.com/861/java-copy-file

    java文件复制方法

    展开全文
  • Java多线程实现复制文件

    千次阅读 2018-09-24 15:55:33
    * 线程实现文件从一目录复制到另一目录 * @param sourceFile:给定源文件路径名 * @param desPath:复制文件路径 * @return */ 代码实现如下: package com.tulun.thread; import java.io.File; import...
    /**
     * 实现文件复制功能
     * 多线程实现文件从一个目录复制到另一个目录
     * @param sourceFile:给定源文件路径名
     * @param desPath:复制点文件路径
     * @return
     */
    

    代码实现如下:

    package com.tulun.thread;
    
    import java.io.File;
    import java.io.FileNotFoundException;
    import java.io.RandomAccessFile;
    
    /**
     * 多线程复制文件
     */
    public class ThreadCopyFile {
        public static void main(String[] args) throws Exception {
            File file = new File("D:\\demo\\erke\\test.txt");
            startThread(5, file.length(), "D:\\demo\\erke\\test.txt",
                    "D:\\demo\\erke\\test1.txt");
        }
    
        /**
         * 开启多线程复制
         * 
         * @param threadnum   线程数
         *  
         * @param fileLength   文件大小(用于确认每个线程下载多少东西)
         *            
         * @param sourseFilePath    源文件目录
         *           
         * @param desFilePath     目标文件目录
         *           
         */
        public static void startThread(int threadnum, long fileLength, String sourseFilePath, String desFilePath) {
            System.out.println(fileLength);
            long modLength = fileLength % threadnum;
            System.out.println("modLength:" + modLength);
            long desLength = fileLength / threadnum;
            System.out.println("desLength:" + desLength);
            for (int i = 0; i < threadnum; i++) {
                System.out.println((desLength * i) + "-----" + (desLength * (i + 1)));
                new FileWriteThread((desLength * i), (desLength * (i + 1)), sourseFilePath, desFilePath).start();
            }
            if (modLength != 0) {
                System.out.println("最后的文件写入");
                System.out.println((desLength * threadnum) + "-----" + (desLength * threadnum + modLength));
                new FileWriteThread((desLength * threadnum), desLength * threadnum + modLength + 1, sourseFilePath,
                        desFilePath).start();
            }
        }
    
        /**
         * 写线程:指定文件开始位置、目标位置、源文件、目标文件,
         */
        static class FileWriteThread extends Thread {
            private long begin;
            private long end;
            private RandomAccessFile sourseFile;
            private RandomAccessFile desFile;
    
            public FileWriteThread(long begin, long end, String sourseFilePath, String desFilePath) {
                this.begin = begin;
                this.end = end;
                try {
                    this.sourseFile = new RandomAccessFile(sourseFilePath, "rw");
                    this.desFile = new RandomAccessFile(desFilePath, "rw");
                } catch (FileNotFoundException e) {
                }
            }
    
            public void run() {
                try {
                    sourseFile.seek(begin);
                    desFile.seek(begin);
                    int hasRead = 0;
                    byte[] buffer = new byte[1];
                    while (begin < end && -1 != (hasRead = sourseFile.read(buffer))) {
                     	begin += hasRead;
                        desFile.write(buffer, 0, hasRead);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    try {
                        sourseFile.close();
                        desFile.close();
                    } catch (Exception e) {
                    }
                }
            }
        }
    }
    
    

    运行结果:
    在这里插入图片描述

    展开全文
  • Java复制文件

    千次阅读 2014-11-21 11:11:43
    Java之中经常有重命名文件复制文件的需求,重命名文件使用File.remaneTo()。但是java并没有对复制文件提供接口。现在只能猜测一下原因,可能是因为复制文件有多种形式,需要根据不同的情况作出选择,这自主权...

    在Java之中经常有重命名文件和复制文件的需求,重命名文件使用File.remaneTo()。但是java并没有对复制文件提供接口。现在只能猜测一下原因,可能是因为复制文件有多种形式,需要根据不同的情况作出选择,这个自主权交给了程序员。

    1.普通的缓冲输入输出流复制文件

    public static void copyFile(File source, File destination){
    	InputStream fis = null;
    	OutputStream fos = null;
    	try {
    		fis = new BufferedInputStream(new FileInputStream(source));	
    		fos = new BufferedOutputStream(new FileOutputStream(destination));
    		byte[] buf = new byte[1024];
    		int i;
    		while((i = fis.read(buf)) != -1){
    			fos.write(buf, 0 ,i);
    		}
        } catch (Exception e) {
    		e.printStackTrace();
     	}finally{
    	 	try{
    		  	fis.close();
    		  	fos.close();
    	  	}catch (IOException e){
    		 	e.printStackTrace();
    	 	}
      	}
    }

    这种是最为常见的复制文件的方式,一般情况下就用这个就好了。

    2.用文件通道(FileChannel)来实现文件复制

    public void fileChannelCopy(File s, File t) {
        FileInputStream fi = null;
        FileOutputStream fo = null;
        FileChannel in = null;
        FileChannel out = null;
        try {
            fi = new FileInputStream(s);
            fo = new FileOutputStream(t);
            in = fi.getChannel();//流和一个文件通道绑定了,使用getChannel获取与该文件绑定的唯一文件通道
            out = fo.getChannel();//得到对应的文件通道
            in.transferTo(0, in.size(), out);//连接两个通道,并且从in通道读取,然后写入out通道
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fi.close();
                in.close();
                fo.close();
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    从上面可以看出文件和流绑定,流和文件通道相绑定。


    通常FileChannel复制文件的速度比BufferedInputStream/BufferedOutputStream复制文件的速度快了近三分之一。在复制大文件的时候更加体现出FileChannel的速度优势。而且FileChannel是多并发线程安全的。


    所以应用场景为:1.大文件,2.并发


    展开全文
  • 昨天晚上做了个实验,用多个线程复制7个文件和单个线程复制7个文件(总共约1.7G)比较,代码如下:import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io....

    昨天晚上做了个实验,用多个线程复制7个文件和单个线程复制7个文件(总共约1.7G)比较,代码如下:

    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.util.concurrent.CountDownLatch;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    
    public class T3 {
    
    	public static void main(String[] args) throws IOException, InterruptedException {
    		
    		File path = new File("E:\\tmp\\1");
    		File[] listFiles = path.listFiles();
    		ExecutorService exec=Executors.newFixedThreadPool(listFiles.length);
    		CountDownLatch c = new CountDownLatch(listFiles.length);
    		System.out.println("begin copy");
    		long b=System.nanoTime();
    		one(listFiles,c);
    //		two(listFiles, exec,c);	
    		c.await();
    		long n=System.nanoTime();
    		System.out.println("copy over,times="+(n-b));
    	}
    	
    	public static void one(File[] listFiles,CountDownLatch c) throws IOException{
    		for(File f:listFiles){
    			FileInputStream fis=null;
    			FileOutputStream fos=null;
    			try{
    				 fis = new FileInputStream(f);
    				 fos = new FileOutputStream(new File("c://tmp//"+f.getName()));
    				byte[] bs=new byte[1024*1024*10];
    				int n=-1;
    				while((n=fis.read(bs))>0){
    					fos.write(bs, 0, n);
    				}
    			}finally{
    				if(fis!=null) fis.close();
    				if(fos!=null) fos.close();
    				System.out.println(Thread.currentThread().getName()+" copy "+f.getName()+" ok");
    				c.countDown();
    			}
    			
    		}
    	}
    	
    	public static void two(File[] files,ExecutorService exec,CountDownLatch c){
    		for(File f:files){
    //			exec.execute(new R(f,c));
    			new Thread(new R(f,c)).start();
    		}
    		exec.shutdown();
    	}
    
    }
    class R implements Runnable{
    	private File f;
    	private CountDownLatch c;
    	public R(File f,CountDownLatch c){
    		this.f=f;this.c=c;
    	}
    
    	@Override
    	public void run() {
    		FileInputStream fis=null;
    		FileOutputStream fos=null;
    		try{
    			 fis = new FileInputStream(f);
    			 fos = new FileOutputStream(new File("c://tmp//"+f.getName()));
    			byte[] bs=new byte[1024*1024];
    			int n=-1;
    			while((n=fis.read(bs))>0){
    				fos.write(bs, 0, n);
    			}
    		}catch(Exception e){
    			e.printStackTrace();
    		}finally{
    			try{
    				if(fis!=null) fis.close();
    				if(fos!=null) fos.close();
    			}catch (Exception e){
    				e.printStackTrace();
    			}
    			System.out.println(Thread.currentThread().getName()+" copy "+f.getName()+" ok");
    			c.countDown();
    		}
    		
    	}
    	
    }

    多线程明显比单线程慢很多。

    打开任务管理器,单线程情况下,磁盘利用率已经99了,读写速度90M/s,于是降低读写速度byte[] bs=new byte[100];再次比较。单线程 磁盘利用率已经变为20左右,读写速度降到了20M/s. 多线程起初IO读写速度较高,但是7个线程都io的时候,利用率达到了99,读写速度受到限制,但是最后随着有的线程完成了任务,io读写速度又升上去了,最终多线程复制话费的时间少于单线程。

    因此想要多线程复制文件,要考虑IO读写速度,单线程磁盘利用率100了,再增加线程也没用。

    展开全文
  • java合并多个文件的两种方式

    万次阅读 2018-03-12 10:45:48
    java多个线程下载文件或处理较大文件是可能会切分成多个文件,处理完成后需要合并成一个文件。Java中合并子文件最容易想到的就是利用BufferedStream进行读写。利用BufferedStream合并多个文件public static ...
  • Java文件快速copy复制

    万次阅读 多人点赞 2020-12-29 16:55:18
    最近学习netty的时候发现nio包下有FileChannel类,经过了解这类作用是专门负责传输文件的通道,支持线程,而且经过测试FileChannel复制文件的速度比BufferedInputStream/BufferedOutputStream复制文件的速度...
  • Java实现文件复制

    千次阅读 2016-04-18 18:00:26
    Java复制文件 下面介绍两种方法 一种是使用传统的缓冲输入输出流(InputStream、OutputStream)来实现 另外一种使用文件通道(FileChannel)来实现,效率上FileChannel会比InputStream快 而且文件越大对比越明显 ...
  • 4种java复制文件的方式

    千次阅读 2015-10-12 12:20:03
    本篇文章列举了4种最受欢迎的java复制文件的方式,复制文件是一重要的操作,需要的朋友可以参考下 尽管Java提供了一可以处理文件的IO操作类,但是没有一复制文件的方法。复制文件是一重要的操作,当你的...
  • java复制文件的4种方式

    千次阅读 2016-11-12 14:20:25
    摘要 尽管Java提供了一个可以处理文件的IO操作类。 但是没有一个复制文件的方法。...这是最经典的方式将一个文件的内容复制到另一个文件中。 使用FileInputStream读取文件A的字节,使用FileOutputSt
  • Java复制文件的4种方式

    万次阅读 2018-03-30 13:33:07
    java复制文件的4种方式 摘要 尽管Java提供了一可以处理文件的IO操作类。 但是没有一复制文件的方法。 复制文件是一重要的操作,当你的程序必须处理很多文件相关的时候。 然而有几种方法可以进行Java文件复制...
  • java复制更改指定文件类型、后缀名

    千次阅读 2016-06-15 11:53:02
    概述 时间太长写的什么东西都忘了,所以...这是一文件中的所有java文件复制后改成一text文件(保存在同一目录下)好了废话不说,直接看代码吧 CopyFile.java public class CopyFile { /** *
  • 复制多个文件到一个文件中

    千次阅读 2016-05-02 15:54:49
    复制多个文件到一个文件中
  • Java下合并多个文件

    万次阅读 2016-10-28 17:13:02
    Java 中如何高效合并文件
  • 使用Java复制文件及显示进度

    千次阅读 2014-12-04 21:36:11
    使用Java复制文件及显示进度 最近在学Java,今天搞了一复制文件的代码,主要是通过BufferedInputStream和BufferedOutputStream对文件进行复制 没什么技术含量,不过进过我的测试发现,对于1G以上的文件,复制时...
  • Java简单实现线程复制文件

    千次阅读 2017-08-16 21:46:51
    #简单点 ...###开启线程复制方法:线程数,文件长度,源文件,目标文件,以参数形式传入,方法里用一for循环去开辟新线程。 ###主方法:找到资源文件,调用开启线程复制方法。import java.i
  • Java编程中,复制文件的方法有很,而且经常要用到。绝大多数人都是缓冲输入输出流来实现的,我也是如此,其实在新的JDK中出现了一种用文件通道(FileChannel)来实现文件复制的方法,而且这种竟然比用文件流快了...
  • java多个文件进行压缩打包处理

    千次阅读 2018-12-06 10:16:24
    复制导入包之后直接可当工具类使用!! public class ZipUtil { private static final int BUFFER_SIZE = 2 * 1024; public static void fileListToZip(List&amp;lt;File&amp;gt; srcFiles , OutputStream ...
  • Java 高效复制文件方法

    千次阅读 2015-01-28 16:51:46
    通过FileChanel 方法复制Java文件,比通常的内存读写 方式效率要好很 public static void headCreate(File f1, File f2) { //f1 为源文件 f2 为目标文件,本方法的功能是 复制f1文件 为f2  FileInputStream ...
  • Java一次性下载多个文件

    千次阅读 2019-09-12 15:46:08
    最近项目遇到一个需求,需要一次性导出全部数据-,而且是按照500条数据一个文件。 话不说,开始。 新增Excel工具类 可以直接复制 import org.apache.poi.hssf.usermodel.*; import org.apache.poi.hssf.util....
  • Java 复制文件的高效方法

    千次阅读 2018-03-11 14:34:02
    Java编程中,复制文件的方法有很,而且经常要用到。我以前一直是缓冲输入输出流来实现的(绝大多数人都是如此),近来在研究JDK文档时发现,用文件通道(FileChannel)来实现文件复制竟然比用老方法快了近三分之...
  • java文件普通复制和NIO复制

    千次阅读 2017-04-19 14:49:02
    自从jdk1.4以后就引入了NIO文件通道的概念,并且是由io的FileinputStream...File Copyfile 复制文件File newfile 新文件 1.传统IO复制 public static void traditionCopy(File Copyfile, File newfile) throws Exce
  • java多个文件(Excel)压缩成zip,并发送给页面 方案 将多个文件夹中的文件,放入一个临时文件夹,并将临时文件夹进行压缩打包,发回给页面。 转移文件类 import java.io.File; import java.io.FileInputStream; ...
  • java 快速复制文件,移动文件

    千次阅读 2018-08-07 23:34:12
    1、File 类的renameTo方法,只移动文件,移动后源目录没有文件 File file = new File(srcFilePath+srcFileName);  File targetFile =new File(realFile);    if(!targetFile.getParentFile().exists()) {  ...
  • java实现复制excel模板(多个工作表)并下载的代码 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持,除了标准的Markdown编辑器功能,我们增加了如下几点新功能,帮助你用它写博客: 全新的界面设计 ,...
  • 快速复制大文件、多个文件

    千次阅读 2017-07-08 19:59:21
    之前写过一个copy文件的方法,30多M要复制1分多...快速复制大文件、多个文件(包含文件夹): public static void copyFile(File file, String dest) { String pathWindows = file.getAbsolutePath() + File.separ...
  • Java实现复制文件或者文件夹

    千次阅读 2019-12-05 14:33:45
    拷贝一个文件的算法比较简单,当然,可以对它进行优化,比如使用缓冲流,提高读写数据的效率等。 话不说直接上代码 import java.io.*; /** * 实现文件的拷贝 */ public class CopyFile { /** * 复制...
  • Java读取复制超大文件加速

    千次阅读 2017-06-17 11:28:44
    不考虑线程优化,单线程文件复制最快的方法是(文件越大该方法越有优势,一般比常用方法快30+%): 直接上代码: package test; import java.io.BufferedInputStream; import java.io.BufferedOutputStream; ...
  • 由于公司需求需要合并多个录音 java合并两个wav文件问题,高手帮忙解答 ...估计是没有去掉文件头尾的原因,各位大侠,如何去掉wav音频文件的头尾,将两个或者多个wav文件追加在一起呢?急求啊!!!!!

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 453,492
精华内容 181,396
关键字:

java复制多个文件

java 订阅