I/O流概述与分类

目录

IO流概述

流与源数据源的程序之间的关系

IO流分类

字节流读写数据

字节缓冲流

字符流读写数据

---

IO流概述

• IO：输入/输出（Input/Output）
• 流：是一种抽象概念，是对数据传输的总称，也就是说数据在设备间的传输称为流，流的本质是数据传输
• IO流就是用来处理设备间的数据传输问题的                                                                                               常见的应用：文件复制；文件上传；文件下载

  ---

流与源数据源的程序之间的关系

IO流分类

• 按照数据的流向来分：① 输入流：读数据 ②输出流：写数据

• 按照数据类型来分①字节流 ：字节输入流；字节输出流 ②字符流 ：字符输入流；字符输出流                                                                                                                  

一般来说，所说的IO流的分类是按照数据类型来分的。 

字节流读写数据

字节流抽象基类

• InputStream：这个抽象类是表示字节输入流的所有类的超类
• OutputStream：这个抽象类是表示字节输出流的所有类的超类
• 子类名特点：子类名称都是以其父类名作为子类名的后缀

---

 FileInputStream：从文件系统中的文件获取输入字节

• FileInputStream（String name）：通过打开与实际文件的连接来创建一个FileInputStream，改文件由文件系统中的路径名name命名

InputStream类的常用方法 

方法	说明
int read（int b）	从输入流中读取下一个字节数据
int read（byte[] b）	从输入流中读取数据，并将数据存储在缓冲区数组b中，返回实际读取的字节数
int read（byte[] b,int off,int len）	从输出流中读取最长len长度的字节，保存到字节数组b中，保存的位置从off开始
void close（）	关闭输入流

•  InputStream类常用的子类有FileInputStream，用于从文件中读取数据

        //把fos.txt中的内容读取出来在控制台输出
        /**
         * fos.txt  “ab”
         * */
        //创建输入流对象
        //FileInputStream（String name）
        FileInputStream fileInputStream = new FileInputStream("fos.txt");

        /**
        //调用字节输入流对象的读取数据方法
        //int read（）：从该输入流读取一个字节的数据
        //第一次读取数据
        int by = fileInputStream.read();
        System.out.println(by);//97
        System.out.println((char)by);//a

        //第一次读取数据
        by = fileInputStream.read();
        System.out.println(by);//98
        System.out.println((char)by);//b
        //第三次读取数据
        by = fileInputStream.read();
        System.out.println(by);//-1  如果读取数据没有的话则会返回-1
        */

        /**
         * 循环改进
         * */
        int by;
        /**
         * fileInputStream.read():读取数据
         * by= fileInputStream.read():把读取到的数据赋值给by
         * by！=-1：判断读取到的数据是否为-1
         * */
        while ((by= fileInputStream.read())!=-1){
            System.out.print((char) by);//ab
        }
        
        //释放资源
        fileInputStream.close();

        字节流读数据数组的方法

        //创建字节输入流对象
        FileInputStream fileInputStream = new FileInputStream("fos.txt");
        //调用字节输入流对象的读数据方法
        //int read（byte[] b）	从输入流中读取数据，并将数据存储在缓冲区数组b中，返回实际读取的字节数
      
         byte[] bys = new byte[5];
         //第一次读取数据
         int len = fileInputStream.read(bys);
         System.out.println(len);//5
         //String (byte[] bytes)
         System.out.println(new String(bys,0,len));//abcde
         //第二次读取数据
         len = fileInputStream.read(bys);
         System.out.println(len);//5
         //String (byte[] bytes)
         System.out.println(new String(bys,0,len));//abc
         //int read（byte[] b,int off,int len）	从输出流中读取最长len长度的字节，保存到字节数组b中，保存的位置从off开始
         //第二次读取数据
         len = fileInputStream.read(bys);
         System.out.println(len);//2
         //String (byte[] bytes)
         System.out.println(new String(bys,0,len));//de
       
         * abcde\r\n
         * abcde\r\n
         * 第一次：abcde
         * 第二次：\r\nabc
         * 因为每一个abcde后面都有一个换行的\r\n所以第二次输出的时候会先输出\r\n
       


        /**
         * 利用循环改进
         * */

        byte[] bys = new byte[1024];//1024及其整数倍
        int len;
        while ((len = fileInputStream.read(bys)) != -1) {
            System.out.println(new String(bys, 0, len));
        }
        //释放资源
        fileInputStream.close();

---

FileOutputStream:文件输出流用于将数据写入File

• FileOutputStream（String name）：创建文件输出流以指定的名称写入文件

OutputStream类的常用方法

方法	说明
void write(int c)	将指定的字节写入此文件输出流，一次写一个字节数据
void write (byte[] buf)	将b.length字节从指定的字节数组写入此文件输出流，一次写一个字节数组数据
void write（byte[] b,int off,int len）	将len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流，一次写一个字节数组的部分数据
void close（）	关闭输出流

