java IO流(一) IO流概述字节流 IO流资源释放

slh别学了

已于 2024-03-14 18:50:13 修改

阅读量423

点赞数

分类专栏： java 文章标签： java 开发语言

于 2023-07-12 23:18:26 首次发布

本文链接：https://blog.csdn.net/weixin_43739821/article/details/131691302

版权

java 专栏收录该内容

34 篇文章 1 订阅

订阅专栏

IO流概述

File类只能操作文件，但是不能操作文件中的内容，IO流则可以对文件或者网络中的数据进行读、写操作。

IO流分为两大派系：
1.字节流：字节流又分为字节输入流、字节输出流
2.字符流：字符流由分为字符输入流、字符输出流

请添加图片描述

字节流-FileInputStream-读取一个字节
使用FileInputStream读取文件中的字节数据，步骤如下

第一步：创建FileInputStream文件字节输入流管道，与源文件接通。
第二步：调用read()方法开始读取文件的字节数据。
第三步：调用close()方法释放资源

需要用到的方法如下图

请添加图片描述

示例代码如下

public class FileInputStreamTest1 {
    public static void main(String[] args) throws Exception {
        // 1、创建文件字节输入流管道，与源文件接通。
        InputStream is = new FileInputStream(("file-io-app\\src\\01.txt"));

        // 2、开始读取文件的字节数据。
        // public int read():每次读取一个字节返回，如果没有数据了，返回-1.
        int b; // 用于记住读取的字节。
        while ((b = is.read()) != -1){
            System.out.print((char) b);
        }
        
        //3、流使用完毕之后，必须关闭！释放系统资源！
        is.close();
    }
}

这里要注意，由于一个中文在UTF-8编码方案中是占3个字节，采用一次读取一个字节的方式就相当于读了1/3个汉字，此时将这个字节转换为字符，是会有乱码的。

字节流

字节流-FileInputStream-读取多个字节
上面一次读取一个字节的读取方式效率太慢了，为了提高效率，我们可以使用另一个read(byte[] bytes)的重载方法，可以一次读取多个字节，至于一次读多少个字节，就在于你传递的数组有多大。

public class FileInputStreamTest2 {
   public static void main(String[] args) throws Exception {
       // 1、创建一个字节输入流对象代表字节输入流管道与源文件接通。
       InputStream is = new FileInputStream("file-io-app\\src\\02.txt");

       // 2、开始读取文件中的字节数据：每次读取多个字节。
       //  public int read(byte b[]) throws IOException
       //  每次读取多个字节到字节数组中去，返回读取的字节数量，读取完毕会返回-1.

       // 3、使用循环改造。
       byte[] buffer = new byte[3];
       int len; // 记住每次读取了多少个字节。  abc 66
       while ((len = is.read(buffer)) != -1){
           // 注意：读取多少，倒出多少。
           String rs = new String(buffer, 0 , len);
           System.out.print(rs);
       }
       // 性能得到了明显的提升！！
       // 这种方案也不能避免读取汉字输出乱码的问题！！

       is.close(); // 关闭流
   }
}

read(byte[] bytes)它的返回值，表示当前这一次读取的字节个数。而且并不是每次读取的时候都把数组装满，当没有3个字节的数据了，只会将剩余字节读到字节数组中去。

字节流-FileInputStream-读取全部字节
我们可以一次性读取文件中的全部字节，然后把全部字节转换为一个字符串，就不会有乱码了。但是文件不能过大，如果文件过大，可能导致内存溢出。

请添加图片描述

// 1、一次性读取完文件的全部字节到一个字节数组中去。
// 创建一个字节输入流管道与源文件接通
InputStream is = new FileInputStream("file-io-app\\src\\03.txt");

// 2、准备一个字节数组，大小与文件的大小正好一样大。
File f = new File("file-io-app\\src\\03.txt");
long size = f.length();//要用long接收 因为文件大小可能很大
byte[] buffer = new byte[(int) size];

int len = is.read(buffer);
System.out.println(new String(buffer));

//3、关闭流
is.close();

请添加图片描述

// 1、一次性读取完文件的全部字节到一个字节数组中去。
// 创建一个字节输入流管道与源文件接通
InputStream is = new FileInputStream("file-io-app\\src\\03.txt");

//2、调用方法读取所有字节，返回一个存储所有字节的字节数组。
byte[] buffer = is.readAllBytes();
System.out.println(new String(buffer));

//3、关闭流
is.close();

FileOutputStream-写字节
使用FileOutputStream往文件中写数据的步骤如下：

第一步：创建FileOutputStream文件字节输出流管道，与目标文件接通。
第二步：调用wirte()方法往文件中写数据
第三步：调用close()方法释放资源

请添加图片描述

public class FileOutputStreamTest4 {
    public static void main(String[] args) throws Exception {
        // 1、创建一个字节输出流管道与目标文件接通。
        // 覆盖管道：覆盖之前的数据
//        OutputStream os =
//                new FileOutputStream("file-io-app/src/04out.txt");//如果没有文件会自动生成一个文件

        // 追加数据的管道:会在原有数据基础上添加写入的数据
        OutputStream os =
                new FileOutputStream("file-io-app/src/04out.txt", true);

        // 2、开始写字节数据出去了
        os.write(97); // 97就是一个字节，代表a
        os.write('b'); // 'b'也是一个字节
        // os.write('磊'); // 汉字在默认的UTF-8下由三个字节组成 但是默认只能写出去一个字节 会乱码

        byte[] bytes = "我爱你中国abc".getBytes();
        os.write(bytes);//一次也可以写入一个字节数组

        os.write(bytes, 0, 15);//写入的是“我爱你中国”

        // 换行符 win平台是\n 但是\r\n能兼容更多平台
        os.write("\r\n".getBytes());//因为不是一个字节 所以转成字节数组写入

        os.close(); // 关闭流
    }
}

