花几千上万学习Java，真没必要！（三十七）

沐风听雨_A

已于 2024-07-31 21:34:13 修改

阅读量378

点赞数 10

文章标签：学习

于 2024-07-31 21:05:23 首次发布

本文链接：https://blog.csdn.net/wehpd/article/details/140831603

版权

IO 流：

读取数据到内存的过程：可以包括从硬盘、网络或其他存储设备中将数据加载到内存中，以便程序能够访问和处理这些数据。
写入数据到硬盘的过程：通常是将内存中的数据保存到硬盘或其他持久性存储设备中，以便长期存储或备份数据。

IO ：输入/输出(Input/Output)
流：是一种抽象概念，是对数据传输的总称。也就是说数据在设备间的传输称为流，流的本质是数据传输，IO 流就是用来处理设备间数据传输问题的。常见的应用：文件复制；文件上传；文件下载。

第一、IO 流的分类
按照数据的流向
输入流：读数据
输出流：写数据

第二、按照数据类型来分类
字节流
字节输入流
字节输出流

字符流
字符输入流
字符输出流

IO 流的使用场景
如果操作的是纯文本文件，优先使用字符流
如果操作的是图片、视频、音频等二进制文件。优先使用字节流。
如果不确定文件类型，优先使用字节流。字节流是万能的流。

测试代码1：

import java.io.FileOutputStream;  
import java.io.IOException;  
//字节流抽象基类
//InputStream ：这个抽象类是表示字节输入流的所有类的超类
//OutputStream ：这个抽象类是表示字节输出流的所有类的超类
//子类名特点：子类名称都是以其父类名作为子类名的后缀
//字节输出流
//FileOutputStream(String name) ：创建文件输出流以指定的名称写入文件
//使用字节输出流写数据的步骤
//创建字节输出流对象 (调用系统功能创建了文件，创建字节输出流对象，让字节输出流对象指向文件)
//调用字节输出流对象的写数据方法
//释放资源 (关闭此文件输出流并释放与此流相关联的任何系统资源)  
public class FileOutputStreamExample {  
    public static void main(String[] args) {  
        // 指定要写入的文件名  
        String fileName = "example.txt";  
  
        // 使用try-with-resources语句自动管理资源  
        try (FileOutputStream fos = new FileOutputStream(fileName)) {  
            // 要写入的文本  
            String text = "Hello, World! This is a test file.";  
  
            // 将文本转换为字节数组  
            byte[] bytes = text.getBytes();  
  
            // 写入字节数组到文件  
            fos.write(bytes);  
  
            // 不需要显式调用fos.close()，try-with-resources会自动处理  
            System.out.println("Data written to " + fileName + " successfully.");  
        } catch (IOException e) {  
            // 如果发生I/O错误，则捕获异常并打印堆栈跟踪  
            e.printStackTrace();  
        }  
  
        // try-with-resources块之后，fos已经被自动关闭。  
    }  
}

测试代码2：

package iotest.com;
import java.io.FileOutputStream;  
import java.io.IOException;  
  
