Java_IO流(字节流)

2023-12-29 10:36:26

一、IO流(字节流)

1.1 IO流概述

在前面已经学习过File类。知道File只能操作文件,但是不能操作文件中的内容。我们也学习了字符集,不同的字符集存字符数据的原理是不一样的。有了前面两个知识的基础,接下来我们再学习IO流,就可以对文件中的数据进行操作了。

IO流的作用:就是可以对文件或者网络中的数据进行读、写的操作。如下图所示

  • 把数据从磁盘、网络中读取到程序中来,用到的是输入流。
  • 把程序中的数据写入磁盘、网络中,用到的是输出流。
  • 简单记:输入流(读数据)、输出流(写数据)

在这里插入图片描述
IO流在Java中有很多种,不同的流来干不同的事情。Java把各种流用不同的类来表示,这些流的继承体系如下图所示:

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

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

1.2 FileInputStream读取一个字节

接下来学习字节流中的字节输入流,用InputStream来表示。但是InputStream是抽象类,我们用的是它的子类,叫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\\itheima01.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个汉字,此时将这个字节转换为字符,是会有乱码的。

1.3 FileInputStream读取多个字节

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

使用FileInputStream一次读取多个字节的步骤如下

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

代码如下:
在这里插入图片描述

/**
 * 目标:掌握使用FileInputStream每次读取多个字节。
 */
