理解java中IO流

一、IO中常用的类

  1. File：用于文件或者目录的描述信息，例如生成新目录，修改文件名，删除文件，判断文件所在路径等。

  2. InputStream：抽象类，基于字节的输入操作，是所有输入流的父类。定义了所有输入流都具有的共同特征。

  3. OutputStream：抽象类。基于字节的输出操作。是所有输出流的父类。定义了所有输出流都具有的共同特征。

  4.Reader：抽象类，基于字符的输入操作。

  5. Writer：抽象类，基于字符的输出操作。

 

二、字符流

简介：

字符流只用来处理文本数据，字节流用来处理媒体数据。

数据最常见的表现方式是文件，字符流用于操作文件的子类一般是FileReader和FileWriter。

字符流读写：

在文本中写入：

    public static void main(String[] args) throws IOException {             //需要对IO异常进行处理   
  
        //创建一个FileWriter对象，该对象一被初始化就必须要明确被操作的文件。  
        //而且该文件会被创建到指定目录下。如果该目录有同名文件，那么该文件将被覆盖。  
  
        FileWriter fw = new FileWriter("D:\\test.txt");//明确数据要存放的目的地 
  
        //调用write的方法将字符串写到流中  
        fw.write("hello world!");  
      
        //刷新流对象缓冲中的数据，将数据刷到目的地中  
        fw.flush();  
  
        //关闭流资源，但是关闭之前会刷新一次内部缓冲中的数据。当我们结束输入时候，必须close();  
        fw.write("first_test");  
        fw.close();  
        //flush和close的区别：flush刷新后可以继续输入，close刷新后不能继续输入。  
  
    } 

读取文本：

    private static void characters() {  
  
        try {  
  
            FileReader fr = new FileReader("Demo.txt");  
            char []  buf = new char[6];   
            //将Denmo中的文件读取到buf数组中。  
            int num = 0;      
            while((num = fr.read(buf))!=-1) {  
  
                System.out.print(buf);
            }  
           
            fr.close();  
        }  
        catch (IOException e) {  
             System.out.print(e.toString);
        }  
    }  

注意：

写入文件后必须要用flush()刷新。

用完流后记得要关闭流

使用流对象要抛出IO异常

三、字符流的缓冲区

字符流的缓冲区：BufferedReader和BufferedWreiter

缓冲区的出现时为了提高流的操作效率而出现的.

需要被提高效率的流作为参数传递给缓冲区的构造函数

在缓冲区中封装了一个数组，存入数据后一次取出

BufferedReader：

public static void main(String[] args)  throws IOException {  
  
        //创建一个字符读取流流对象，和文件关联  
        FileReader rw = new FileReader("buf.txt");  
  
        //只要将需要被提高效率的流作为参数传递给缓冲区的构造函数即可  
        BufferedReader brw = new BufferedReader(rw);  
  
          
        for(;;) {  
            String s = brw.readLine();  
            if(s==null) break;  
            System.out.println(s);  
        }  
          
        brw.close();//关闭输入流对象  
  
    }  

BufferedWreiter：

public static void main(String[] args)  throws IOException {  
  
        //创建一个字符写入流对象  
        FileWriter fw = new FileWriter("buf.txt");  
  
        //为了提高字符写入效率，加入了缓冲技术。  
        //只要将需要被提高效率的流作为参数传递给缓冲区的构造函数即可  
        BufferedWriter bfw = new BufferedWriter(fw);  
  
        //用到缓冲区就必须要刷新  
        for(int x = 1; x < 5; x++) {  
            bfw.write("abc");  
            bfw.newLine(); //java提供了一个跨平台的换行符newLine();  
            bfw.flush();  
        }  
  
  
  
        bfw.flush();    //刷新缓冲区  
        bfw.close();    //关闭缓冲区，但是必须要先刷新  
  
        //注意，关闭缓冲区就是在关闭缓冲中的流对象  
        fw.close();    //关闭输入流对象  
  
    }  

 

四、字节流

字节流和字符流的基本操作是相同的，但是要想操作媒体流就需要用到字节流。

字节流因为操作的是字节，所以可以用来操作媒体文件。（媒体文件也是以字节存储的）

读写字节流：InputStream   输入流（读）和OutputStream  输出流（写）

字节流操作可以不用刷新流操作。

