Java 基础--File - IO流（2）-CSDN博客

本文链接：https://blog.csdn.net/m0_68844946/article/details/140204156

I/O流

定义

数据从硬盘流向内存为输入流，数据从内存流向硬盘为输出流。输入也叫读取数据，输出也叫写出数据。

IO分类

1.按照数据的流向分为：输入流和输出流

①输入流：把数据从其他设备上读取到内存中的流

②输出流：把数据从内存中写出到其他设备上的流

2.按照功能类型分为：字节流和字符流

①字节流：以字节为单位，读写数据的流

②字符流：以字符为单位，读写数据的流

字节流和字符流的顶级父类

字节流：①字节输入流：InputStream

②字节输出流：OutputStream

字符流：①字符输入流：Reader

②字符输出流：Writer

注：这些都是抽象父类，不能直接使用，要使用他们的子实现类

字节输出流（OutputStream）

一切皆为字节，我们存储的数据，文件，图片等都是以二进制数字的形式保存，都是一个一个的字节，传输的时候也是一样。java.io.OutputStream抽象类是表示字节输出流的所有类的父类，将指定的字节信息写出到目的地。

1.字节输出流的基本共性功能方法：

①public void close()：关闭此输出流并释放与此流相关联的任何系统资源当完成流的操作时，必须调用此方法，释放系统资源。

②public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。

③public void write(byte[] b, int off, int len)` ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。

④public abstract void write(int b)：将指定的字节输出。

FileOutputStream类（文件字节输出流）

OutputStream的子类，用于将数据写出到文件

构造方法

1.public FileOutputStream(File file)：创建文件输出流以写入由指定的File对象表示的文件

        // 使用File对象创建流对象
        File file = new File("a.txt");
        FileOutputStream fos = new FileOutputStream(file);

2.public FileOutputStream(String name)：创建文件输出流以指定的名称写入文件

        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("b.txt");

注：如果目标文件不存在,则创建，若存在，则覆盖。

常用方法：

1.写出字节：write(int b) 方法，每次可以写出一个字节数据

        FileOutputStream fos = new FileOutputStream(“D:/test/test.txt”);
        fos.write(97);
        fos.close();//文件中会写出a

注：虽然参数为int类型四个字节，但是只会保留一个字节的信息写出，因为这是字节输出流，一个字节一个字节输出，只会保留我们输出的那个字节。

2.写出字节数组：write(byte[] b)，每次可以写出数组中的数据

        File file = new File("D:/test/test.txt");
        FileOutputStream fos = new FileOutputStream(file);
        //写出一个字节数组大小的数据
        byte[] b={97,98,99,100};
        fos.write(b);
        byte[] b1="今天真好看".getBytes();
        fos.write(b1);
        fos.close();//写入abcd今天真好看

3.写出指定长度字节数组：write(byte[] b, int off, int len),每次写出从off索引开始，len个字节

        File file = new File("D:/test/test.txt");
        FileOutputStream fos = new FileOutputStream(file);
        //写出数组中指定长度的字节数据
        byte[] b={97,98,99,100};
        fos.write(b,1,2);
        fos.close();//写入bc

4.数据追加续写

public FileOutputStream(File file/String name,boolean append)：这个构造方法，参数中需要传入一个boolean类型的值，true表示追加数据，false表示清空原有数据，不写的话默认是false

        File file = new File("D:/test/test.txt");
        FileOutputStream fos = new FileOutputStream(file,true);
        //追加数据
        byte[] b={97,98,99,100};
        fos.write(b,1,2);
        fos.close();//写入bcbc

5.写出换行

        File file = new File("D:/test/test.txt");
        FileOutputStream fos = new FileOutputStream(file,true);
        //换行\r\n
        byte[] b={97,98,99,100};
        for(int i:b){
            fos.write(i);
            fos.write("\r\n".getBytes());
        }
        fos.close();

注：①回车符（\r）：回到一行的开头,如果在abcde中的c前回车后不做任何操作，再写数据的时候光标是在c前面

②换行符（\n）：另起一行，如果在abcde中的c前换行后不做任何操作，再写数据的时候光标是在e后面

字节输入流（InputStream）

java.io.InputStream 抽象类是表示字节输入流的所有类的父类，可以读取字节信息到内存中。定义了字节输入流的基本共性功能方法。

1.基本共性功能方法：

①public void close()：关闭此输入流并释放与此流相关联的任何系统资源。

②public abstract int read()：从输入流读取数据的下一个字节。

③public int read(byte[] b)：从输入流中读取一些字节数，并将它们存储到字节数组 b中。

FileInputStream类（文件字节输入流）

构造方法：

1.FileInputStream(File file)：通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。

        // 使用File对象创建流对象
        File file = new File("a.txt");
        FileInputStream fos = new FileInputStream(file);

2.public FileInputStream(String name)：通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。

        // 使用文件名称创建流对象
        FileInputStream fos = new FileInputStream("b.txt");

常用方法：

1.读取字节数据：read方法，从输入流中读取数据的下一个字节，自动提升为int类型，读取到文件末尾，返回-1。

 public static void main(String[] args) throws IOException {
        File file=new File("D:\\test\\test.txt");
        FileInputStream fis = new FileInputStream(file);
        int r;
        while ((r=fis.read())!=-1){
            System.out.println((char)r);//遍历文件中的全部字节
        }
        fis.close();
    }

2.使用字节数组读取：read(byte[] b)，每次读取b的长度个字节到数组中，返回读取到的有效字节个数，读取到末尾时，返回-1。

 public static void main(String[] args) throws IOException {
        File file=new File("D:\\test\\test.txt");
        FileInputStream fis = new FileInputStream(file);
        //每次读一个字节数组的数据
        byte[] b=new byte[3];
        int read =fis.read(b);//返回的int值是读取的有效字节个数
        System.out.println(read);//3
        System.out.println(new String(b));//bca
        fis.close();
    }

注：

读取到的数据赋值给字节数组b,每一次读取会覆盖前一次的数据如果字符的长度不是字节数组的整数倍，比如字节数组长度为3，但是读取到最后只剩2个字符，那么这两个字符会覆盖字符数组前两位，而第三位则还是上一次读取的字符，

改进如下：

 public static void main(String[] args) throws IOException {
        File file=new File("D:\\test\\test.txt");
        FileInputStream fis = new FileInputStream(file);
        byte[] b=new byte[3];
        //定义有效字节数
        int len;
        while ((len=fis.read(b))!=-1){
            String s=new String(b,0,len);
            System.out.println(s);
        }
        fis.close();
    }

字符输入流（Reader）

java.io.Reader抽象类是表示用于读取字符流的所有类的父类，可以读取字符信息到内存中。

1.基本共性功能方法：

①public void close()：关闭此流并释放与此流相关联的任何系统资源

②public int read()：从输入流读取一个字符

③public int read(char[] cbuf)：从输入流中读取一些字符，并将它们存储到字符数组 cbuf中

FileReader类

java.io.FileReader `类是读取字符文件的便捷类

