java-io流--（六）--文件io复制

最新推荐文章于 2023-09-23 07:00:00 发布
最新推荐文章于 2023-09-23 07:00:00 发布
阅读量303 收藏
点赞数
分类专栏： io流 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43470725/article/details/121334968
版权

参考：https://blog.csdn.net/qq_43470725/article/details/121283862
https://blog.csdn.net/Enjoy96/article/details/78650182

详情参考：io流

1、文本io流的复制 代码演示：

package com.example.io.fileIo.copy.charCopy;

import java.io.*;

public class CharCopyTest01 {

    public static void main(String[] args) {

        CharCopyTest01 charCopyTest01 = new CharCopyTest01();
        String path = charCopyTest01.getPath();
        path = getPath01(path);
        System.out.println(path);
//        创建文件夹和文件并返回File：
        File file = createFile(path,"test","\\test.txt");
//        创建要复制到目标的文件夹及文件：
        File fileCopy = createFile(path, "test", "\\testCopy.txt");

//        复制文件
        try {
//            一次读一个字符数组
//            copyFile(file, fileCopy);
//            一次读一个字符
//            copyFileByOne(file, fileCopy);
//            一次读一行
//            copyFileByLine(file,fileCopy);
            //基本字符流读取一个字符数组（效率低）
//            copyFileByBasic(file, fileCopy);
            //基本字符流读取一个字符（效率低）
//            copyFileByBasicOne(file, fileCopy);
//            采用打印流PrintWriter的println()方法进行文件的复制
            copyFileByPrintWriter(file, fileCopy);

        } catch (IOException e) {
            e.printStackTrace();
        }


    }

    //    得到该类的路径
    public String getPath(){
        String path = this.getClass().getResource("").getPath();
        return path;
    }

    public static String getPath01(String pathIn){

        pathIn = pathIn.substring(1,pathIn.length());
        pathIn = pathIn.replace("/", "\\");
        System.out.println("pathIn==="+pathIn);
        return pathIn;
    }

    public static File createFile(String path,String filePath,String fileName){
//        创建文件夹
        path = path + filePath;
        File file = new File(path);
        if(!file.exists()){
            file.mkdir();
        }
//        创建文件
        path = path + fileName;
        System.out.println("path---last===="+path);
        file = new File(path);
        if(!file.exists()){
            try {
                file.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return file;
    }

//    缓冲字符流一次读取一个字符数组
    public static void copyFile(File pathSource,File pathCopyRoot) throws IOException {
//        封装数据源：
//        创建一个文件字节输入流对象
        BufferedReader br = new BufferedReader(new FileReader(pathSource));
//        封装目的地
//        创建文件输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter(pathCopyRoot));

//        一次读取一个字符数组
        char[] chs = new char[1024];
        int len = 0;
        while ((len = br.read(chs)) != -1){
//            一次读一个字符数组，使用输出流给testCopy.txt文件写一个字符数组
            bw.write(chs, 0, len);
//            刷新流
            bw.flush();

        }
//        释放资源
        br.close();
        bw.close();

    }

    //    缓冲字符流一次读取一个字符
    public static void copyFileByOne(File pathSource,File pathCopyRoot) throws IOException {
//        封装数据源：
//        创建一个文件字节输入流对象
        BufferedReader br = new BufferedReader(new FileReader(pathSource));
//        封装目的地
//        创建文件输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter(pathCopyRoot));


        int ch = 0;
        while ((ch = br.read()) != -1){
//            一次读一个字符数组，使用输出流给testCopy.txt文件写一个字符数组
            bw.write(ch);
//            刷新流
            bw.flush();

        }
//        释放资源
        br.close();
        bw.close();

    }

//    缓冲字符流一次读一行：
public static void copyFileByLine(File pathSource,File pathCopyRoot) throws IOException {
//        封装数据源：
//        创建一个文件字节输入流对象
    BufferedReader br = new BufferedReader(new FileReader(pathSource));
//        封装目的地
//        创建文件输出流对象
    BufferedWriter bw = new BufferedWriter(new FileWriter(pathCopyRoot));

// 使用BufferedReader中的特有功能public String readLine() 一次读取一行
    String str = null;
    while ((str = br.readLine()) != null){
// 一次读一行，使用输出流给b.txt文件写入此行字符串
        bw.write(str);
//BufferedWriter中的特有功能public void newLine() 写入一个分行符
        bw.newLine();
//        刷新流
        bw.flush();

    }
//        释放资源
    br.close();
    bw.close();

}

//基本字符流读取一个字符数组（效率低）
    public static void copyFileByBasic(File pathSource,File pathCopyRoot) throws IOException {

        FileReader fr = new FileReader(pathSource);

        FileWriter fw = new FileWriter(pathCopyRoot);

        char[] chs = new char[1024];
        int len = 0;
        while ((len = fr.read(chs)) != -1){

            fw.write(chs,0,len);
            fw.flush();

        }
        fr.close();
        fw.close();

    }
    //基本字符流读取一个字符（效率低）
    public static void copyFileByBasicOne(File pathSource,File pathCopyRoot) throws IOException {

        FileReader fr = new FileReader(pathSource);

        FileWriter fw = new FileWriter(pathCopyRoot);

        int ch = 0;
        while ((ch = fr.read()) != -1){

            fw.write(ch);
            fw.flush();

        }
        fr.close();
        fw.close();

    }

//    采用打印流PrintWriter的println()方法进行文件的复制
public static void copyFileByPrintWriter(File pathSource,File pathCopyRoot) throws IOException{

        BufferedReader br = new BufferedReader(new FileReader(pathSource));

        PrintWriter pw = new PrintWriter( new FileWriter(pathCopyRoot),true);// 此种构造方式可以自动刷新

//        读取数据
        String line = null;
        while ((line = br.readLine()) != null){
//            写入数据，读取一行并启动自动换行
            pw.println(line);

        }

//        释放资源
        br.close();
        pw.close();

}


}

2、文件（图片、视频等）的复制 代码演示：

package com.example.io.fileIo.copy.byteCopy;

import java.io.*;

public class ByteCopyTest01 {

    public static void main(String[] args) {

        ByteCopyTest01 byteCopyTest01 = new ByteCopyTest01();
        String path = byteCopyTest01.getPath();
        path = getPath01(path);
        System.out.println(path);
        //        创建文件夹和文件并返回File：
        File file = createFlode(path,"test");

        String jpgPathSource = "D:\\2.jpg";
        try {
            String jpgPathRoot = file.getCanonicalPath().toString();
            System.out.println(jpgPathRoot);
            jpgPathRoot = jpgPathRoot + "\\2copy.jpg";
            //      缓冲字节流一次读一个字节数组
//            copyFileByBuffer(jpgPathSource, jpgPathRoot);
            //      缓冲字节流一次读一个字节
//            copyFileByBufferOne(jpgPathSource, jpgPathRoot);
            //采用基本字节输入流，一次读一个字节数组
//            copyFileByBasic(jpgPathSource, jpgPathRoot);
            //    采用基本字节输入流，一次读一个字节
//            copyFileByBasicOne(jpgPathSource, jpgPathRoot);
            //    采用打印流PrintStream的writer()方法进行图片的复制
            copyFileByPrintStream(jpgPathSource, jpgPathRoot);


        } catch (IOException e) {
            e.printStackTrace();
        }


    }

    //    得到该类的路径
    public String getPath(){
        String path = this.getClass().getResource("").getPath();
        return path;
    }

    public static String getPath01(String pathIn){

        pathIn = pathIn.substring(1,pathIn.length());
        pathIn = pathIn.replace("/", "\\");
        System.out.println("pathIn==="+pathIn);
        return pathIn;
    }

//    创建文件
    public static File createFile(String path, String filePath, String fileName){
//        创建文件夹
        path = path + filePath;
        File file = new File(path);
        if(!file.exists()){
            file.mkdir();
        }
//        创建文件
        path = path + fileName;
        System.out.println("path---last===="+path);
        file = new File(path);
        if(!file.exists()){
            try {
                file.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return file;
    }
    //    创建文件夹
    public static File createFlode(String path, String filePath){
//        创建文件夹
        path = path + filePath;
        File file = new File(path);
        if(!file.exists()){
            file.mkdir();
        }
        return file;
    }

//    缓冲字节流一次读一个字节数组

    public static void copyFileByBuffer(String pathSource,String pathRoot) throws IOException {

        //获取当前的系统时间
        long startTime = System.currentTimeMillis() ;

        // 封装数据源:
        // 创建一个文件字节输入流对象
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(pathSource));

        // 封装目的地
        // 创建文件输出流对象
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(pathRoot));//如果没有文件，会自动创建


        // 使用高效字节输入流，一次读取一个字节数组
        byte[] bytes = new byte[1024];
        int len;
        while ((len = bis.read(bytes)) != -1){
            // 一次读一个字节数组，使用输出流给Marco.jpg文件写一个字节数组
            bos.write(bytes,0,len);
//            刷新流
            bos.flush();
        }

//        释放资源
        bis.close();
        bos.close();

//        时间测试
        long endTime = System.currentTimeMillis() ;
        System.out.println("共耗时:"+(endTime-startTime)+"毫秒");
    }

//      缓冲字节流一次读一个字节
public static void copyFileByBufferOne(String pathSource,String pathRoot) throws IOException {

    //获取当前的系统时间
    long startTime = System.currentTimeMillis() ;

    // 封装数据源:
    // 创建一个文件字节输入流对象
    BufferedInputStream bis = new BufferedInputStream(new FileInputStream(pathSource));

    // 封装目的地
    // 创建文件输出流对象
    BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(pathRoot));//如果没有文件，会自动创建


    // 使用高效字节输入流，一次读取一个字节

    int by;
    while ((by = bis.read()) != -1){
        // 一次读一个字节数组，使用输出流给Marco.jpg文件写一个字节数组
        bos.write(by);
//            刷新流
        bos.flush();
    }

//        释放资源
    bis.close();
    bos.close();

//        时间测试
    long endTime = System.currentTimeMillis() ;
    System.out.println("共耗时:"+(endTime-startTime)+"毫秒");
}

//采用基本字节输入流，一次读一个字节数组

    public static void copyFileByBasic(String pathSource,String pathRoot) throws IOException {

        // 获取当前的系统时间
        long startTime = System.currentTimeMillis();

        // 封装数据源:
        // 创建一个文件字节输入流对象
        FileInputStream fis = new FileInputStream(pathSource);

        // 封装目的地
        // 创建文件输出流对象
        FileOutputStream fos = new FileOutputStream(pathRoot);

        // 使用基本字节输入流，一次读取一个字节数组
        byte[] bytes = new byte[1024];
        int len = 0;
        while ((len = fis.read(bytes)) != -1){
            // 一次读一个字节数组，使用输出流给Marco.jpg文件写一个字节数组
            fos.write(bytes,0,len);
//            刷新流
            fos.flush();

        }

//        释放资源
        fis.close();
        fos.close();
        // 时间测试
        long endTime = System.currentTimeMillis();
        System.out.println("共耗时:" + (endTime - startTime) + "毫秒"); // 1249毫秒

    }

//    采用基本字节输入流，一次读一个字节
public static void copyFileByBasicOne(String pathSource,String pathRoot) throws IOException {

    // 获取当前的系统时间
    long startTime = System.currentTimeMillis();

    // 封装数据源:
    // 创建一个文件字节输入流对象
    FileInputStream fis = new FileInputStream(pathSource);

    // 封装目的地
    // 创建文件输出流对象
    FileOutputStream fos = new FileOutputStream(pathRoot);

    // 使用基本字节输入流，一次读取一个字节
    int by = 0;
    while ((by = fis.read()) != -1){
        // 一次读一个字节，使用输出流给02test.jpg文件写一个字节
        fos.write(by);
//        刷新流
        fos.flush();

    }

//    释放资源
    fis.close();
    fos.close();

    // 时间测试
    long endTime = System.currentTimeMillis();
    System.out.println("共耗时:" + (endTime - startTime) + "毫秒");

    }

//    采用打印流PrintStream的writer()方法进行图片的复制
public static void copyFileByPrintStream(String pathSource,String pathRoot) throws IOException {
    // 获取当前的系统时间
    long startTime = System.currentTimeMillis();

    // 封装数据源
    BufferedInputStream bis = new BufferedInputStream(new FileInputStream(pathSource));

    // 封装目的地，使用字符打印流对象并启动自动刷新功能
    PrintStream ps = new PrintStream(new FileOutputStream(pathRoot),true); // 此种构造方式可以自动刷新

//    读取数据，一次读取一个字节数组
    byte[] bytes = new byte[1024];
    int len = 0;
    while ((len = bis.read(bytes)) != -1){

//        写入数据，一次写一个字节数组
        ps.write(bytes,0,len);
    }

//    释放资源
    bis.close();
    ps.close();

    // 时间测试
    long endTime = System.currentTimeMillis();
    System.out.println("共耗时:" + (endTime - startTime) + "毫秒");

    }


}
春风霓裳
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java-Io流，练习
07-06
关于java的IO流基础的练习，适合刚接触IO流，没有基础的同学
java-io-guide:Java中的Java IO（输入和输出流）指南
04-29
这是Java中文件处理的完整指南。 本指南的源代码在我们的本地开发环境中经过了很好的测试，并使用了静态代码分析器工具SonatLint ， PMD等对代码进行了分析。本指南的源代码无缺陷，并使用JDK 8进行编译和执行。 ...
[IO流]使用FileReader和FileWriter实现文本文件的复制
self
05-06 409
@Test public void testFileReaderFileWriter(){ FileReader fr = null; FileWriter fw = null; try { //1.创建File类的对象，指明读入和写出的文件 File srcFile = new File("he.txt"); File destFile = new File("dest.txt.
java IO 文件copy
qq_42866384的博客
08-10 311
package date10; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.File; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java....
【java io】io copy文件
hao007cn的专栏
02-20 556
public class Stream { FileInputStream fis = null; public static void main(String[] args) { FileInputStream fis = null; try { //1、创建一个文件输入流 fis = new FileInputStream("D:\\javaspacen
Java IO进行文件copy
另一个世界
08-16 783
此处列举四种copy方式(不考虑复制时重复的冲突)，其中前三种需要递归复制，第四种使用ApacheCommonsIO工具类，不需要自己手写递归。 递归复制/** * 递归复制 * @param file 原文件路径 * @param copyFile 复制文件路径 * @param type 复制方式 * @throws IOException */ public s
复制文件应用FileIO流
qq_41815040的博客
10-28 199
import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; public class CopyFile {     public static void main(String[] args) {         long s = System.currentTimeMi...
JavaIO文件复制优化-JavaIO优化详解（下载可用）
最新发布
05-30
JavaIO文件复制优化——JavaIO优化详解（下载可用）。个人经导师指导并认可通过的98分大作业设计项目，适用人群：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业或毕业设计，作为“参考资料”使用。...
Java IO流和文件操作实现过程解析
08-25
主要介绍了Java IO流和文件操作实现过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
实例讲述Java IO文件复制
08-27
本篇文章通过实例给大家详细讲述Java IO文件复制的相关知识点，需要的读者们学习下吧。
Java Io 之拷贝文件性能比较
weixin_30659829的博客
09-06 113
前面我们共讨论了拷贝文件有三种方式： 1. 第一种，一个字节一个字节的进行拷贝文件操作。 2. 第二种，使用字节数据批量的进行拷贝文件操作。 3. 第三种，使用带缓冲输入输出流来拷贝文件。 那么哪一种性能比较优越呢，也就是耗时时间比较短。测试如下： package com.dcz.io; import java.io.BufferedInputStream; import jav...
Java IO流简单实现Copy文件
baidu_38795342的博客
04-06 318
package com.ymw.test.collection; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; public clas...
Java IO流实现文件复制
冰小九的博客
09-23 1292
Windows文件复制时我们是使用Ctrl C复制Ctrl V粘贴，上一篇文章Java基础入门·对存储文件的相关操作，我们学习了Java IO流对文件的读写操作，那我们可以思考一下，字节的读取和写入，怎样运用到文件复制的操作中？
Java IO流 复制一个目录
小蓝的博客
08-10 1933
Java IO流 复制目录 实现把一个目录中的所有内容复制到一个目录中去 实现文件复制 因为一个目录下的文件可能是字符文件，也可能是二进制文件，所以使用字节流来进行复制,这样能复制所有类型的文件。 /** * 复制一个文件 * @param srcFile 源文件 * @param destFile 目的文件 * @throws IOException */ public...
文件复制粘贴（IO流）
diexie1060的博客
03-06 204
项目 package com.I_O; import java.io.*; /** * 文件文件 */ public class Copy_I_O { /** * 复制粘贴方法 */ public void copy(){ InputStream is=null; OutputStre...
java（IO）copy，字节字符
asd623444055的博客
02-02 344
package com.day21.IO; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; //字符 public class FileCopy { //编写程序FileCopy.java，在测试方法中，将FileCopy.java复制为FileCopy.java.bak文件； // 查看FileCopy.java.bak文件的内容，验证复制是否正确。 public.
java FileIO类
dyyweb的专栏
12-16 811
package system;import java.io.*;import java.util.*;/**此类完成文件输入输出的常用功能*/public class FileIO{/**将一个字符串写稿到文件中*/public static boolean writeStrToFile(File f,String str)//将数据写入到文件中{   try   {    if(!f.exists()) f.createNewFile();    FileOutputStream fos = new Fi
复制文件IO、NIO的写法比较
老秦的博客
07-11 217
复制文件的比较 Io是web端不可不谈的一个重点，而复制则是一个典型的运用，从复制中可以了解各中io的运用及效率 原生IO @Test public void executeInputStream() { String srcFile = "E:/电子书/白帽子讲Web安全.pdf"; String tarFile = "E:/book.pdf"; long start = Syst...
使用Java的IO与NIO来Copy文件的四种方法实现以及性能对比
kaven
02-04 1345
使用Java的IO与NIO来Copy文件的四种方法实现以及性能对比 FileCopyRunner接口，定义了Copy文件的接口，等下在测试类中使用匿名内部类来实现。 package nio.channel; import java.io.File; public interface FileCopyRunner { void copyFile(File source , File ta...
java eav模型_Java - IO入门实现简单的转存
06-09
好的，我来回答你的问题。 首先，让我们来了解一下什么是 EAV 模型。EAV 模型是一种数据建模的方法，它将所有的数据存储在一个三元组 (实体、属性、值) 中。其中，实体表示存储的对象，属性表示实体的某个特征，值则表示该属性的具体取值。这种模型可以用于存储非结构化数据和动态的数据，但是在查询和维护方面会存在一些挑战。 接下来，让我们来看一下如何实现简单的转存。Java 中提供了许多用于文件操作的类和方法，其中最常用的是 java.io 包中的类。我们可以使用 FileInputStream 和 FileOutputStream 类来实现文件的读写操作。 例如，我们可以通过以下代码将源文件的内容复制到目标文件中： ```java import java.io.*; public class FileCopy { public static void main(String[] args) { try { FileInputStream in = new FileInputStream("source.txt"); FileOutputStream out = new FileOutputStream("target.txt"); byte[] buffer = new byte[1024]; int length; while ((length = in.read(buffer)) > 0) { out.write(buffer, 0, length); } in.close(); out.close(); System.out.println("File copied successfully!"); } catch (IOException e) { e.printStackTrace(); } } } ``` 在上面的代码中，我们首先创建了一个 FileInputStream 对象来读取源文件，然后创建了一个 FileOutputStream 对象来写入目标文件。接着，我们使用一个字节数组作为缓冲区，每次读取 1024 个字节，并将其写入目标文件中。最后，我们关闭了输入输出流，完成了文件复制操作。 希望这个简单的例子能够帮助你入门 Java IO 操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值