黑马程序员JAVA基础IO流之字符流和字符流缓冲区

　　Java 的IO 流 是实现输入和输出的基础，Java 中把不同的输入、输出源抽象表述为“流” （Streem）。按照不同的分类方式，可以将流分为不同的类型：输入流和输出流、字节流和字符流、字点流和处理流。

　　

一.字符流

　　1.1 字符流基类：

　　Writer 和 Reader 抽象类，通过这两个抽象类提供的方法可以对文件进行操作。

　　Writer 中包含的方法：

　　> void write(String str) : 将str 字符串中包含的字符输出到指定输出流。

　　> void write(String str, int off, int len) : 写入字符串的某一部分。

　　> void write(char[] cbuf)   : 写入字符数组。

　　> abstract  void write(char[] cbuf, int off, int len) : 写入字符数组的某一部分 。

　　> abstract  void flush()  刷新该流的缓冲。

　　> abstract  void close() :关闭此流，但要先刷新它。 

　　练习：在硬盘上，创建一个文件并写入一些文字数据:

import java.io.*;
public class FileWriterDemo {
    public static void main(String[] args) throws IOException{
//        创建一个FileWriter 对象。该对象一被初始化就必须要明确被操作的文件。
//        而且该文件会被创建到指定的目录下。如果该目录下已有同名文件，将被覆盖。
//        其实该步就是明确数据的存放的目的地
        FileWriter fw = new FileWriter("D:\\HelloWorld.txt"); 
        
//        调用父类 Writer 的 wirter 方法 
//        将字符串写到内存中。
        fw.write("HelloWrold!") ;
        
//        刷新流对象中的缓冲中的数据。
//        将数据存到目的文件。
        fw.flush() ;
//        关闭流资源，但是关闭之前会刷新一次内部缓冲中的数据。
//        将数据刷到目的文件中。
        fw.close(); 
    }
}

　　Reader 中包含的方法：

　　> int read()  读取单个字符。 

　　> int read(char[] cbuf) 将字符读入数组。

　　> abstract  int read(char[] cbuf, int off, int len) 将字符读入数组的某一部分。

public class ReadDemo1 {
    public static void main(String[] args) throws IOException {
//        创建一个文件读取流对象，和指定的文件相关联。
//        要保证文件存在，否则会出现 FileNotFoundException ；
        FileReader fr = new FileReader("D:\\HelloWorld.txt") ;
        
//        调用读取流对象read方法。
//        read():一次只读一个字符，而且会自动往下读。
        int n1  = fr.read() ;
        System.out.println((char) n1);
        
        int n2  = fr.read() ;
        System.out.println((char) n2);
        
//        定义一个字符数组。用于存储字符。
//        read(char[] ch) 返回的是读取的字符个数。
        char[] ch = new char[3] ; 
        int num = fr.read(ch) ;
        System.out.println(num+"...."+ new String(ch));  
    }
}

 　　上面代码演示了FileReader 的两种读取方法。 

　　> read():一次只读一个字符，而且会自动往下读。

　　通过学习，在处理IO流是都要抛出IOException 异常。为了使得代码更安全，在处理IO异常要有必要的手段。

import java.io.*; 
public class IOExceptionTest {
    public static void main(String[] args){
        
//        在外面建立引用，在try 中进行初始化：不然引用在finally不存在。
        FileWriter fw = null ; 
        try{ 
            fw = new FileWriter("HelloWorld") ;
            fw.write("hello world") ; 
            fw.flush() ;
        }
        catch(IOException e) {
            e.printStackTrace();
        }
        finally {
            try{
//                如果有多个引用，则要分开try。
                if(fw != null)
                    fw.close() ;
            }
            catch(IOException e){
                e.printStackTrace() ;
            }
        }
    }
}

　　上面的代码是IO处理异常方式。

　　练习：读取一个.Java 文件，并在控制台上打印。

import java.io.*; 
public class ReadDemo2 {
    public static void main(String[] args) {
//        创建读取流对象：
        FileReader fr = null ;
        try {
            fr = new FileReader("D:\\workspace\\heima\\src\\io\\ReadDemo1.java") ;
//            创建一个存储字符
            char[] ch = new char[1024] ;
            int num  ;
            while((num = fr.read(ch)) != -1)
            {
                System.out.println(new String(ch,0,num));
            }
        }catch(IOException e) {
            e.printStackTrace() ;
        }finally{
            try{
                if (fr != null )
                    fr.close() ;
            }catch(IOException e) {
                e.printStackTrace() ;
            } 
        }
    }
}

 　 创建存储字符数组时，大小最好是1024的整数倍（为什么？）

　　练习： 将一个文件复制到另一个地方。 

　　复制的原理：
　　其实就是将文件数据存储到另一个文件中。
　　步骤：
　　1、在目标地点创建一个文件，用于存储被复制的数据。
　　2、定义读取流和被复制文件关联。
　　3、通过不断的读写完成数据存储。
　　4、关闭资源。

public class ReadDemo3 {
    public static void main(String[] args) {
        CopyMethod("D:\\ReadDemo2.txt" , "D:\\workspace\\heima\\src\\io" +
                "\\IOExceptionTest.java") ;
    }
    
    public static void CopyMethod(String w , String r) {
//        创建Writer 流对象和Reader 流对象。
        FileReader fr = null ; 
        FileWriter fw = null ;
        try { 
//            在D盘下创建一个文件，用于存储被复制的数据。
            fw = new FileWriter(w) ;
//            读取要被复制的文件。
            fr = new FileReader(r) ; 
            
//            创建字符数组：存储读取文件数据。
            char[] ch = new char[1024] ;
            int num = 0  ;
//            往目标文件写入数据。
            while ((num = fr.read(ch))!=-1) {
                fw.write(ch, 0, num) ;
                fw.flush() ;
            } 
        }catch(IOException e){
            System.out.println(e.toString());
        }finally {
//            分开try.
            if (fw != null)
                try { 
                     fw.close() ;  
                }catch(IOException e) {
                    System.out.println(e.toString());
                }
            if (fr != null)
                try{
                        fr.close() ;
                }catch(IOException e) {
                    System.out.println(e.toString());
                }
            }
    } 
}

　　

 　1.2 字符流缓冲区：

　　从内部结构上来看，Buffer 就像一个数组，它可以保存多个类型相同的数据。例如：如果将IO流比作水管滴水，那么使用字符缓冲区，便像用杯子先将水滴存储起来。

　　特点：

　　1、缓冲区的出现提高了对数据读写的效率。

　　2、缓冲区要结合流才可以使用。

　　3、在流的基础上对流的功能的进行增强。

 　　字符流缓冲区对应类：BufferedReader 和 BufferedWriter 。 

public class BufferedWriterDemo {
    public static void main(String[] args){
//        创建一个字符写入流引用。
        FileWriter fw = null ;
//        为了提高字符写入流效率，加入缓冲技术；
        BufferedWriter bufw = null ; 
        try{
            fw = new FileWriter("D:\\HelloWorld1.txt") ;
//            只要将需要被提高效率的流对象最为参数传递给缓冲区的构造函数即可。
            bufw = new BufferedWriter(fw) ; 
            bufw.write("afwefw ") ;
            bufw.flush() ;
        }catch(IOException e){
            e.printStackTrace();
        }finally{
            if(bufw != null)
                try{
//                    只需要关闭缓冲区 便可。
                    bufw.close() ;
                }catch(IOException e){}
        }
    }
}

　　 缓冲区的基本操作如上。

　　对于字符流读取缓冲区，该缓冲区提供了一个一次读一行的方法readLine , 方便于对文本数据的获取，当返回null 时，表示读到文件末尾。

　　注意：readLine 方法返回的是回车符之间的字符，不包括回车符。

　　> String readLine() : 读取一个文行。 

import java.io.*;
public class BufferedReaderDemo {
    public static void main(String[] args){
//        创建一个读取流对象和文件相关联
        FileReader fr = null ; 
//        加入缓冲技术：
        BufferedReader bufr = null ; 
        try {
            fr = new FileReader("D:\\ReadDemo2.txt") ;
            bufr = new BufferedReader(fr) ; 
            
            String line = null ;
//            一次读取一行
            while ((line = bufr.readLine())!= null){
                System.out.println(line);
            }
        }catch(IOException e){
            e.printStackTrace() ; 
        }finally{
            if(bufr != null)
                try{
                    bufr.close() ; 
                }catch(IOException e){
                    e.printStackTrace() ;
                }
        }
    }
}

　　练习：使用字符流缓冲区技术，复制一个文本。 

public class BufferedReaderDemo2 {
    public static void main(String[] args){
        BufferedReader bufr = null ;
        BufferedWriter bufw = null ; 
        try {
//            使用缓冲区
            bufr = new BufferedReader(new FileReader("D:\\ReadDemo2.txt")) ; 
            bufw = new BufferedWriter(new FileWriter("D:\\BufferedReader.txt")) ;
            
//            读写文件。
            String line = null ; 
            while ((line = bufr.readLine()) != null){
                bufw.write(line) ;
//                由于不包括换行符，所以写入数据时要另开一行
                bufw.newLine() ;
                bufw.flush() ;
            }
        }catch(IOException e){
            e.printStackTrace() ;
        }finally{
            if(bufr != null)
                try{
                    bufr.close() ;
                }catch(IOException e) {
                    e.printStackTrace() ; 
                }
            if(bufw != null) 
                try{
                    bufw.close() ;
                }catch(IOException e) {
                    e.printStackTrace() ; 
                }
        }
    }
}