Surpass Day24——Java IO流1

目录

1、什么是IO流

2、流的分类

2.1 按照流的方向进行分类

2.2 按照读取数据方式的不同来进行分类

3、流的四大家族

4、常用的IO流

4.1 文件专属

4.1.1 FileInputStream读文件（字节输入流）

4.1.2 FileOutputStream写文件（字节输出流）

4.1.3 文件的复制

4.1.4 FileReader读文件（字符输入流）

4.1.5 FileWriter写文件（字符输出流）

---

*

1、什么是IO流

文件通常是由一连串的字节或字符构成，组成文件的字节序列 称为 字节流 ，组成文件的字符序列称为字符流，

Java 中根据流的方向可以分为输入流和输出流： I：Input，输入流是将文件或其它输入设备的数据加载到内存的过程 O：Output，输出流恰恰相反，是将内存中的数据保存到文件或其它输出设备

简单来说，通过IO流可以完成对硬盘文件的读和写

2、流的分类

2.1 按照流的方向进行分类

以内存作为参照物，往内存中去叫做输入（Input）读（Read），从内存中出来叫做输出（Output）写（Write）

2.2 按照读取数据方式的不同来进行分类

1）按照字节的方式读取数据

一次读取一个字节，等同于一次读取8个二进制位，这种流是万能的，什么类型的文件都可以读取，包括文本文件、图片、声音文件、视频文件等。

2）按照字符的方式读取数据

一次读取一个字符，这种流是为了方便读取普通文本文件而存在的，这种流不能读取图片、声音、视频等文件，只能读取纯文本文件，连word文件都无法读取

综上所述，流的分类： 输入流、输出流

字节流、字符流

举个例子，假设我们有一个文件file1.txt，里面的内容是：a中国bc张三fe

采用字节流的话是这样读的： 第一次读：一个字节，正好读到'a' 第二次读：一个字节，正好读到'中'字符的一半 第三次读：一个字节，正好读到'中'字符的另外一半

采用字符流的话是这样读的： 第一次读：'a' 字符（'a'字符在windows系统中占用1个字节） 第二次读：'中' 字符（'中'字符在windows系统中占用2个字节）

3、流的四大家族

怎么学好IO流？ Java中的IO流都已经写好了（在java.io.*包下），因此程序员不需要关心具体怎么去实现，我们最主要的还是掌握如何使用就好，掌握在java中已经提供了哪些流，每个流的特点是什么，每个流对象的常用方法有哪些以及如何使用？

我们要学会怎么new流对象? 我们要学会调用流对象的方法，知道哪个方法是读，哪个方法是写

下面首先介绍一下IO流的四大家族：

1）四大家族的首领：

• java.io.InputStream 字节输入流

• java.io.OutputStream 字节输出流

• java.io.Reader 字符输入流

• java.io.Writer 字符输出流

2）四大家族的首领都是抽象类(abstract class)

3）所有的流都实现了 java.io.Closeable 接口，都是可关闭的，都有close()这个方法

4）所有的输出流都实现了 java.io.Flushable 接口，都是可刷新的，都有flush()方法

注意：

流毕竟是一个管道，这个是内存和硬盘之间的通道，用完之后一定要关闭，不然会占用很多资源，因此在后面的学习和使用中要养成好习惯，用完流一定要关闭！同时，输出流在最终输出之后，也要记得使用flush()方法刷新一下，这个刷新表示将通道/管道当中剩余未输出的数据强行输出完（清空管道！）（注意：如果没有flush()可能会导致数据丢失）

4、常用的IO流

java.io包下需要掌握的16个流：

⭐️文件专属：

• java.io.FileInputStream（重点掌握）

• java.io.FileOutputStream（重点掌握）

• java.io.FileReader

• java.io.FileWriter

⭐️转换流：（将字节流转换成字符流）

• java.io.InputStreamReader 主要是将字节输入流转换成字符输入流

• java.io.OutputStreamWriter 主要是将字节输出流转换成字符输出流

⭐️缓冲流：（缓冲流主要是为了提高效率而存在的，它可以减少物理读取次数）

• java.io.BufferedReader

• java.io.BufferedWriter

• java.io.BufferedInputStream

• java.io.BufferedOutputStream

⭐️数据流专属：

• java.io.DataInputStream

• java.io.DataOutputStream

⭐️标准输出流：

• java.io.PrintWriter