public static void copyBmp() {  
  
        FileInputStream fis = null;  
        FileOutputStream fos = null;  
        try {  
            fis = new FileInputStream("D:\\test1.bmp");  //写入流关联文件  
            fos = new FileOutputStream("D:\\test2.bmp"); //读取流关联文件  
            byte[] copy = new byte[1024];  
            int len = 0;  
            while((len=fis.read(copy))!=-1) {  
            fos.write(copy,0,len);  
            }  
        }  
        catch (IOException e) {  
            e.printStackTrace();  
            throw new RuntimeException("复制文件异常");  
        }  
        finally {  
            try {  
                if(fis!=null) fis.close();  
            }  
            catch (IOException e) {  
                e.printStackTrace();  
                throw new RuntimeException("读取流");  
            }  
        }  
          
    }

[java] view plain copy

  
流操作的基本规律。  
一、两个明确：(明确体系)  
1. 明确源和目的  
    源：输入流  InputStream  Reader  
    目的：输出流  OutputStream Writer  
  
2. 操作的数据是否是纯文本  
    是： 字符流  
    否： 字节流  
二、明确体系后要明确具体使用的对象  
    通过设备区分：内存，硬盘，键盘  
    目的设备：内存，硬盘，控制台  
  
  
示例1：将一个文本文件中的数据存储到另一个文件中: 复制文件  
    一、明确体系  
        源：文件-->读取流-->(InputStream和Reader)  
        是否是文本：是-->Reader  
          
          
        目的：文件-->写入流-->(OutputStream Writer)  
        是否纯文本：是-->Writer  
      
    二、 明确设备  
        源：Reader  
            设备：硬盘上一个文本文件 --> 子类对象为：FileReader  
                FileReader fr = new FileReader("Goods.txt");  
              
            是否提高效率：是-->加入Reader中的缓冲区：BufferedReader  
                BufferedReader bufr = new BufferedReader(fr);  
                  
        目的：Writer  
            设备：键盘上一个文本文件 --> 子类对象：FileWriter  
                FileWriter fw = new FileWriter("goods1.txt");  
            是否提高效率：是-->加入Writer的缓冲区：BufferedWriter  
                BufferedWriter bufw = new BufferedWriter(fw);  
              
              
              
示例2：将一个图片文件数据复制到另一个文件中：复制文件  
    一、明确体系  
        源：文件-->读取流-->(InputStream和Reader)  
        是否是文本：否-->InputStream  
          
          
        目的：文件-->写入流-->(OutputStream Writer)  
        是否纯文本：否-->OutputStream  
      
    二、 明确设备  
        源：InputStream  
            设备：硬盘上一个媒体文件 --> 子类对象为：FileInputStream  
                FileInputStream fis = new FileInputStream("Goods.txt");  
              
            是否提高效率：是-->加入InputStream中的缓冲区：BufferedInputStream  
                BufferedInputStream bufi = new BufferedInputStream(fis);  
                  
        目的：OutputStream  
            设备：键盘上一个媒体文件 --> 子类对象：FileOutputStream  
                FileOutputStream fos = new FileOutputStream("goods1.txt");  
            是否提高效率：是-->加入OutputStream的缓冲区：BufferedOutputStream  
                BufferedOutputStream bufo = new BufferedOutputStream(fw);  
  
示例3：将键盘录入的数据保存到一个文本文件中  
    一、明确体系  
        源：键盘-->读取流-->(InputStream和Reader)  
        是否是文本：是-->Reader  
          
          
        目的：文件-->写入流-->(OutputStream Writer)  
        是否纯文本：是-->Writer  
      
    二、 明确设备  
        源：InputStream  
            设备：键盘 --> 对用对象为：System.in --> InputStream  
                为了操作方便，转成字符流Reader --> 使用Reader中的转换流：InputStreamReader  
                InputStreamReader isr = new InputStreamReader(System.in);  
              
            是否提高效率：是-->加入Reader中的缓冲区：BufferedReader  
                BufferedReader bufr = new BufferedReader(isr);  
                  
        目的：Writer  
            设备：键盘上一个文本文件 --> 子类对象：FileWriter  
                FileWriter fw = new FileWriter("goods1.txt");  
            是否提高效率：是-->加入Writer的缓冲区：BufferedWriter  
                BufferedWriter bufw = new BufferedWriter(fw);