public class FileInputStreamTest2 {
    public static void main(String[] args) throws Exception {
        // 1、创建一个字节输入流对象代表字节输入流管道与源文件接通。
        InputStream is = new FileInputStream("file-io-app\\src\\itheima02.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)它的返回值,表示当前这一次读取的字节个数。

假设有一个a.txt文件如下:

abcde

每次读取过程如下

也就是说,并不是每次读取的时候都把数组装满,比如数组是 byte[] bytes = new byte[3];
第一次调用read(bytes)读取了3个字节(分别是97,98,99),并且往数组中存,此时返回值就是3
第二次调用read(bytes)读取了2个字节(分别是99,100),并且往数组中存,此时返回值是2
第三次调用read(bytes)文件中后面已经没有数据了,此时返回值为-1
  • 还需要注意一个问题:采用一次读取多个字节的方式,也是可能有乱码的。因为也有可能读取到半个汉字的情况。

1.4 FileInputStream读取全部字节

前面我们到的读取方式,不管是一次读取一个字节,还是一次读取多个字节,都有可能有乱码。那么接下来我们介绍一种,不出现乱码的读取方式。

我们可以一次性读取文件中的全部字节,然后把全部字节转换为一个字符串,就不会有乱码了。
在这里插入图片描述

public static void main(String[] args) throws Exception {
        //System.out.println("Hello xsy!");
        //1.一次性读取完文件的全部字节到一个字节数组中去
        //创建一个字节输入流管道与源文件接通
        InputStream is=new FileInputStream("oop-day10\\src\\xsy.txt");

        //得到一个该文件的对象
        File f=new File("oop-day10\\src\\xsy.txt");
        //得到文件的大小
        long size=f.length();
        //准备一个字节数组,大小与文件的大小正好一样大
        byte[]buffer=new byte[(int)size];

        int len=is.read(buffer);

        //将字节数组中的字节转换成字符串
        System.out.println(new String(buffer));

        System.out.println("size:"+size);
        System.out.println("len"+len);

        is.close();
    }

在这里插入图片描述

// 1、一次性读取完文件的全部字节到一个字节数组中去。
// 创建一个字节输入流管道与源文件接通
InputStream is = new FileInputStream("file-io-app\\src\\itheima03.txt");
 
//2、调用方法读取所有字节,返回一个存储所有字节的字节数组。
byte[] buffer = is.readAllBytes();
System.out.println(new String(buffer));
 
//3、关闭流
is.close(); 

最后,还是要注意一个问题:一次读取所有字节虽然可以解决乱码问题,但是文件不能过大,如果文件过大,可能导致内存溢出。
在这里插入图片描述

1.5 FileOutputStream写字节

各位同学,前面我们学习了使用FIleInputStream读取文件中的字节数据。然后有同学就迫不及待的想学习往文件中写入数据了。

往文件中写数据需要用到OutputStream下面的一个子类FileOutputStream。写输入的流程如下图所示
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

使用FileOutputStream往文件中写数据的步骤如下:

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

代码如下:

/**
 * 目标:掌握文件字节输出流FileOutputStream的使用。
 */
public class FileOutputStreamTest4 {
    public static void main(String[] args) throws Exception {
        // 1、创建一个字节输出流管道与目标文件接通。
        // 覆盖管道:覆盖之前的数据
//        OutputStream os =
//                new FileOutputStream("file-io-app/src/itheima04out.txt");
 
        // 追加数据的管道
        OutputStream os =
                new FileOutputStream("file-io-app/src/itheima04out.txt", true);
 
        // 2、开始写字节数据出去了
        os.write(97); // 97就是一个字节,代表a
        os.write('b'); // 'b'也是一个字节
        // os.write('磊'); // [ooo] 默认只能写出去一个字节
 
        byte[] bytes = "我爱你中国abc".getBytes();
        os.write(bytes);
 
        os.write(bytes, 0, 15);
 
        // 换行符
        os.write("\r\n".getBytes());
 
        os.close(); // 关闭流
    }
}

1.6 字节流复制文件

比如:我们要复制一张图片,从磁盘D:/resource/meinv.png的一个位置,复制到C:/data/meinv.png位置。
在这里插入图片描述

复制文件的思路如下图所示:

1.需要创建一个FileInputStream流与源文件接通,创建FileOutputStream与目标文件接通
2.然后创建一个数组,使用FileInputStream每次读取一个字节数组的数据,存如数组中
3.然后再使用FileOutputStream把字节数组中的有效元素,写入到目标文件中

代码如下:

/**
 * 目标:使用字节流完成对文件的复制操作。
 */
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();
        is.close();
        System.out.println("复制完成!!");
    }
}

二、IO流资源释放

流使用完之后一定要释放资源。但是之前的代码并不是很专业。

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

2.1 JDK7以前的资源释放

在这里插入图片描述

使用try…catch…finally的注意事项:

1.不管异常是否发生,finally里面的代码都会执行。

public static void main(String[] args) {

        try{
            System.out.println(10/2);
        }catch (Exception e)
        {
            e.printStackTrace();
        }finally {
            System.out.println("===finally被执行了一次===");
        }
    }

在这里插入图片描述
在这里插入图片描述

2.即便不加finally,最后的代码也可以执行,那么为什么必须加上呢?
在这里插入图片描述
只是在try里面没有返回语句的情况下会执行下面的代码,当try里面有返回语句的时候是不会执行下面代码的。
在这里插入图片描述
加上finally后即便有返回语句跳出,也会执行finally里面的语句,只有当finally里面的语句执行完之后才会返回
在这里插入图片描述
只有一种情况不会执行finally里面的语句,就是当虚拟机挂掉后不会执行
在这里插入图片描述

当方法有返回值的时候,不仅try里面要返回数据,catch里面也需要返回数据,目的仅仅是代表出现异常,让程序编译不报错。
在这里插入图片描述
千万不要在finally中返回数据!这样会导致返回的数据不正确在这里插入图片描述
原因就是try中的return语句会等待finally里面的语句执行,但是finally里面是return语句,所以直接跳出了循环,导致try里面的return语句无法执行。

在JDK7版本以前,我们可以使用try…catch…finally语句来处理。格式如下

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

改造之前的复制代码:

为什么会报编译时异常呢?它担心在try代码块里面程序运行中已经将流关闭了,所以提醒程序员在finally块里面关闭就不要在前面进行关闭了。还有一种情况就是在创建流之前程序就出现错误就会跳到catch里面来,最后执行finally里面的代码,此时流还没有创建,is和os还是null,在finally里面进行关闭就相当于null.close(),会出现空指令,是错误的
在这里插入图片描述

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\\itheima03.txt");
            // 2、创建一个字节输出流管道与目标文件接通。
            os = new FileOutputStream("file-io-app\\src\\itheima03copy.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();
            }
            try {
                if(is != null) is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

代码写到这里,有很多同学就已经看不下去了。是的,我也看不下去,本来几行代码就写完了的,加上try…catch…finally之后代码多了十几行,而且阅读性并不高。难受…

2.2 JDK7以后的资源释放

在这里插入图片描述

try…catch…finally处理异常,并释放资源代码比较繁琐。Java在JDK7版本为我们提供了一种简化的是否资源的操作,它会自动是否资源。代码写起来也想当简单。

格式如下:

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

代码如下:

/**
 * 目标:掌握释放资源的方式:try-with-resource
 */
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");
        ){
            // 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();
        }
    }
}

注意:try的( )里面只能放资源对象
什么是资源呢?从系统级别来理解,就是要占系统资源,进行文件的读写,底层占用系统资源,这样的对象就是资源。Java为了方便在程序中识别资源,它规定资源都会实现一个接口,这个接口是AutoCloseable接口(自动关闭的意思)。资源都会有一个close方法,并且资源放到try的( )里面,用完之后,会被自动调用其close方法完成资源的释放操作。

文章来源:https://blog.csdn.net/qq_48083892/article/details/135204035
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。