构造方法：

①FileReader(File file)：创建一个新的 FileReader ，给定要读取的File对象

        // 使用File对象创建流对象
        File file = new File("a.txt");
        FileReader fr = new FileReader(file);

②FileReader(String fileName)：创建一个新的 FileReader ，给定要读取的文件的名称

        // 使用文件名称创建流对象
        FileReader fr = new FileReader("b.txt");

常用方法：

1.读取字符：read方法，每次可以读取一个字符的数据，提升为int类型，读取到文件末尾，返回-1，循环读取

public static void main(String[] args) throws IOException {
            //字符输入流
            FileReader fr=new FileReader(new File("F:\\test\\bbb.txt"));
            int r ;
            while ((r=fr.read())!=-1){
                System.out.println((char)r);
            }
            fr.close();
        }

2.使用字符数组读取：read(char[] cbuf)，每次读取b的长度个字符到数组中，返回读取到的有效字符个数，读取到末尾时，返回-1

public static void main(String[] args) throws IOException {
            //字符输入流
            FileReader fr=new FileReader(new File("F:\\test\\bbb.txt"));
            char[] c=new char[3];
            int l;
            while ((l=fr.read(c))!=-1){
                String s=new String(c,0,l);
                System.out.println(s);
            }
            fr.close();
        }

字符输出流(Writer)

java.io.Writer 抽象类是表示用于写出字符流的所有类的超类，将指定的字符信息写出到目的地

1.基本共性功能方法

①public abstract void close()：关闭此输出流并释放与此流相关联的任何系统资源

②public abstract void flush()：刷新此输出流并强制任何缓冲的输出字符被写出

③public void write(int b)：写出一个字符

④public void write(char[] cbuf)：将 cbuf.length字符从指定的字符数组写出此输出流

⑤public abstract void write(char[] b, int off, int len)：从指定的字符数组写出 len字符，从偏移量 off开始输出到此输出流

⑥public void write(String str)：写出一个字符串

FileWriter类