public class FileOutputStreamTest {  
    public static void main(String[] args) {  
        String fileName = "example.txt";  
  
        // 写入单个字节  
        try (FileOutputStream fosSingleByte = new FileOutputStream(fileName)) {  
            fosSingleByte.write(65); // ASCII码65对应字母'A'  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
  
        // 写入字节数组  
        byte[] byteArray = "Hello, World!".getBytes();  
        try (FileOutputStream fosByteArray = new FileOutputStream(fileName, true)) { // 追加模式  
            fosByteArray.write(byteArray);  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
  
        // 写入字节数组的一部分  
        byte[] partOfByteArray = " New Line!".getBytes();  
        try (FileOutputStream fosPartOfArray = new FileOutputStream(fileName, true)) { // 继续追加  
            // 写入换行符  
            fosPartOfArray.write("\n".getBytes());  
            // 写入字节数组的一部分  
            fosPartOfArray.write(partOfByteArray, 0, partOfByteArray.length);  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
}

测试代码3：Copy文本

package iotest.com;
import java.io.File;
import java.io.FileInputStream;  
import java.io.FileOutputStream;  
import java.io.IOException;  
//复制文本文件，把文本文件的内容从一个文件中读取出来 (数据源)，然后写入到另一个文件中
//数据源：
//E:\\Test\\a.txt 读数据:InputStream -->FileInputStream
//目的地：
//D:\\AA\\a.txt 写数据: OutputStream -->FileOutputStream 
public class FileCopyExample {  
    public static void main(String[] args) {  
        String sourceFile = "E:\\Test\\a.txt";  
        String destFile = "D:\\AA\\a.txt";  
  
        // 检查目标目录是否存在，如果不存在则创建它  
        File destDir = new File("D:\\AA");  
        if (!destDir.exists()) {  
            destDir.mkdirs(); // 创建目录结构  
        }  
  
        FileInputStream fis = null;  
        FileOutputStream fos = null;  
  
        try {  
            // 创建FileInputStream对象  
            fis = new FileInputStream(sourceFile);  
              
            // 创建FileOutputStream对象  
            fos = new FileOutputStream(destFile);  
  
            // 读取和写入数据  
            byte[] buffer = new byte[1024]; // 创建一个缓冲区  
            int length;  
            while ((length = fis.read(buffer)) > 0) { // 读取到文件末尾  
                fos.write(buffer, 0, length); // 写入读取到的数据  
            }  
  
            // 刷新输出流，确保所有数据都被写入文件  
            fos.flush();  
  
        } catch (IOException e) {  
            e.printStackTrace();  
        } finally {  
            // 关闭流  
            try {  
                if (fis != null) fis.close();  
                if (fos != null) fos.close();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
        }  
    }  
}

测试代码4：Copy图片

package iotest.com;
import java.io.FileInputStream;  
import java.io.FileOutputStream;  
import java.io.IOException;  
  
public class CopyImage {  
    public static void main(String[] args) {  
        String sourceFile = "E:\\Test\\a.jpg";  
        String destFile = "D:\\AA\\a.jpg";  
  
        // 检查目标目录是否存在，如果不存在则创建它  
        java.io.File destDir = new java.io.File("D:\\AA");  
        if (!destDir.exists()) {  
            destDir.mkdirs(); // 创建目录结构  
        }  
  
        FileInputStream fis = null;  
        FileOutputStream fos = null;  
        //读取次数并不直接对应于读取的字节总数。
        //例如，如果文件大小不是1024的整数倍，那么最后一次读取可能会读取少于1024个字节的数据，但读取次数仍然会增加1。
        int readCount = 0; // 读取次数计数器 
        try {  
            // 创建FileInputStream对象  
            fis = new FileInputStream(sourceFile);  
              
            // 创建FileOutputStream对象  
            fos = new FileOutputStream(destFile);  
  
            // 读写数据  
            byte[] buffer = new byte[1024]; // 创建一个1024字节的缓冲区  
            int bytesRead;  
            while ((bytesRead = fis.read(buffer)) != -1) { // 读取到文件末尾时返回-1  
                fos.write(buffer, 0, bytesRead); // 写入读取到的数据，注意只写入实际读取到的字节数  
                readCount++; // 每次读取后增加计数器  
            }  
  
            // 刷新输出流，FileOutputStream这一步是可选的，close()会调用flush() 。 
            // fos.flush();  
            System.out.println("Total read operations: " + readCount); // 打印读取次数  
  
        } catch (IOException e) {  
            e.printStackTrace();  
        } finally {  
            // 关闭流  
            try {  
                if (fis != null) fis.close();  
                if (fos != null) fos.close();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
        }  
    }  
}

测试代码5：字节缓冲流

package iotest.com;
import java.io.BufferedInputStream;  
import java.io.BufferedOutputStream;  
import java.io.FileInputStream;  
import java.io.FileOutputStream;  
import java.io.IOException;  
  
public class BufferedStreamDemo {  
  
    public static void main(String[] args) {  
        // 指定文件路径  
        String filePath = "E:\\Test\\a.txt";  
  
        // 使用try-with-resources语句自动关闭资源  
        try (  
            // 创建BufferedOutputStream，用于向文件写入数据  
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(filePath));  
        ) {  
             byte[] data = "Hello, Buffered Streams!".getBytes();  
            // 写入数据到文件  
            bos.write(data);  
            System.out.println("Data written to file successfully.");  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
  
        // 再次使用try-with-resources语句读取文件内容  
        try (  
            // 创建BufferedInputStream，用于从文件读取数据  
            BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath));  
        ) {  
            // 用于存储从文件中读取的数据  
            byte[] buffer = new byte[1024];  
            // 用于记录实际读取的字节数  
            int bytesRead;  
            // 读取文件内容  
            while ((bytesRead = bis.read(buffer)) != -1) {  
                // 打印读取到的数据  
                System.out.write(buffer, 0, bytesRead);  
            }  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
}

测试代码6：用字节缓冲流Copy视频。

package iotest.com;
import java.io.BufferedInputStream;  
import java.io.BufferedOutputStream;  
import java.io.File;  
import java.io.FileInputStream;  
import java.io.FileOutputStream;  
import java.io.IOException;  
  
public class TestCopyVideo {  
  
    public static void main(String[] args) {  
        String sourceFile = "E:\\Test\\a.avi";  
        String destinationFile = "D:\\AA\\a.avi";  
  
        // 确保目标目录存在  
        File destinationDir = new File(new File(destinationFile).getParent());  
        if (!destinationDir.exists()) {  
            destinationDir.mkdirs(); // 创建目录，包括所有必需的但不存在的父目录  
        }  
  
        // 使用try-with-resources自动关闭流  
        try (  
            BufferedInputStream bis = new BufferedInputStream(new FileInputStream(sourceFile));  
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destinationFile))  
        ) {  
            byte[] buffer = new byte[1024]; // 创建一个字节数组作为缓冲区  
            int bytesRead;  
  
            // 从源文件读取数据到缓冲区，然后写入到目标文件  
            while ((bytesRead = bis.read(buffer)) != -1) {  
                bos.write(buffer, 0, bytesRead);  
            }  
  
            System.out.println("文件复制成功！");  
        } catch (IOException e) {  
            e.printStackTrace();  
            System.out.println("文件复制失败！");  
        }  
    }  
}