IO流

IO流

概述

IO：Input(输入)，Output(输出)，往一个文件中输出内容或从一个文件中读取内容，这个过程就是IO操作。

输入Input：读取外部数据（磁盘，光盘等存储设备的数据）到程序（内存）中。

输出Ouput：将程序（内存）数据输出到磁盘，光盘等存储设备中。

IO分类

Java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。

①按照数据的流向不同分为：输入流和输出流（从内存角度上看）

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

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

②按操作数据单位的不同分为：字节流（8bit）和字符流（16bit）

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

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

③根据IO流的角色不同分为：节点流和处理流

　　节点流：直接从数据源或目的地读写数据

　　处理流：不直接连接到数据源或目的地，而是“连接”在已存在的流（节点流或处理流）之上，通过对数据的处理为程序提供更为强大的读写功能

IO流框架

 本章中主要学习标注红色的流。

InputStream类

它是一个字节输入流，流的内容是字节单位，它是所有直接输入流的父类。而该类中最常用的一个子类FileInputStream。这种流适合图片，音频，视频的操作。

操作步骤：

第1步：创建读取的File类的对象
第2步：创建FileInputStream输入流
第3步：具体的读入的过程
      read()：一个一个进行读取，当没有字符时返回-1
第4步：关闭流资源，避免内存泄露

举个例子：

public class Test {
    public static void main(String[] args) {
        FileInputStream fs= null;
        try {
            //1.创建file文件对象
            File file =new File("a.txt");
            //2.创建输入流(这里会存在异常需要进行处理)
            fs = new FileInputStream(file);
            int a;
            //3.读取一个一个字符，当文件没有内容时会返回-1
            //这里的read()方法会有异常需要进行处理
            while((a=fs.read())!=-1){
                System.out.println((char)a);
            }
        } catch (IOException e) {
            System.out.print(e.getMessage());
        } finally {
            //4.关闭资源
            try {
                //这里需要判断如果有FileInputStream时才需要关闭资源
                if(fs!=null){
                    fs.close();
                }
            } catch (IOException e) {
                System.out.println(e.getMessage());
            }
        }
    }
}

效果展示：

OutputStream类

字节输出流，往文件中写入的内容为字节。OutputStream是字节输出流的父类，它也是一个抽象类，FileOutputStream是它的实现类。

操作步骤：

第1步：创建写出的File类的对象
第2步：创建FileOutputStream输出流（如果文件不存在时会创建文件）
第3步：具体的写出的过程
      write(int b)：将指定的字节写到指定文件
      write(byte[] s)：将指定的字节写到指定文件
第4步：关闭资源

举个例子：