java.io.FileWriter 类是写出字符到文件的便利类。构造时使用默认字节缓冲区（之前输出流是从内存直接就写到硬盘中了，现在这个字符输出流是有一个缓冲区存在的，在向外界磁盘写数据的时候会先把数据写到缓冲区中，只有调用刷新或者关闭方法的时候，才会把当前缓冲区内的数据输出到指定文件中）

构造方法：

1.FileWriter(File file)：创建一个新的 FileWriter，给定要读取的File对象

        // 使用File对象创建流对象
        File file = new File("a.txt");
        FileWriter fw = new FileWriter(file);

2.FileWriter(String fileName)：创建一个新的 FileWriter，给定要读取的文件的名称

        // 使用文件名称创建流对象
        FileWriter fw = new FileWriter("b.txt");

常用方法：

1.写出字符：write(int b) 方法，每次可以写出一个字符数据

public static void main(String[] args) throws IOException {
        //文件字符输出流
        //FileWriter fw= new FileWriter("F:\\test\\aaa.txt");

        FileWriter fw= new FileWriter(new File("F:\\test\\aaa.txt"));
        fw.write("我");
        fw.write(30000);
        //写出的数据现在存放在缓冲区中，必须刷新或者关闭才能把数据输出到文件中。
        fw.close();

    }

关闭和刷新的区别

1.flush：刷新缓冲区，流对象可以继续使用

2.close：关闭流，释放系统资源，关闭前会刷新缓冲区，但流对象不可以继续使用。

public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileWriter fw = new FileWriter("F:\\test\\aaa.txt");
        // 写出数据，通过flush
        fw.write('刷'); // 写出第1个字符
        fw.flush();//写出成功
        fw.write('新'); // 继续写出第2个字符
        fw.flush();//写出成功
      
          // 写出数据，通过close
        fw.write('关'); // 写出第1个字符
        fw.close();
        fw.write('闭'); // 继续写出第2个字符,【报错】java.io.IOException: Stream closed
        fw.close();
    }

2.写出其他数据

①写出字符数组：write(char[] cbuf) 和 write(char[] cbuf, int off, int len)，每次可以写出字符数组中的数据，同FileOutputStream的用法一样。

       FileWriter fw= new FileWriter(new File("F:\\test\\aaa.txt"));
       char[] c="今天适合吹风".toCharArray();
       fw.write(c);
       fw.write(c,3,2);
       //写出的数据现在存放在缓冲区中，必须刷新或者关闭才能把数据输出到文件中。
       fw.close();

②写出字符串：write(String str) 和 write(String str, int off, int len)，每次可以写出字符串中的数据。

       FileWriter fw= new FileWriter(new File("F:\\test\\aaa.txt"));
       String s="今天太阳好大";
       fw.write(s);
       fw.write(s,2,3);
       //写出的数据现在存放在缓冲区中，必须刷新或者关闭才能把数据输出到文件中。
       fw.close();

③续写和换行：操作类似于FileOutputStream

   FileWriter fw= new FileWriter(new File("F:\\test\\aaa.txt"),true);
   fw.write("今天太阳好大");
   fw.write("\r\n");
   fw.write("今天");
   //写出的数据现在存放在缓冲区中，必须刷新或者关闭才能把数据输出到文件中。
   fw.close();

总结

凡是自己能写出来的用字符流，字符写不出来的比如图片，视频等用字节流。

IO流的异常处理

第一种方式：

public static void main(String[] args){
         FileInputStream fis=null;
        FileOutputStream fos=null;
         try{
            fis=new FileInputStream("C:\\test\\完整的页面效果图.jpg");
            fos=new FileOutputStream("C:\\test\\1.jpg");
            byte[] b=new byte[1024];
            int l=0;
            while((l=fis.read(b))!=-1){
                fos.write(b,0,l);
            }
        }catch(IOException e){
            e.printStackTrace();
        }finally {
            try {
                if(fos!=null){
                    fos.close();
                }

            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(fis!=null){
                    fis.close();
                }

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

第二种方式：1.7之后流的简化版处理异常的方式.不再需要自己关流，这种方式会自动关流

public static void main(String[] args) throws IOException {
        //第二种方式
        try(
            FileInputStream fis=new FileInputStream("C:\\test\\完整的页面效果图.jpg");
            FileOutputStream fos=new FileOutputStream("C:\\test\\1.jpg")
            ){
            byte[] b=new byte[1024];
            int l=0;
            while((l=fis.read(b))!=-1){
                fos.write(b,0,l);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }