Java文件处理之IO流

1、概述

  流：表明任何有能力产出数据的数据源对象或者是有能力接受数据的接收端对象 ；其做用是为数据源和目的地创建一个输送通道。

  IO流：是程序中一套用于数据传输的机制。IO流是Input流和Output流的简称。流的输入输出是以程序为参照物。

一、输入流

   数据从外部流向程序。例如读取文件，就是从外部流入程序。

二、输出流

   数据从程序流向外部。例如将程序中的数据写入到文件中。

2、输入输出流的分类

 一、根据方向可分为：输入流和输出流

 二、根据形式：分为字符流（字符类型文件：txt、java、html等）和字节流（图片、视频、音频等）。

三、四大基本流都是抽象类，都不能直接建立对象。

四、数据的来源/目的地：磁盘、网络、内存和外部设备。

 3、文件字符流

 一、从文件中读取数据：FileReader类

  FileReader类时Reader的一个实现子类。FileReader对象中经常使用的是read方法，返回读取的字符串个数。

    不传入数组，源码中会自动建立一个长度为1的数组，将读取值放入到数组中，返回读取到的字符值；传入数组，底层会将读取到的字符放入到对应数组中，并返回读取到的字符个数。

   示例以下：

 //1.每次读取一个字符
        //建立了一个输入流对象指向D盘下的a.txt
        //文件字符输入流没有缓冲区
        FileReader reader = new FileReader("D:\\a.txt");
        
        //读取数据
        //每次只读取一个字符，因此返回值也就是表示读取到的这个字符
        // int i1 = reader.read();
        // System.out.println(i1);
        //定义一个变量记录每次读取的字符
        int i;    
        //读取到末尾会返回 -1
        //这种写法是错误的，表示读一个跳一个
        // while((i = reader.read()) != -1) {
        // System.out.println(reader.read());
        // }
        //
        while((i = reader.read()) != -1) {
            System.out.println(i);
        }            
        //关流
        reader.close();

       //2.每次读取多个字符
       FileReader reader = new FileReader("D:\\a.txt");
        
        //定义一个字符数组做为缓冲区
        char[] cs = new char[5];
        
        //将数据读取到缓冲区
        // reader.read(cs);
        // System.out.println(new String(cs));
        
        //返回值表示本次读取到的字符个数
        //定义一个变量记录读取的个数;
        //文件中一共有11个字符
        //第一次读取的时候，读取到了5个字符，因此len的值为5
        //第二次读取的时候，读取到了5个字符，因此len的值为5
        //第三次读取的时候，读取到了1个字符，因此len的值为1
        //第四次读取的时候，读取到了文件末尾，因此len的值为-1
        
        int len;
        //将读取到的数据放到数组中，而返回值表示王数组中放的字符个数
        while((len = reader.read(cs)) != -1) {
            //String(value, offset, len)
            //从value数组的第offset为开始，将len个元素转为字符串
            System.out.println(new String(cs, 0 , len));
        }
        reader.close();

二、向txt文件中写入字符串 --FileWriter

  FileWriter类时Writer的一个实现子类。FileWriter对象中经常使用的是write方法，表示将数据写入到文件中。

  示例以下：

//建立一个新文件
        //若是原文件不存在，则操做建立的这个新文件
        //若是源文件已存在，则利用新文件覆盖源文件
        FileWriter writer = new FileWriter("D:\\a.txt");
        
        //写出数据
        //在写数据的时候，这个数据并不直接写到文件中而是先写到缓冲区中
        //当缓冲区写满了以后，再将缓冲区中的数据写入到文件中
        //在缓冲区没有写满的时候，程序就已经结束
        //结果致使数据死在了缓存区
        writer.write("detgagf");
        
        //冲刷缓冲区
        //将数据从缓冲区中冲到文件中
        writer.flush();
        
        
        //关闭流
        //为了释放文件以容许别的流来操做这个文件
        //流一旦关闭，就不能再次开启
        //close以前，流自动进行一次flush操做，以免有数据死在缓冲区
        writer.close();
        
        //清空引用将其标记为垃圾对象
        writer = null;

4、文件字节流

 一、文件字节输入流 FileInputStream

     FileInputStream类时InputStream的一个实现子类。FileInputStream对象中经常使用的是write方法，表示将数据写入到文件中。 文件字节流没有缓冲区，可定义字节数组做为缓冲区。示例以下

FileInputStream in = new FileInputStream("D:\\b.txt");
        
        //读取到的是字节
        
        //定义一个字节数组做为缓冲区
        byte[] bs = new byte[10];
        int len;
        while((len = in.read(bs)) != -1) {
            System.out.println(new String(bs, 0 , len));
        }
        in.close();

二、文件字节输出流 FileOutputStream

  FileOutputStream类时OutputStream的一个实现子类。FileOutputStream对象中经常使用的是write方法，表示将数据写入到文件中。能够定义一个字节数组做为缓冲区。

  示例以下：

FileOutputStream fs = new FileOutputStream("D:\\b.txt");
        
        //写出数据
        //字节输出流没有缓冲区
        fs.write("abc".getBytes());
        
        //关流
        fs.close();

5、缓冲流

    一、字符输入缓冲流  BufferedReader

    在构建的时候须要传入一个Reader对象。真正读取数据依靠的是传入的这个Reader对象，BufferedReader从Reader对象中获取数据提取到缓冲区。其本质是FileReader的一个包装类。省去了程序员人为为FileReader提供数组缓冲区的步骤。

   示例以下：

//真正读取文件的是FileReader
        //FileReader自己没有缓冲区
        FileReader reader = new FileReader("D:\\a.txt");
        
        //BufferedReader将FileReader读取的数据进行缓冲
        //BufferedReader提供缓冲区
         BufferedReader br = new BufferedReader(reader);
         
         //读取一行
        //String str = br.ReadLine();
        // System.out.println(str);
         
         //定义一个变量用来记录读取的每一行数据
         String str;
         //若是读取到末尾，返回的是null
         while((str = br.readLine()) != null) {
             System.out.println(str);
         }
         //关流  只关闭外层流就行
         br.close();

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

  提供了一个更大的缓冲区，其中提供了一个newLine()方法，用于进行换行操做，以屏蔽不一样操做系统的差别性。

示例以下：

//真正向文件中写数据的流是FileWirter
        //BufferedWriter提供了一个更大的缓冲区
        BufferedWriter writer = new BufferedWriter(new FileWriter("D:c.txt"));
        writer.write("sdsakj");
        //在Windows中，换行通常用\r\n
        //在linux中，换行只用\n
        
        //进行换行，屏蔽不一样操做系统的差别性
        writer.newLine();
        writer.write("4564561");
        
        writer.close();

6、流中的异常处理

  一、不管流操做成功与否，关流操做都得发生，因此须要将关流操做放到finally代码块中。

  二、为了让流对象在finally依然可以使用，因此须要将流对象放在try以外声明，而且要赋值为null，而后放在try以内进行实际的初始化过程。

  三、在关流以前要判断对象是否初始化成功，实际上就是判断流对象是否为null；

  四、由于关流有可能失败，此时流会依然占用文件，因此须要将流对象置为null，标记为垃圾对象进行强制回收以释放内存；

  五、若是流有缓冲区，那么为了防止关流失败致使没有进行自动冲刷，因此须要手动冲刷一次，以防止有数据死在缓冲区而产生数据丢失。

  流异常处理实例以下：

       //2.须要将流对象放在try以外声明而且赋值为null
        FileWriter writer = null;
        try {
            // 2.将流对象放在try以内进行初始化
            writer = new FileWriter("F:\\a.txt");
            
            writer.write("积分圣诞节");        
            
            //5.为了防止关流失败没有自动flush而致使数据产生丢失
            writer.flush();
            
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //3.在关流以前要判断对象是否初始化成功，实际上就是判断流对象是否为null
            if(writer != null) {
                try {
                    //1.不管写流成功仍是失败，都须要关流
                    writer.close();
                } catch (IOException e) {                
                    e.printStackTrace();
                } finally {
                    //4.若是关流失败，将该流标记为垃圾对象，强制回收
                    //若是关流成功，将该流标记为垃圾对象，释放内存
                    writer = null;
                }
            }                    
        }