• java.io.PrintStream（掌握）

⭐️对象流专属：

• java.io.ObjectInputStream（掌握）

• java.io.ObjectOutputStream（掌握）

总结：以Writer和Reader结尾的叫字符流，以Stream结尾的叫字节流！

4.1 文件专属

4.1.1 FileInputStream读文件（字节输入流）

FileInputStream：文件字节输入流，万能的，任何类型的文件都可以采用这个流来读取

首先我们在E:\01javaSE\test这个目录下新建一个test.txt文件，然后在IDEA中编写测试代码

package com.java.javase.IO1;
​
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
​
public class FileInputStreamTest01 {
    public static void main(String[] args) {
        // 创建文件字节输入流对象
        FileInputStream fis=null;
        try {
            // 文件路径：E:\01javaSE\test（IDEA会自动把\编成\\，因为java中\表示转义）
            fis=new FileInputStream("E:\\01javaSE\\test\\test.txt");
            // 开始读
            while(true){
                // 调用read()方法，返回值是读取的数据所对应的ASCII码，例如读取ab，则打印出的结果是97 98
                // 当没有数据可以读取时，返回值是-1
                int readDate=fis.read();
                if(readDate==-1){
                    break;
                }
                System.out.print(readDate+" ");
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 在finally语句块中要确保流最后被关闭，并且被关闭的前提是流不为空（流为空也没必要关！避免空指针异常）
            if(fis!=null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

注意点：程序执行结束后，在finally语句块中确保流一定被关闭，并且关闭流的前提是流不为空，因为流是null的时候没必要关闭，这样做可以避免空指针异常！

并且上面代码中的while循环有点冗余，因此可以改造一下上面代码中的while循环：

int readDate=0;
while((readDate=fis.read())!=-1){
    System.out.print(readDate+" ");
}

改进以后我们再来分析这个程序存在哪些缺点？

一次读取一个字节（byte），这样内存和硬盘交互太频繁，会浪费大量的时间和资源在交互上面，因此我们需要对其进行改进，使其可以一次读取多个字节

read(byte[] b)方法，从此输入流中将最多b.length个字节的数据读入一个byte数组中，下面我们就使用这个方法对之前的程序进行改造，减少硬盘和内存的交互，提高程序的执行效率

package com.java.javase.IO1;
​
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
​
public class FileInputStreamTest01 {
    public static void main(String[] args) {
        // 创建文件字节输入流对象
        FileInputStream fis=null;
        try {
            // 文件路径：E:\01javaSE\test（IDEA会自动把\编成\\，因为java中\表示转义）
            fis=new FileInputStream("E:\\01javaSE\\test\\test.txt");
            // 开始读
            while(true){
                // 创建一个byte数组
                byte[]bytes=new byte[4];
                while(true){
                    // 下面这个方法的返回值是读到的字节数量，一个字节都没有读到则返回-1
                    int readCount=fis.read(bytes);
                    if(readCount==-1){
                        break;
                    }
                    System.out.println(readCount);
                    // 将byte数组转换成字符串String，读取到多少个字节就转换多少个字节
                    System.out.println(new String(bytes,0,readCount));                }
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 在finally语句块中要确保流最后被关闭，并且被关闭的前提是流不为空（流为空也没必要关！避免空指针异常）
            if(fis!=null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

FileInputStream类的其它常用方法：

• int available() 返回一个int类型的值，表示流当中剩余的没有读到的字节数量，可以在未读取之前获取总字节数量，这样就可以很方便的确定用于读取的byte数组的长度，但是这种方式不太适合太大的文件，因为byte[]数组不能太大！

• long skip() 跳过几个字节不读

第一个方法演示

package com.java.javase.IO1;
​
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
​
public class FileInputStreamTest02 {
    public static void main(String[] args) {
        FileInputStream fis=null;
        try{
            fis=new FileInputStream("E:\\01javaSE\\test\\test.txt");
            System.out.println("总字节数量:"+fis.available());
            int readByte=fis.read();
            System.out.println("还剩下多少个字节没有读： "+fis.available());
​
        }catch(FileNotFoundException e){
            e.printStackTrace();
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            if(fis!=null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

第二个方法演示

package com.java.javase.IO1;
​
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
​
public class FileInputStreamTest02 {
    public static void main(String[] args) {
        FileInputStream fis=null;
        try{
            fis=new FileInputStream("E:\\01javaSE\\test\\test.txt");
            fis.skip(3);
            System.out.println(fis.read());
​
        }catch(FileNotFoundException e){
            e.printStackTrace();
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            if(fis!=null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

4.1.2 FileOutputStream写文件（字节输出流）

FileOutputStream：文件字节输出流，负责写

package com.java.javase.IO1;
​
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
​
public class FileOutputStreamTest01 {
    public static void main(String[] args) {
        FileOutputStream fos=null;
        try{
            // 工程Project的根就是IDEA的默认当前路径
            // append:true的作用是以追加的方式在文件末尾写入，不会清空源文件内容
            fos=new FileOutputStream("chapter6/src/com/java/javase/IO1/IODocument",true);
            byte[]bytes={97,98,99,100};
            // 将byte数组全部写出
            fos.write(bytes);
            fos.flush();                       // 写完之后,最后一定要刷新
        }catch(FileNotFoundException e){
            e.printStackTrace();
        }catch(IOException e){
            e.printStackTrace();
        }finally{
            if(fos!=null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
             }
        }
    }
}

我们可以指定只写byte数组的一部分

package com.java.javase.IO1;
​
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
​
public class FileOutputStreamTest01 {
    public static void main(String[] args) {
        FileOutputStream fos=null;
        try{
            // 工程Project的根就是IDEA的默认当前路径
            // append:true的作用是以追加的方式在文件末尾写入，不会清空源文件内容
            fos=new FileOutputStream("chapter6/src/com/java/javase/IO1/IODocument",true);
            byte[]bytes={97,98,99,100};
            // 将byte数组的一部分写出(数组，起始下标，长度)
            fos.write(bytes,0,2);
​
            fos.flush();                       // 写完之后,最后一定要刷新
        }catch(FileNotFoundException e){
            e.printStackTrace();
        }catch(IOException e){
            e.printStackTrace();
        }finally{
            if(fos!=null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
​
}

写入中文字符串

String s1="我是一个大学生！";
byte[]bs=s1.getBytes();
fos.write(bs);

4.1.3 文件的复制

• 使用FileInputStream+FileOutputStream完成文件的拷贝

• 拷贝的过程应该是一边读，一边写

• 使用以上的字节流拷贝文件的时候，文件类型是随意的

package com.java.javase.IO1;
import java.io.*;
​
public class Copy1 {
    public static void main(String[] args) {
        FileInputStream fis=null;
        FileOutputStream fos=null;
        try {
            fis=new FileInputStream("chapter6/src/com/java/javase/IO1/IODocument");
            fos=new FileOutputStream("E:\\01javaSE\\test\\test.txt",true);
            // 一次拷贝1MB
            byte[]bytes=new byte[1024*1024];
            int readCount=0;
            while((readCount=fis.read(bytes))!=-1){
                fos.write(bytes,0,readCount);
            }
            fos.flush();
​
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            if(fis!=null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fos!=null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
​

4.1.4 FileReader读文件（字符输入流）

• 文件字符输入流，按照字符的方式去读取，只能读取普通文本

• 读取文本内容时，比较方便和快捷

• 读取时使用的是char数组

package com.java.javase.IO2;
​
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
​
public class FileReaderTest01 {
    public static void main(String[] args) {
        FileReader fr=null;
        try{
            fr=new FileReader("E:\\01javaSE\\test\\test.txt");
            char[]chars=new char[4];
            int readCount=0;
            while((readCount=fr.read(chars))!=-1){
                System.out.println(new String(chars,0,readCount));
            }
​
        }catch(FileNotFoundException e){
            e.printStackTrace();
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            if(fr!=null){
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

4.1.5 FileWriter写文件（字符输出流）

• 文件字符输出流，FileReader的兄弟，负责写

• 只能输出普通文本

package com.java.javase.IO2;
​
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
​
public class FileWriterTest01 {
    public static void main(String[] args) {
        FileWriter fw=null;
        try{
            // 创建文件字符输出流对象，并且指定写的方式是追加
            fw=new FileWriter("E:\\01javaSE\\test\\test.txt",true);
            char[]chars={'1','我','是','中','国','人'};
            fw.write(chars);
​
            // 输出流刷新
            fw.flush();
        }catch(FileNotFoundException e){
            e.printStackTrace();
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            if(fw!=null){
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

写入换行符

fw.write("\n");
fw.write("HelloWorld");