IO流拷贝文件的几种方式

简介: IO流拷贝文件的几种方式

通过IO流拷贝文件的几种方式如下:

需求1: 拷贝纯文本文件.

FileInputStream && FileOutputStream

  1. 普通的字节流一次读写一个字节.
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class Demo1 {
    public static void main(String[] args) throws Exception {
        //创建字节输入流对象,关联数据源文件
        FileInputStream fileInputStream = new FileInputStream("src\\input.txt");//不写绝对地址则默认项目目录下的地址
        //创建字节输出流对象,关联目的地文件 
        //补充:new FileOutputStream("input.txt",true),从文本末尾开始写入数据,不会覆盖原本内容,不写true则默认为false,会从文本头开始写入,覆盖原本内容
        FileOutputStream fileOutputStream = new FileOutputStream("src\\output.txt");//不写绝对地址则默认项目目录下的地址
        int len;//用于接收读取的字符
        //fileInputStream.read返回类型为int型,如果没有数据则返回-1
        //循环读取, 只要条件满足, 就一直读, 并将读取到的数据赋值给变量.
        while ((len = fileInputStream.read()) != -1) {
            // 将读取到的数据写入到目的地文件中.
            fileOutputStream.write(len);
        }
        //关流,释放资源
        fileInputStream.close();
        fileOutputStream.close();
    }
}
  1. 普通的字节流一次读写一个字节数组. //掌握
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class Demo2 {
    public static void main(String[] args) throws Exception {
        //创建字节输入流对象,关联数据源文件
        FileInputStream fileInputStream = new FileInputStream("src\\input.txt");//不写绝对地址则默认项目目录下的地址
        //创建字节输出流对象,关联目的地文件
        FileOutputStream fileOutputStream = new FileOutputStream("src\\output.txt");//不写绝对地址则默认项目目录下的地址
        byte[] bytes = new byte[8192];
        int len;
        while ((len = fileInputStream.read(bytes)) != -1) {
            fileOutputStream.write(bytes, 0, len);
        }
        fileInputStream.close();
        fileOutputStream.close();
    }
}

BufferedInputStream && BufferedOutputStream

  1. 高效的字节流一次读写一个字节. //掌握
public class Demo3 {
    public static void main(String[] args) throws Exception{
        //创建输入流, 关联数据源文件
        BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("src\\input.txt"));//BufferedInputStream(InputStream )
        //创建输出流, 关联目的地文件
        //补充:new FileOutputStream("input.txt",true),从文本末尾开始写入数据,不会覆盖原本内容,不写true则默认为false,会从文本头开始写入,覆盖原本内容
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("src\\output.txt"));//BufferedOutputStream(OutputStream)
        //定义变量, 用来记录读取到的数据(字节).
        int len;
        //循环读取, 只要条件满足, 就一直读, 并将读取到的数据赋值给变量.
        while((len = bufferedInputStream.read())!=-1){
        //将读取到的数据写入到目的地文件中.
            bufferedOutputStream.write(len);
        }
        //关闭流,释放资源
        bufferedInputStream.close();
        bufferedOutputStream.close();
    }
  1. 高效的字节流一次读写一个字节数组.
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class Demo4 {
    public static void main(String[] args) throws Exception {
        //创建输入流, 关联数据源文件
        BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("src\\input.txt"));//BufferedInputStream(InputStream )
        //创建输出流, 关联目的地文件.
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("src\\output.txt"));//BufferedOutputStream(OutputStream)
        //接收数据
        byte[] bytes = new byte[8192];//建议数组长度设置为8192,与字节缓冲区长度相同.
        //定义变量, 用来记录读取到的数据(字节).
        int len;
        //循环读取, 只要条件满足, 就一直读, 并将读取到的数据赋值给变量.
        while ((len = bufferedInputStream.read(bytes)) != -1) {
            //将读取到的数据写入到目的地文件中.
            bufferedOutputStream.write(bytes, 0, len);
        }
        //关流,释放资源
        bufferedInputStream.close();
        bufferedOutputStream.close();
    }
}

InputStreamReader && OutputStreamWriter

  1. 转换流一次读写一个字符.
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class Demo5 {
    public static void main(String[] args) throws Exception {
        InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream("src\\input.txt"));
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream("src\\output.txt"));
        int len;
        while ((len = inputStreamReader.read())!=-1){
            outputStreamWriter.write(len);
        }
        inputStreamReader.close();
        outputStreamWriter.close();
    }
}
  1. 转换流一次读写一个字符数组.
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class Demo6 {
    public static void main(String[] args) throws Exception {
//new InputStreamReader(new FileInputStream("day12/data/1.txt"),"utf-8");设置读取格式为utf-8,如果不设置格式,则为当前编译器默认的编码
        InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream("src\\input.txt"));
//new OutputStreamWriter(new FileOutputStream("day12/data/2.txt"),"utf-8");设置读取格式为utf-8,如果不设置格式,则为当前编译器默认的编码
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream("src\\output.txt"));
        int len;
        char[] bytes = new char[8192];
        while ((len = inputStreamReader.read(bytes)) != -1) {
            outputStreamWriter.write(bytes, 0, len);
        }
        inputStreamReader.close();
        outputStreamWriter.close();
    }
}

FileReader && FileWriter

  1. 普通的字符流一次读写一个字符.
import java.io.FileReader;
import java.io.FileWriter;

public class Demo7 {
   public static void main(String[] args) throws Exception {
       FileReader fileReader = new FileReader("src\\input.txt");
       FileWriter fileWriter = new FileWriter("src\\output.txt");
       int len;
       while ((len = fileReader.read()) != -1) {
           fileWriter.write(len);
       }
       fileReader.close();
       fileWriter.close();
   }
}
  1. 普通的字符流一次读写一个字符数组.
public class Demo8 {
    public static void main(String[] args) throws Exception {
        FileReader fileReader = new FileReader("src\\input.txt");
        FileWriter fileWriter = new FileWriter("src\\output.txt");
        int len;
        char[] chars = new char[8192];
        while ((len = fileReader.read(chars)) != -1) {
            fileWriter.write(chars, 0, len);
        }
        fileReader.close();
        fileWriter.close();
    }
}

BufferedReader && BufferedWriter

  1. 高效的字符流一次读写一个字符.
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;

public class Demo9 {
    public static void main(String[] args)throws Exception {
        BufferedReader bufferedReader = new BufferedReader(new FileReader("src\\input.txt"));
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("src\\output.txt"));
        int len;
        while ((len = bufferedReader.read())!=-1){
            bufferedWriter.write(len);
        }
        bufferedReader.close();
        bufferedWriter.close();
    }
}
  1. 高效的字符流一次读写一个字符数组.
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;

public class Demo10 {
    public static void main(String[] args) throws Exception {
        BufferedReader bufferedReader = new BufferedReader(new FileReader("src\\input.txt"));
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("src\\output.txt"));
        int len;
        char[] chars = new char[8192];
        while ((len = bufferedReader.read(chars)) != -1) {
            bufferedWriter.write(chars, 0, len);
        }
        bufferedReader.close();
        bufferedWriter.close();
    }
}
  1. 高效的字符流一次读写一行. //掌握
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;

public class Demo11 {
    public static void main(String[] args) throws Exception {
        BufferedReader bufferedReader = new BufferedReader(new FileReader("src\\input.txt"));
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("src\\output.txt"));
        String len;
        while ((len = bufferedReader.readLine()) != null) {
            bufferedWriter.write(len);
            bufferedWriter.newLine();//换行
        }
        bufferedReader.close();
        bufferedWriter.close();
    }
}

需求2: 拷贝任意类型的文件.

        1. 普通的字节流一次读写一个字节.
        2. 普通的字节流一次读写一个字节数组.
        3. 高效的字节流一次读写一个字节.
        4. 高效的字节流一次读写一个字节数组.
目录
相关文章
|
17天前
|
Java 大数据 API
Java 流(Stream)、文件(File)和IO的区别
Java中的流(Stream)、文件(File)和输入/输出(I/O)是处理数据的关键概念。`File`类用于基本文件操作,如创建、删除和检查文件;流则提供了数据读写的抽象机制,适用于文件、内存和网络等多种数据源;I/O涵盖更广泛的输入输出操作,包括文件I/O、网络通信等,并支持异常处理和缓冲等功能。实际开发中,这三者常结合使用,以实现高效的数据处理。例如,`File`用于管理文件路径,`Stream`用于读写数据,I/O则处理复杂的输入输出需求。
|
1月前
|
Linux C语言
C语言 文件IO (系统调用)
本文介绍了Linux系统调用中的文件I/O操作,包括文件描述符、`open`、`read`、`write`、`lseek`、`close`、`dup`、`dup2`等函数,以及如何获取文件属性信息(`stat`)、用户信息(`getpwuid`)和组信息(`getgrgid`)。此外还介绍了目录操作函数如`opendir`、`readdir`、`rewinddir`和`closedir`,并提供了相关示例代码。系统调用直接与内核交互,没有缓冲机制,效率相对较低,但实时性更高。
|
2月前
|
存储 监控 Linux
性能分析之从 IO 高定位到具体文件
【8月更文挑战第21天】性能分析之从 IO 高定位到具体文件
30 0
性能分析之从 IO 高定位到具体文件
WXM
|
2月前
|
存储 缓存 算法
IO/线程的零拷贝
服务器在提供文件传输功能时,传统实现方式是通过读取磁盘文件内容,将其加载到用户空间的缓冲区,再通过网络 API 发送至客户端,这个过程涉及多次上下文切换和内存拷贝,导致性能下降。
WXM
41 12
|
3月前
|
Linux 数据处理 C语言
【Linux】基础IO----系统文件IO & 文件描述符fd & 重定向(下)
【Linux】基础IO----系统文件IO & 文件描述符fd & 重定向(下)
60 0
|
3月前
|
Linux C语言 C++
【Linux】基础IO----系统文件IO & 文件描述符fd & 重定向(上)
【Linux】基础IO----系统文件IO & 文件描述符fd & 重定向(上)
39 0
|
4月前
|
C++
Open3D File Io 文件IO
Open3D File Io 文件IO
|
4月前
|
Linux 网络安全 开发工具
【linux】基础IO |文件操作符
【linux】基础IO |文件操作符
32 0
|
4月前
使用字节输入流报错 java.io.FileNotFoundException: srcdruid.properties (系统找不到指定的文件。)
使用字节输入流报错 java.io.FileNotFoundException: srcdruid.properties (系统找不到指定的文件。)
34 0
|
2月前
|
存储 Java
【IO面试题 四】、介绍一下Java的序列化与反序列化
Java的序列化与反序列化允许对象通过实现Serializable接口转换成字节序列并存储或传输,之后可以通过ObjectInputStream和ObjectOutputStream的方法将这些字节序列恢复成对象。