字节流案例-复制文件
学完字节流的输入和输出，尝试综合使用它们来完成一个复制文件的案例。

public class CopyTest5 {
    public static void main(String[] args) throws Exception {
        // 需求：复制照片。
        // 1、创建一个字节输入流管道与源文件接通
        InputStream is = new FileInputStream("D:/resource/meinv.png");
        // 2、创建一个字节输出流管道与目标文件接通。
        OutputStream os = new FileOutputStream("C:/data/meinv.png");

        //System.out.println(10 / 0);
        // 3、创建一个字节数组，负责转移字节数据。
        byte[] buffer = new byte[1024]; // 1KB.
        // 4、从字节输入流中读取字节数据，写出去到字节输出流中。读多少写出去多少。
        int len; // 记住每次读取了多少个字节。
        while ((len = is.read(buffer)) != -1){
            os.write(buffer, 0, len);
        }

        os.close();//注意 规范的关闭流的方法是后创建的先关闭 可以规避bug
        is.close();
        System.out.println("复制完成！！");
        
        //其实这个程序不止可以复制照片 可以复制一切类型的文件 并且不会有乱码
    }
}

IO流资源释放

流使用完之后一定要释放资源,但是我们之前复制文件的代码存在一些问题:

public class CopyTest5 {
    public static void main(String[] args) throws Exception {
        InputStream is = new FileInputStream("D:/resource/meinv.png");
        OutputStream os = new FileOutputStream("C:/data/meinv.png");

		System.out.println(10 / 0);//这里出现程序异常之后程序就终止了！
        byte[] buffer = new byte[1024];
        int len; 
        while ((len = is.read(buffer)) != -1){
            os.write(buffer, 0, len);
        }

        os.close();//所以这里释放资源的代码根本没有执行！
        is.close();
        System.out.println("复制完成！！");

    }
}

那这个问题怎么解决呢？在JDK7以前，和JDK7以后分别给出了不同的处理方案。

JDK7以前的资源释放
在JDK7版本以前，我们可以使用try…catch…finally语句来处理。格式如下:

try{
    //有可能产生异常的代码
}catch(异常类 e){
    //处理异常的代码
}finally{
    //释放资源的代码
    //finally里面的代码有一个特点，不管异常是否发生，finally里面的代码都会执行，除非JVM终止
}

所以上面有问题的代码就可以更改成下面的代码，但是可读性很差。

public class Test2 {
    public static void main(String[] args)  {
        InputStream is = null;
        OutputStream os = null;
        try {
            System.out.println(10 / 0);//这里发生错误
            // 1、创建一个字节输入流管道与源文件接通
            is = new FileInputStream("file-io-app\\src\\03.txt");
            // 2、创建一个字节输出流管道与目标文件接通。
            os = new FileOutputStream("file-io-app\\src\\03copy.txt");

            System.out.println(10 / 0);

            // 3、创建一个字节数组，负责转移字节数据。
            byte[] buffer = new byte[1024]; // 1KB.
            // 4、从字节输入流中读取字节数据，写出去到字节输出流中。读多少写出去多少。
            int len; // 记住每次读取了多少个字节。
            while ((len = is.read(buffer)) != -1){
                os.write(buffer, 0, len);
            }
            System.out.println("复制完成！！");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 释放资源的操作
            try {
                if(os != null) os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            //这里这样写是因为如果只写个os.close();会报错 idea会提醒你有可能在之前就已经关闭过os了
            //或者说os可能是null 所以这里也要写好异常的代码
            try {
                if(is != null) is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

JDK7以后的资源释放
try…catch…finally处理异常，并释放资源代码比较繁琐,Java在JDK7版本为我们提供了一种简化的释放资源的操作try-with-resource，它会自动释放资源。

请添加图片描述

try(定义资源对象1; 定义资源对象2;...){
    使用资源的代码
}catch(异常类 e){
    处理异常的代码
}
//注意到没有，这里没有释放资源的代码。它会自动释放资源

public class Test3 {
    public static void main(String[] args)  {
    	try (
          // 1、创建一个字节输入流管道与源文件接通
          InputStream is = new FileInputStream("D:/resource/meinv.png");
          // 2、创建一个字节输出流管道与目标文件接通。
          OutputStream os = new FileOutputStream("C:/data/meinv.png");
          //注意这里只能放资源对象(流对象) 定义个int会报错无法释放
        ){
            // 3、创建一个字节数组，负责转移字节数据。
            byte[] buffer = new byte[1024]; // 1KB.
            // 4、从字节输入流中读取字节数据，写出去到字节输出流中。读多少写出去多少。
            int len; // 记住每次读取了多少个字节。
            while ((len = is.read(buffer)) != -1){
                os.write(buffer, 0, len);
            }
            System.out.println(conn);
            System.out.println("复制完成！！");

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

slh别学了

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java IO流(一) IO流概述字节流 IO流资源释放

java IO流(一) IO流概述字节流 FileInputStream-读取一个字节 FileInputStream-读取多个字节 IO流资源释放 try...catch...finally try-with-resource
复制链接

扫一扫