public class Test{
    public static void main(String[] args) {
        //1.创建文件对象
        File file = new File("b.txt");
        //2.创建FileOutStream对象
        FileOutputStream os = null;
        try {
            //创建OutputStream流对象--如果指定的文件不存在则创建。
            os = new FileOutputStream(file,true);
            //3.调用FileOutStream类中的方法完成输出操作
            String msg="你好 今天学习IO流";
            os.write(msg.getBytes());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //4.关闭流资源
            if (os != null) {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

效果展示:

当文件不存在的时候，会自动创建指定的文件。

Reader类

该类用于读取的内容为字符类型，它是所有字符输入流的父类，它比较适合读取文本内容，它常用的子类FileReader类

操作步骤：

第1步：创建读取的File类的对象
第2步：创建FileReader输入流
第3步：具体的读入的过程
      read()：一个一个进行读取，当没有字符时返回-1
第4步：关闭流资源，避免内存泄露

举个例子：

public class Test {
    public static void main(String[] args) {
        Reader reader=null;
        try{
            //创建一个输入字符流对象
            reader=new FileReader(new File("b.txt"));
            //调用Reader类中方法完成读取功能
            int c = -1;
            while ((c=reader.read())!=-1){
                System.out.print((char)c);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //关闭资源
            if(reader!=null){
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

效果展示：

Writer类

该类用于读取的内容为字符类型，它是所有字符输出流的父类，它比较适合读取文本内容，它常用的子类FileWriter类

操作步骤：

第1步：创建写出的File类的对象
第2步：创建FileWriter输出流
第3步：具体的写出的过程
　　　 write(int b)：将指定的字节写到指定文件
　　　 write(byte[] s)：将指定的字节写到指定文件
第4步：关闭流资源，避免内存泄露

举个例子：

public class Test {
    public static void main(String[] args) {
        Writer writer = null;
        try {
            //1.创建一个字符输出流对象--
            writer=new FileWriter(new File("c.txt"));
            //2.调用里面的输出方法
            String msg="今天是个好日志，心想的事儿都能成.";
            writer.write(msg);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (writer != null) {
                try {
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

效果展示：

为什么说字节流更适合操作图片，音频，视频操作，而字符流更适合操作文件呢

>对于字符流只能用来操作文本文件，不能用来处理非文本

>对于字节流，通常用来处理非文本的，因为当处理文本时如果里面内容存在中文会出现乱码，所以更适合操作图片，音频，视频操作。

说明：

文本文件：.txt、.java、.c、.cpp、.py等

非文本文件：.doc、.xls、.jpg、.pdf、.mp3、.avi等

缓冲流

BufferedInputStream-----缓冲字节输入流

BufferedOutputStream-----缓冲字节输出流

BufferedReader----------缓冲字符输入流

BufferedWriter------------缓冲字符输出流

BufferedInputStream类

缓冲字节输入流，用于FileInputStream输入流

操作步骤：

第1步：创建读取的File类对象
第2步：创建FileInputStream输入流
第3步：创建BufferedInputStream缓冲字节输入流
第4步：具体的读取的过程
          read()：一个一个进行读取，如果后面没有内容返回-1
          readLine()：整行读取，但是不换行
第5步：关闭缓冲流资源，避免内存泄露

举个例子：

public class Test {
    public static void main(String[] args) {
        BufferedInputStream bis= null;
        try {
            //创建一个FileInputStream对象
            InputStream is=new FileInputStream(new File("a.txt"));
            //创建一个BufferedInputStream对象
            bis = new BufferedInputStream(is);
            //调用BufferedInputStream的方法
            int c;
            while((c=bis.read())!=-1){
                System.out.print((char)c);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭缓冲流资源
            if(bis!=null){
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

效果展示：

BufferedOutputStream类

缓冲字节输出流，用于FileOutputStream输出流

操作步骤：

第1步：创建写出的File类对象
第2步：创建FileOutputStream输出流对象
第3步：创建BufferedOutputStream缓冲字节输出流
第4步：具体的写出的过程
      write(byte[] b)：将指定的字节写到指定文件
      write(int b)：将指定的字节写到指定文件
第5步：关闭流资源，避免内存泄露

举个例子：

public class Test {
    public static void main(String[] args) {
        BufferedOutputStream bis= null;
        try {
            //创建FileIn
            FileOutputStream is=new FileOutputStream(new File("a.txt"));

            //创建一个BufferedOutputStream对象
            bis = new BufferedOutputStream(is);
            //调用BufferedOutputStream的方法
            byte[] arr={12,97,20,34};
            bis.write(arr);
            
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(bis!=null){
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

效果展示：

 BufferedReader类

缓冲字节输入流，用于FileReader输入流

操作步骤：

第1步：创建读入的File类的对象
第2步：创建FileReader输入流对象
第3步：创建BufferedReader缓冲输入流对象
第4步：具体的读入的过程
      int     read()：一个一个字符读取，直到没有字符返回-1
　    String  readLine()：一行一行字符读取，不换行，直到没有字符返回null
第5步：关闭缓冲流，避免内存泄露

举个例子：

public class Test {
    public static void main(String[] args) {
        FileReader fr = null;
        BufferedReader br = null;
        try {
            fr = new FileReader(new File("c.txt"));
            br = new BufferedReader(fr);
            String ch;
            while ((ch = br.readLine()) != null) {
                System.out.println(ch);

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

                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

效果展示：

BufferedWriter类

缓冲字节输出流，用于FileReader输出流

操作步骤：

第1步：创建读入的File类的对象
第2步：创建FileWriter输入流对象
第3步：创建BufferedWriter缓冲输入流对象
第4步：具体的读入的过程
      void   write(String c)：写入一个字符串
　    void   newLine()：写一行分隔符
第5步：关闭缓冲流，避免内存泄露

举个例子：

public class Test {
    public static void main(String[] args) {
        FileWriter fw = null;
        BufferedWriter bw = null;
        try {
            fw = new FileWriter(new File("b.txt"));
            bw = new BufferedWriter(fw);
            String str = "今天天气真好！";
            bw.write(str);
            bw.newLine();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (bw != null) {

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

                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

效果展示：

对象流

对象流概述

对象流用于操作java对象，可以把java对象从内存保存到文件中，也可以把文件中对象读取到内存中。

序列化：通过对象流把内存中的对象保存磁盘 | 网络上这个过程-------------------称为序列化

反序列化：通过对象流把磁盘 | 网络上的对象转化为内存中的对象这个过程---------------称为反序列化

处理流分为两种：

第一种：ObjectInputStream： 对象输入流

第二种：ObjectOutputStream: 对象输出流

对象输出流

通过对象流把内存中的对象保存磁盘 | 网络上这个过程

操作步骤：

第1步：创建对象
第2步：创建存放磁盘的位置
第3步：将对象存储到文件中
      writeObject(对象)：将对象存放到磁盘中
第4步：关闭对象流资源

举个例子：

public class Test {
    public static void main(String[] args) {
        FileOutputStream fs= null;
        ObjectOutputStream ois= null;
        try {
            //1.创建对象
            Student s1=new Student("张三",13);
            //2.存放在磁盘中的位置
            File file=new File("a.txt");
            fs = new FileOutputStream(file);
            ois = new ObjectOutputStream(fs);
            //3.将对象存储到文件中
            ois.writeObject(s1);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(ois!=null){
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fs!=null){
                try {
                    fs.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

效果展示：

发现会报错，这是因为对象没有实现序列化Serializable接口，所以会出现异常。

解决方法：（只需要在类上实现Serializable接口即可）

class Student implements  Serializable{
    private String name;
    private  int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
}

效果展示：

在文件中加载成功，注意这不是给你看的是给计算机看的。

对象输入流

通过对象流把磁盘 | 网络上的对象转化为内存中的对象这个过程-

操作步骤：

第1步：创建之前存放对象的文件
第2步：创建对象输入流
第3步：使用对象输入流获取对象
      readObject()：获取对象
第4步：关闭流资源

举个例子：

public class Test {
    public static void main(String[] args) {

        ObjectInputStream ois= null;
        try {
            //1.创建之前存放对象的文件
            File file=new File("a.txt");
            //2.创建对象输入流
            ois = new ObjectInputStream(new FileInputStream(file));
            //3.由于反序列化时不知道文件中的对象是什么类型
            //所以我们可以使用向下转型的方式
            Student student =(Student)ois.readObject();
            System.out.println(student);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            //4.关闭流资源
            if(ois!=null){

                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

效果展示: