精华内容
下载资源
问答
  • Java文件copy拷贝的4种方式
    千次阅读
    2020-05-23 04:24:45

    要说到文件拷贝,我们最先想到的估计就是,使用Java原生的InputStream和OutputStream了,实现一边读取一边拷贝。下面就来实现以下。流操作均使用try-with-resource,让Java自己去关闭流的连接。

    1、Java原生实现

    声明一点:什么叫做追加,下面是我个人通过试验,得出的自我理解:追加是指io流关闭之后再启动一个io往里写才算追加。可以使用小的缓冲字节数组进行验证。

    @Test
    public void fileCopy(){
        try(InputStream is = new FileInputStream("src.txt");
            OutputStream os = new FileOutputStream("dest.txt", true)){  //注意OS的第二参数,是否追加。
            byte[] buffer = new byte[1024];
            int len = 0;
            while ((len=is.read(buffer)) != -1){
                os.write(buffer, 0, len);
            }
            System.out.println("拷贝完成");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    

    2、使用apache的commons-io工具类

    这个工具类跟我一开始的想法很吻合,就应该是直接用输入流输出流上这样多符合我们生活中常识啊。我一开始想着Java自己应该实现这个功能了吧,找了一圈发现自己天真了。不过还好别人帮我们实现了,也一样。

    下面这个方法只能拷贝2G以内的文件。它会首先判断你这个文件是否大于2G,如果大于就不进行后续的拷贝了,直接返回-1。小于2G就去拷贝,并返回我们这个文件的大小。

    @Test
    public void fileCopy(){
        try(InputStream in = new FileInputStream("src.txt");
            OutputStream out = new FileOutputStream("dest.txt", true)){
            int count = IOUtils.copy(in, out);  //啧啧,这多和谐啊。
            System.out.println(count);
            System.out.println("拷贝完成");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    

    只能拷贝2G太不爽了,我一个小电影就3G多,你这个方法有点逊啊。

    2.1 大文件的拷贝

    能拷贝大文件首先你名字就要有大的样子,确实copy大文件的名字就比copy多了一个large,把名字换成copyLarge就可以了,什么都不用动。返回值也是文件的大小。

    copycopyLarge有很多重载的方法,不过就这两个就够用了。

    3、使用Java的java.nio

    原来Java还真实现了,看来我只真的天真了。

    @Test
    public void fileCopy(){
        try(FileChannel in = new FileInputStream("src.txt").getChannel();
            FileChannel out = new FileOutputStream("dest.txt", true).getChannel()){
            out.transferFrom(in, 0, in.size());
            System.out.println("拷贝完成");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    

    Java的FIles类实现

    @Test
    public void fileCopy(){
        try {
            Files.copy(Paths.get("src.txt"), Paths.get("dest.txt"));  //如果dest文件存在就会报错
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("拷贝完成");
    }
    

    4、怎么能少了我们的Guava呢

    4.1 文件对文件,不支持追加

    我们不用担心文件存不存在,如果文件不存在的话,他会帮我们创建

    @Test
    public void fileCopy(){
        File src = new File("src.txt");
        File dest = new File("dest.txt");
        try {
            Files.copy(src, dest);
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("拷贝完成");
    }
    
    4.2支持追加,文件对字节输出流OutputStream
    @Test
    public void fileCopy(){
        File src = new File("src.txt");
        try (OutputStream out = new FileOutputStream("dest.txt", true)){
            Files.copy(src, out);
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("拷贝完成");
    }
    
    更多相关内容
  • Java基础之数组拷贝

    2020-12-22 08:59:23
    java中,我们可以将一个数组变量直接拷贝给另一个数组变量。但拷贝后,两个数组变量引用的是同一个数组。若改变其中一个数组中的内容,另一个数组也会同时改变。 (注:如果想打印数组内的所有值,可以使用Arrays....
  • Java拷贝

    2021-02-12 19:43:47
    1、摘要零拷贝的“零”是指用户态和内核态间copy数据的次数为零。传统的数据copy(文件到文件、client到server等)涉及到四次用户态内核态切换、四次copy。四次copy中,两次在用户态和内核态间copy需要CPU参与、两次在...

    1、摘要

    零拷贝的“零”是指用户态和内核态间copy数据的次数为零。

    传统的数据copy(文件到文件、client到server等)涉及到四次用户态内核态切换、四次copy。四次copy中,两次在用户态和内核态间copy需要CPU参与、两次在内核态与IO设备间copy为DMA方式不需要CPU参与。零拷贝避免了用户态和内核态间的copy、减少了两次用户态内核态间的切换。

    零拷贝可以提高数据传输效率,但对于需要在用户传输过程中对数据进行加工的场景(如加密)就不适合使用零拷贝。

    使用Zero Copy前后对比:

    前:

    7130162242e232e6bf8901d7f82375b9.png   , 后:

    ec9a6143ae9d6beaabff6eb68b6db2cc.png

    2、介绍

    java 的zero copy多在网络应用程序中使用。Java的libaries在linux和unix中支持zero copy,关键的api是java.nio.channel.FileChannel的transferTo(),transferFrom()方法。我们可以用这两个方法来把bytes直接从调用它的channel传输到另一个writable byte channel,中间不会使data经过应用程序,以便提高数据转移的效率。

    许多web应用都会向用户提供大量的静态内容,这意味着有很多data从硬盘读出之后,会原封不动的通过socket传输给用户。这种操作看起来可能不会怎么消耗CPU,但是实际上它是低效的:kernal把数据从disk读出来,然后把它传输给user级的application,然后application再次把同样的内容再传回给处于kernal级的socket。这种场景下,application实际上只是作为一种低效的中间介质,用来把disk file的data传给socket。

    data每次穿过user-kernel boundary,都会被copy,这会消耗cpu,并且占用RAM的带宽。幸运的是,你可以用一种叫做Zero-Copy的技术来去掉这些无谓的 copy。应用程序用zero copy来请求kernel直接把disk的data传输给socket,而不是通过应用程序传输。Zero copy大大提高了应用程序的性能,并且减少了kernel和user模式的上下文切换

    使用kernel buffer做中介(而不是直接把data传到user buffer中)看起来比较低效(多了一次copy)。然而实际上kernel buffer是用来提高性能的。在进行读操作的时候,kernel buffer起到了预读cache的作用。当写请求的data size比kernel buffer的size小的时候,这能够显著的提升性能。在进行写操作时,kernel buffer的存在可以使得写请求完全异步。

    悲剧的是,当请求的data size远大于kernel buffer size的时候,这个方法本身变成了性能的瓶颈。因为data需要在disk,kernel buffer,user buffer之间拷贝很多次(每次写满整个buffer)。

    而Zero copy正是通过消除这些多余的data copy来提升性能。

    3、传统方式及涉及到的上下文切换

    通过网络把一个文件传输给另一个程序,在OS的内部,这个copy操作要经历四次user mode和kernel mode之间的上下文切换,甚至连数据都被拷贝了四次,如下图:

    具体步骤如下:

    read() 调用导致一次从user mode到kernel mode的上下文切换。在内部调用了sys_read() 来从文件中读取data。第一次copy由DMA (direct memory access)完成,将文件内容从disk读出,存储在kernel的buffer中。

    然后请求的数据被copy到user buffer中,此时read()成功返回。调用的返回触发了第二次context switch: 从kernel到user。至此,数据存储在user的buffer中。

    send() Socket call 带来了第三次context switch,这次是从user mode到kernel mode。同时,也发生了第三次copy:把data放到了kernel adress space中。当然,这次的kernel buffer和第一步的buffer是不同的buffer。

    最终 send() system call 返回了,同时也造成了第四次context switch。同时第四次copy发生,DMA egine将data从kernel buffer拷贝到protocol engine中。第四次copy是独立而且异步的。

    bc07929312be205ef910da3cafb1afe5.png

    963031d24519fd24df5f217bf163fa36.png

    4、zero copy方式及涉及的上下文转换

    在linux 2.4及以上版本的内核中(如linux 6或centos 6以上的版本)修改了socket buffer descriptor,使网卡支持 gather operation,通过kernel进一步减少数据的拷贝操作。这个方法不仅减少了context switch,还消除了和CPU有关的数据拷贝。user层面的使用方法没有变,但是内部原理却发生了变化:

    transferTo()方法使得文件内容被copy到了kernel buffer,这一动作由DMA engine完成。 没有data被copy到socket buffer。取而代之的是socket buffer被追加了一些descriptor的信息,包括data的位置和长度。然后DMA engine直接把data从kernel buffer传输到protocol engine,这样就消除了唯一的一次需要占用CPU的拷贝操作。

    5d58d0e8f6ffd77ad75af3538a25f008.png

    f144c19c98bb5777bf26e1e25defd7e2.png

    5、Java NIO 零拷贝示例

    NIO中的FileChannel拥有transferTo和transferFrom两个方法,可直接把FileChannel中的数据拷贝到另外一个Channel,或直接把另外一个Channel中的数据拷贝到FileChannel。该接口常被用于高效的网络/文件的数据传输和大文件拷贝。在操作系统支持的情况下,通过该方法传输数据并不需要将源数据从内核态拷贝到用户态,再从用户态拷贝到目标通道的内核态,同时也减少了两次用户态和内核态间的上下文切换,也即使用了“零拷贝”,所以其性能一般高于Java IO中提供的方法。

    5.1、通过网络把一个文件从client传到server:

    8f900a89c6347c561fdf2122f13be562.png

    961ddebeb323a10fe0623af514929fc1.png

    1 /**

    2 * disk-nic零拷贝3 */

    4 classZerocopyServer {5 ServerSocketChannel listener = null;6

    7 protected voidmySetup() {8 InetSocketAddress listenAddr = new InetSocketAddress(9026);9

    10 try{11 listener =ServerSocketChannel.open();12 ServerSocket ss =listener.socket();13 ss.setReuseAddress(true);14 ss.bind(listenAddr);15 System.out.println("监听的端口:" +listenAddr.toString());16 } catch(IOException e) {17 System.out.println("端口绑定失败 : " + listenAddr.toString() + " 端口可能已经被使用,出错原因: " +e.getMessage());18 e.printStackTrace();19 }20

    21 }22

    23 public static voidmain(String[] args) {24 ZerocopyServer dns = newZerocopyServer();25 dns.mySetup();26 dns.readData();27 }28

    29 private voidreadData() {30 ByteBuffer dst = ByteBuffer.allocate(4096);31 try{32 while (true) {33 SocketChannel conn =listener.accept();34 System.out.println("创建的连接: " +conn);35 conn.configureBlocking(true);36 int nread = 0;37 while (nread != -1) {38 try{39 nread =conn.read(dst);40 } catch(IOException e) {41 e.printStackTrace();42 nread = -1;43 }44 dst.rewind();45 }46 }47 } catch(IOException e) {48 e.printStackTrace();49 }50 }51 }52

    53 classZerocopyClient {54 public static void main(String[] args) throwsIOException {55 ZerocopyClient sfc = newZerocopyClient();56 sfc.testSendfile();57 }58

    59 public void testSendfile() throwsIOException {60 String host = "localhost";61 int port = 9026;62 SocketAddress sad = newInetSocketAddress(host, port);63 SocketChannel sc =SocketChannel.open();64 sc.connect(sad);65 sc.configureBlocking(true);66

    67 String fname = "src/main/java/zerocopy/test.data";68 FileChannel fc = newFileInputStream(fname).getChannel();69 long start =System.nanoTime();70 long nsent = 0, curnset = 0;71 curnset = fc.transferTo(0, fc.size(), sc);72 System.out.println("发送的总字节数:" + curnset + " 耗时(ns):" + (System.nanoTime() -start));73 try{74 sc.close();75 fc.close();76 } catch(IOException e) {77 System.out.println(e);78 }79 }80 }

    View Code

    5.2、文件到文件的零拷贝:

    8f900a89c6347c561fdf2122f13be562.png

    961ddebeb323a10fe0623af514929fc1.png

    1 /**

    2 * disk-disk零拷贝3 */

    4 classZerocopyFile {5 @SuppressWarnings("resource")6 public static void transferToDemo(String from, String to) throwsIOException {7 FileChannel fromChannel = new RandomAccessFile(from, "rw").getChannel();8 FileChannel toChannel = new RandomAccessFile(to, "rw").getChannel();9

    10 long position = 0;11 long count =fromChannel.size();12

    13 fromChannel.transferTo(position, count, toChannel);14

    15 fromChannel.close();16 toChannel.close();17 }18

    19 @SuppressWarnings("resource")20 public static void transferFromDemo(String from, String to) throwsIOException {21 FileChannel fromChannel = newFileInputStream(from).getChannel();22 FileChannel toChannel = newFileOutputStream(to).getChannel();23

    24 long position = 0;25 long count =fromChannel.size();26

    27 toChannel.transferFrom(fromChannel, position, count);28

    29 fromChannel.close();30 toChannel.close();31 }32

    33 public static void main(String[] args) throwsIOException {34 String from = "src/main/java/zerocopy/1.data";35 String to = "src/main/java/zerocopy/2.data";36 //transferToDemo(from,to);

    37 transferFromDemo(from, to);38 }39 }

    View Code

    6、参考资料

    展开全文
  • Java NIO 文件拷贝与内容追加

    千次阅读 2019-08-02 23:13:41
    Java NIO 文件拷贝与内容追加 (后期博文会对代码中涉及的知识进行一一说明,请先自信参考进行学习。如有高人愿虚心请教学习,关于使用FileChannel和ByteBuffer以及MappedByteBuffer的文件操作方式也会在以后分享给...

    Java NIO 文件拷贝与内容追加

    (后期博文会对代码中涉及的知识进行一一说明,请先自信参考进行学习。如有高人愿虚心请教学习,关于使用FileChannel和ByteBuffer以及MappedByteBuffer的文件操作方式也会在以后分享给大家)

    下面是本次展示的代码(请多多参考API文档):

    package top.smartprinting;
    
    import java.io.IOException;
    import java.nio.file.*;
    
    /**
     * @author Chief
     * @date 2019-08-01 11:00
     * @Email MyEvery7655@gmail.com
     */
    public class Main {
    
        public static void main(String[] args) {
            //文件根路径
            String rootPath = "C:\\Users\\ThinkPad\\Desktop\\TestNio";
            //生成原文件One.txt Two.txt的Path对象
            Path pathOne = FileSystems.getDefault().getPath(rootPath, "One.txt");
            Path pathTwo = FileSystems.getDefault().getPath(rootPath, "Two.txt");
            //生成目标生成的文件JavaNio.java的Path对象
            Path pathJavaNio = FileSystems.getDefault().getPath(rootPath, "JavaNio.java");
    
            try {
                //实现文件拷贝,将One.txt文件拷贝到JavaNio.java文件中
                Files.copy(pathOne, pathJavaNio, StandardCopyOption.COPY_ATTRIBUTES, StandardCopyOption.REPLACE_EXISTING);
                //实现文件追加写入,将Two.txt文件的内容追加到JavaNio.java文件已有内容后
                Files.write(pathJavaNio, Files.readAllBytes(pathTwo), StandardOpenOption.APPEND, StandardOpenOption.CREATE, StandardOpenOption.SYNC, StandardOpenOption.WRITE);
                //实现文件追加在行尾,在行尾添加 LF(换行)、CR(回车)、}(尾花括号)
                Files.write(pathJavaNio, new byte[]{10, 13, 125}, StandardOpenOption.APPEND, StandardOpenOption.CREATE, StandardOpenOption.SYNC, StandardOpenOption.WRITE);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
    }
    

    请多多参考API文档:
    Java8 API_NIO

    代码测试时使用的文件:
    代码测试时使用的文件

    One.txt
    文件One.txt的内容

    Two.txt
    文件Two.txt的内容

    JavaNio.java(默认情况下根路径下没有创建此文件,由代码进行创建)
    生成的目标文件JavaNio.java

    展开全文
  • 在操作系统里面有一个copy命令,这个命令的主要功能是可以实现文件的拷贝处理,现在要求模拟这个命令,通过初始化参数输入拷贝的源文件路径与拷贝的目标路径实现文件的拷贝处理。需求分析:·需要实现文件的拷贝操作...

    在操作系统里面有一个copy命令,这个命令的主要功能是可以实现文件的拷贝处理,现在要求模拟这个命令,通过初始化参数输入拷贝的源文件路径与拷贝的目标路径实现文件的拷贝处理。

    需求分析:

    ·需要实现文件的拷贝操作,那么这种拷贝就有可能拷贝各种类型的文件,所以肯定使用字节流;

    ·在进行拷贝的时候有可能需要考虑到大文件的拷贝问题;

    实现方案:

    ·方案一:使用InputStream将全部要拷贝的内容直接读取到程序里面,而后一次性的输出到目标文件;

    |- 如果现在拷贝的文件很大,基本上程序就死了;

    ·方案二:采用部分拷贝,读取一部分输出一部分数据,如果现在要采用第二种做法,核心的操作方法:

    |- InputStream:public int read​(byte[] b) throws IOException;

    |- OutputStream:public void write​(byte[] b,int off, int len) throws IOException;

    范例:实现文件拷贝处理

    8f900a89c6347c561fdf2122f13be562.png

    961ddebeb323a10fe0623af514929fc1.png

    1 importjava.io.File;2 importjava.io.FileInputStream;3 importjava.io.FileOutputStream;4 importjava.io.InputStream;5 importjava.io.OutputStream;6 class FileUtil { //定义一个文件操作的工具类

    7 private File srcFile ; //源文件路径

    8 private File desFile ; //目标文件路径

    9 publicFileUtil(String src,String des) {10 this(new File(src),newFile(des)) ;11 }12 publicFileUtil(File srcFile,File desFile) {13 this.srcFile =srcFile ;14 this.desFile =desFile ;15 }16 public boolean copy() throws Exception { //文件拷贝处理

    17 if (!this.srcFile.exists()) { //源文件必须存在!

    18 System.out.println("拷贝的源文件不存在!");19 return false ; //拷贝失败

    20 }21 if (!this.desFile.getParentFile().exists()) {22 this.desFile.getParentFile().mkdirs() ; //创建父目录

    23 }24 byte data [] = new byte[1024] ; //开辟一个拷贝的缓冲区

    25 InputStream input = null;26 OutputStream output = null;27 try{28 input = new FileInputStream(this.srcFile) ;29 output = new FileOutputStream(this.desFile) ;30 int len = 0;31 //1、读取数据到数组之中,随后返回读取的个数、len = input.read(data32 //2、判断个数是否是-1,如果不是则进行写入、(len = input.read(data)) != -1

    33 while ((len = input.read(data)) != -1) {34 output.write(data, 0, len);35 }36 return true;37 } catch(Exception e) {38 throwe ;39 } finally{40 if (input != null) {41 input.close();42 }43 if (output != null) {44 output.close() ;45 }46 }47 }48 }49 public classJavaAPIDemo {50 public static void main(String[] args) throwsException {51 if (args.length != 2) { //程序执行出错

    52 System.out.println("命令执行错误,执行结构:java JavaAPIDemo 拷贝源文件路径 拷贝目标文件路径");53 System.exit(1);54 }55 long start =System.currentTimeMillis() ;56 FileUtil fu = new FileUtil(args[0],args[1]) ;57 System.out.println(fu.copy() ? "文件拷贝成功!" : "文件拷贝失败!");58 long end =System.currentTimeMillis() ;59 System.out.println("拷贝完成的时间:" + (end -start));60 }61 }

    JavaAPIDemo

    009cf24e294eac9b853a53e698205df7.png

    ced8ef94b2fa9ec9ed38c3685420d46f.png

    但是需要注意的是,以上的做法是属于文件拷贝的最原始的实现,而从JDK1.9开始InputStream和Reader类中都追加有数据转存的处理操作方法:

    ·InputStream:public long transferTo​(OutputStream out) throws IOException;

    ·Reader:public long transferTo​(Writer out) throws IOException;

    范例:使用转存的方式处理

    8f900a89c6347c561fdf2122f13be562.png

    961ddebeb323a10fe0623af514929fc1.png

    1 importjava.io.File;2 importjava.io.FileInputStream;3 importjava.io.FileOutputStream;4 importjava.io.InputStream;5 importjava.io.OutputStream;6 class FileUtil { //定义一个文件操作的工具类

    7 private File srcFile ; //源文件路径

    8 private File desFile ; //目标文件路径

    9 publicFileUtil(String src,String des) {10 this(new File(src),newFile(des)) ;11 }12 publicFileUtil(File srcFile,File desFile) {13 this.srcFile =srcFile ;14 this.desFile =desFile ;15 }16 public boolean copy() throws Exception { //文件拷贝处理

    17 if (!this.srcFile.exists()) { //源文件必须存在!

    18 System.out.println("拷贝的源文件不存在!");19 return false ; //拷贝失败

    20 }21 if (!this.desFile.getParentFile().exists()) {22 this.desFile.getParentFile().mkdirs() ; //创建父目录

    23 }24 InputStream input = null;25 OutputStream output = null;26 try{27 input = new FileInputStream(this.srcFile) ;28 output = new FileOutputStream(this.desFile) ;29 input.transferTo(output) ;30 return true;31 } catch(Exception e) {32 throwe ;33 } finally{34 if (input != null) {35 input.close();36 }37 if (output != null) {38 output.close() ;39 }40 }41 }42 }43 public classJavaAPIDemo {44 public static void main(String[] args) throwsException {45 if (args.length != 2) { //程序执行出错

    46 System.out.println("命令执行错误,执行结构:java JavaAPIDemo 拷贝源文件路径 拷贝目标文件路径");47 System.exit(1);48 }49 long start =System.currentTimeMillis() ;50 FileUtil fu = new FileUtil(args[0],args[1]) ;51 System.out.println(fu.copy() ? "文件拷贝成功!" : "文件拷贝失败!");52 long end =System.currentTimeMillis() ;53 System.out.println("拷贝完成的时间:" + (end -start));54 }55 }

    JavaAPIDemo

    此时千万要注意程序的运行版本问题。如果说现在对此程序要求进一步扩展,可以实现一个文件目录的拷贝呢?一旦进行了文件目录的拷贝还需要拷贝所有的子目录中的文件。

    范例:文件夹拷贝

    8f900a89c6347c561fdf2122f13be562.png

    961ddebeb323a10fe0623af514929fc1.png

    1 importjava.io.File;2 importjava.io.FileInputStream;3 importjava.io.FileOutputStream;4 importjava.io.InputStream;5 importjava.io.OutputStream;6 class FileUtil { //定义一个文件操作的工具类

    7 private File srcFile ; //源文件路径

    8 private File desFile ; //目标文件路径

    9 publicFileUtil(String src,String des) {10 this(new File(src),newFile(des)) ;11 }12 publicFileUtil(File srcFile,File desFile) {13 this.srcFile =srcFile ;14 this.desFile =desFile ;15 }16 public boolean copyDir() throwsException {17 try{18 this.copyImpl(this.srcFile) ;19 return true;20 } catch(Exception e) {21 return false;22 }23 }24 private void copyImpl(File file) throws Exception { //递归操作

    25 if (file.isDirectory()) { //是目录

    26 File results [] = file.listFiles() ; //列出全部目录组成

    27 if (results != null) {28 for (int x = 0 ; x < results.length ; x ++) {29 copyImpl(results[x]) ;30 }31 }32 } else { //是文件

    33 String newFilePath = file.getPath().replace(this.srcFile.getPath() + File.separator, "") ;34 File newFile = new File(this.desFile,newFilePath) ; //拷贝的目标路径

    35 this.copyFileImpl(file, newFile) ;36 }37 }38 private boolean copyFileImpl(File srcFile,File desFile) throwsException {39 if (!desFile.getParentFile().exists()) {40 desFile.getParentFile().mkdirs() ; //创建父目录

    41 }42 InputStream input = null;43 OutputStream output = null;44 try{45 input = newFileInputStream(srcFile) ;46 output = newFileOutputStream(desFile) ;47 input.transferTo(output) ;48 return true;49 } catch(Exception e) {50 throwe ;51 } finally{52 if (input != null) {53 input.close();54 }55 if (output != null) {56 output.close() ;57 }58 }59 }60

    61 public boolean copy() throws Exception { //文件拷贝处理

    62 if (!this.srcFile.exists()) { //源文件必须存在!

    63 System.out.println("拷贝的源文件不存在!");64 return false ; //拷贝失败

    65 }66 return this.copyFileImpl(this.srcFile, this.desFile) ;67 }68 }69 public classJavaAPIDemo {70 public static void main(String[] args) throwsException {71 if (args.length != 2) { //程序执行出错

    72 System.out.println("命令执行错误,执行结构:java JavaAPIDemo 拷贝源文件路径 拷贝目标文件路径");73 System.exit(1);74 }75 long start =System.currentTimeMillis() ;76 FileUtil fu = new FileUtil(args[0],args[1]) ;77 if (new File(args[0]).isFile()) { //文件拷贝

    78 System.out.println(fu.copy() ? "文件拷贝成功!" : "文件拷贝失败!");79 } else { //目录拷贝

    80 System.out.println(fu.copyDir() ? "文件拷贝成功!" : "文件拷贝失败!");81 }82 long end =System.currentTimeMillis() ;83 System.out.println("拷贝完成的时间:" + (end -start));84 }85 }

    JavaAPIDemo

    本程序是IO操作的核心代码,本程序可以理解整个的IO处理机制就非常容易理解了。

    展开全文
  • 概念IO流用来处理设备之间的数据传输Java对数据的操作是通过流的方式Java用于操作流的类都在IO包中流按流向分为两种:输入流,输出流。流按操作类型分为两种:字节流 : 字节流可以操作任何数据,因为在计算机中任何...
  • java:List的深拷贝

    万次阅读 2018-12-09 19:17:41
    java:List的深拷贝 相关方法调用: void org.apache.commons.collections.CollectionUtils.addAll(Collection collection, Object[] elements) Integer[] java.util.List.toArray(Integer[] a) void java....
  • //修改新生成的sheet页名称 以上就是代码部分了,可以自行追加逻辑来确认是否克隆新的sheet, 这个方法比起字节流一行一行读方便很多,唯一的问题是没办法对内容进行筛选。 但如果仅是对模板进行操作,这种方法是我...
  • 加入到NIO的,位于java.nio.file包,它的实例代表了文件系统里的一个路径,可以指向文件或文件夹 初始化 Path path = Paths . get ( "D:\\svn-config.properties" ) ; Path.normalize() normalize()方法...
  • java实现文件拷贝

    2020-12-28 21:20:49
    在相同路径下实现该txt文件的拷贝同时向复制完成文件追加拷贝完成”字样。 import java.io.BufferedWriter; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java...
  • //先将添加位置之前的元素拷贝到s2  s2[index] = element;  System.arraycopy(s1, index, s2, index+1, s1.length-index);//将添加位置之后的元素拷贝到s2  for(String s :s2) {  System.out.println(s); ...
  • IO_字节流_节点流_文件读取_写出_追加文件_拷贝文件JAVA147-148
  • 转自:... 文章目录 java:List的深拷贝 1. CollectionUtils.addAll与Collections.copy结合实现深拷贝 2. List.toArray与CollectionUtils.addAll结合实现深拷贝 3、在使用Collections.copy(d...
  • 写数据,操作文件时,采用追加的方式。速度非常快(接近内存写的速度) 读数据,也不要自己去seek指定偏移量,而是按顺序read(因为read时会预读取后续一部分数据,而不是仅读取当前位置的数据,所以顺序读可以充分...
  • 拷贝原理讲解 我们以用户通过网络读取一个本地磁盘上文件为例,在说零拷贝之前,我们先要说说一个普通的IO操作是怎样做的 系统接收到网络用户读取文件的请求 应用程序发起系统调用, 从用户态切换到内核态(第一次...
  • 现在要求通过java.io包中采用自定义程序的模式实现该功能,可以通过初始化参数设置拷贝的文件路径。 思路分析: 1、要进行拷贝的文件可能是文本文件或者是二进制文件,所以所以为了达到通用性,最好的方法是使用...
  • 2.8 java.nio.file.Files.copy()实现文件拷贝,其中第三个参数决定是否覆盖 public static void copyFile(String source,String target){ Path sourcePath = Paths.get(source); Path destinationPath = Paths...
  • 往文件里面追加内容

    2021-05-25 05:18:39
    linux 如何往文件最后追加内容1.将 abc 追加到文件a.txt最后 echo "abc" >> a.txt 2. 将文件b.txt 中的内容追加到a.txt最后 cat b.txt >> a.txt 3.在a.txt文件的最后面加abcd echo "abcd" >> a....
  • 2.4 文件拷贝 1. File类的基本使用 File类即可描述真实文件,也可描述文件夹(目录) File类是java.io包中唯一一个与文件本身操作(创建、删除、取得信息)有关,与文件内容无关的程序类 File类的常用构造...
  • 10万字208道Java经典面试题总结(附答案)

    万次阅读 多人点赞 2021-08-01 16:05:55
    JDK(Java Development Kit),Java开发工具包 JRE(Java Runtime Environment),Java运行环境 JDK中包含JRE,JDK中有一个名为jre的目录,里面包含两个文件夹bin和lib,bin就是JVM,lib就是JVM工作所需要的类库。...
  • 首先扯点别的:真是好记性不如烂笔头啊,关于java的输入输出流真是看一遍忘一遍,每次用的时候还得查看API,也是艰难。除了知道IO可以分为输入流,输出流,字符流,字节流,其他的忘得干干净净的,都还给老师了。...
  • package ...import java.io.*; import java.net.MalformedURLException; import java.net.URL;/** * 文件工具类 * Created by charlin on 2017/9/8. */ public class FileUtil { /** * 读取文件内容
  • 问题在写东西的时候用appendChild为li标签两次追加相同内容,结果却页面只出现了一个li标签原因appengChild是把一个元素(对象)追到到另一个元素上,但是这个追加其实是"剪切"的意思。也就是说,如果追加同一个元素...
  • java8中将数组进行分割Here you will learn how to copy one array to another in Java. 在这里,您将学习如何使用Java将一个数组复制到另一个数组。 There are mainly four different ways to copy all elements ...
  • 本文深入探究零拷贝的原理,从操作系统开始层层递进的分析了数据传输的各个相关组件及流程,直观透彻的呈现了零拷贝的原理和优点。
  • java中遍历MAP,嵌套map的几种方法

    千次阅读 2021-02-13 01:57:28
    java中遍历MAP的几种方法Map map=new HashMap();map.put("username", "qq");map.put("passWord", "123");map.put("userID", "1");map.put("email", "qq@qq.com");1.用for循环for (Map.Entry entry : map.entrySet())...
  • 一、摘要 前面学习了IO流,写了拷贝文件的功能;接着学习了多线程,现在将两个知识结合起来,来实现多线程拷贝文件。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 36,883
精华内容 14,753
关键字:

java 拷贝 追加

java 订阅