•  OutputStream类常用的子类有FileOutputStream，用于从文件中读取数据

         //创建字节输出流对象
        //FileOutputStream(String name),创建文件输出流以指定的名称写入文件
        FileOutputStream fileOutputStream = new FileOutputStream("fos.txt");


        //void write（int b）
        //将指定的字节写入此文件输出流，一次写一个字节数据
        fileOutputStream.write(97);//a
        fileOutputStream.write(57);//9
        fileOutputStream.write(55);//7

        //void write（byte[] b）
        //将b.length字节从指定的字节数组写入此文件输出流，一次写一个字节数组数据
        byte[] bys = {97,98,99,100,101};
        fileOutputStream.write(bys);//abcde
        
         //void write（byte[] b,int off,int len）
        //将len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流，一次写一个字节数组的部分数据
        byte[] bys = {97,98,99,100,101};
        fileOutputStream.write(bys,0, bys.length);//abcde
        fileOutputStream.write(bys,2, bys.length-3);//cd

       
        for (int i = 0; i < 10; i++) {
        fileOutputStream.write("hello".getBytes());
        //换行
        fileOutputStream.write("\r\n".getBytes());
        }

        //追加写入  true
        FileOutputStream fileOutputStream = new FileOutputStream("fos.txt"，true);

        //IO操作相关的内容最后都要释放资源
        //void close(): 关闭此文件输出流并释放与此流相关联的任何系统资源
        fileOutputStream.close();

Tip1 ：

创建字节输出流对象做了三件事
1.调用系统功能创建了文件
2.创建了字节输出流对象
3.让字节输出流对象指向创建好的文件

所有与IO操作相关的内容最后都要释放资源

不同操作系统的换行是不同的
window：\r\n
liunx:\n
mac:\r 

练习：把根目录下的fos.txt复制到根目录下的fos2.txt文件下

       //根据数据源创建字节输入流对象
        FileInputStream fis = new FileInputStream("fos.txt");
        //根据目的地创建字节输出流对象
        FileOutputStream fos = new FileOutputStream("fos2.txt");
        
        //读写数据：复制文本文件（一次读取一个字节，一次写入一个字节）
        int by;
        while ((by = fis.read())!=-1){
            fos.write(by);
        }

        /**
        //复制图片,把上面的地址改为图片地址则可
        byte[] bys = new byte[1024];
        int len;
        while ((len = fileInputStream.read(bys)) != -1) {
            System.out.println(new String(bys, 0, len));
        }
        */
        //释放资源
        fis.close();
        fos.close();

结果： 

字节缓冲流

   
        //字节缓冲输出流，BufferedOutputStream（OutputStream out）
        //FileOutputStream fos = new FileOutputStream("fos.txt");
        //BufferedOutputStream bos = new BufferedOutputStream(fos);
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("fos.txt"));
        //写数据
        bos.write("hello\r\n".getBytes());
        bos.write("world\r\n".getBytes());
        //释放资源
        bos.close();
        
        //字节缓冲输入流，BufferedInputStream（InputStream out）
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("fos.txt"));
        //一次读取一个字节数据
        int by;
        while ((by = bis.read())!=-1){
            System.out.print((char)by);
        }
        
        //循环
        //一次读取一个字节数组数据
        byte[] bys = new byte[1024];
        int len;
        while ((len = bis.read(bys))!=-1){
            System.out.println(new String(bys,0,len));
        }
        bis.close();


输出：
hello
world

---

字符流读写数据

 Reader类的常用方法

方法	说明
int read（）	从输入流中读取单个字符，返回所读取的字符数据
int read（byte[] c）	从输入流中最多读取c.length个字符，保存到字符数组c中，返回实际读取的字符串
int read（char[] b,int off,int len）	从输入流中读取最多len个字符，保存到字符数组c中，保存的位置从off位置开始，返回实际读取的字符数
void close（）	关闭输入流

• Reader类的常用子类为BufferedReader,接受Reader对象作为参数，并对其添加字符缓冲器

          //InputStreamReader(IntStream in):创建一个使用默认字符集的InputStreamReader
        InputStreamReader isr = new InputStreamReader(new FileInputStream("fos.txt"));

        //int read（）：一次读一个字符数据
        int ch;
        while ((ch=isr.read())!=-1){
            System.out.print((char)ch);//abcde
        }

        //int read (char[] cbuf):一次读一个字符数组数据
        char[] chs = new char[1024];
        int len;
        while ((len = isr.read(chs))!=-1){
            System.out.println(new String(chs,0,len));//abcde
        }

        //释放资源
        
            isr.close();
       

---

 Writer类的常用方法

方法	说明
void write(String str)	将str字符串里包含的字符输出到指定的输出流中
void write（String str,int off,int len）	将str字符串里从off位置开始，长度len的多个字符输出到输出流中
void close（）	关闭输出流，先刷新
void flush（）	刷新输出流

• Write类的常用子类为BufferedWriter,用于将数据缓冲到字符输出流

        //OutputStreamWriter(OutputStream out)创建一个使用默认字符编码OutputStreamWriter
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("fos.txt"));

       
         //void write（int c）:写一个字符
         osw.write(97);//a
         //void flush():刷新流
         osw.flush();
         osw.write(98);//b
         osw.flush();
         osw.write(99);//c
      

        //void write(char[] cbuf):写入一个字符数组
        char[] chs ={'a','b','c','d','e'};
        //void write(char[] cbuf,int off,int len):写入字符数组的一部分
        osw.write(chs,0,chs.length);//abcde
        osw.write(chs,1,3);//bcd

        //void write(String str):写入一个字符串
        osw.write("abcde");//abcde
        
        //void write(String str,int off,int len):写入字符串的一部分
        osw.write("abcde",0,"abcde".length());//abcde
        osw.write("abcde",1,3);//bcd
        //释放资源
        osw.close();

Tip2 ：

        字节流和字符流读数据格式都是一样的，只不过一个字节一个是字符而已。

Tip3 ：

①在操作上字节流与字符流有一个区别，字符流在操作时使用缓冲区（内部存储器），而字      节流在操作时直接操作文件，不会使用缓冲区。

②所有的这些方法在出现错误时都会抛出IOException异常。

解决办法：可以直接添加异常到方法签名，也可以使用try / catch环绕