黑马程序员——java基础知识之IO流（二）

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-
（一）缓冲区
缓冲区的出现是为了提高流的操作效率而出现的。

注意：
所以在创建缓冲区之前，必须要先有流对象。
该缓冲区中提供了一个跨平台的换行符。
newLine();

一、字符写入缓冲流
BufferedWriter

class  BufferedWriterDemo
{
    public static void main(String[] args) throws IOException
    {
        //创建一个字符写入流对象。
        FileWriter fw = new FileWriter("buf.txt");

        //为了提高字符写入流效率。加入了缓冲技术。
        //只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可。
        BufferedWriter bufw = new BufferedWriter(fw);
        for(int x=1; x<5; x++)
        {
            bufw.write("abcd"+x);
            bufw.newLine();
            bufw.flush();
        }

        //记住，只要用到缓冲区，就要记得刷新。
        //bufw.flush();

        //其实关闭缓冲区，就是在关闭缓冲区中的流对象。
        bufw.close();
    }
}

字符读取缓冲流：
BufferReader
注意：
该缓冲区提供了一个一次读一行的方法 readLine，方便于对文本数据的获取。当返回null时，表示读到文件末尾。
readLine方法返回的时候只返回回车符之前的数据内容。并不返回回车符。

class  BufferedReaderDemo
{
    public static void main(String[] args) throws IOException
    {
        //创建一个读取流对象和文件相关联。
        FileReader fr = new FileReader("buf.txt");

        //为了提高效率。加入缓冲技术。将字符读取流对象作为参数传递给缓冲对象的构造函数。
        BufferedReader bufr = new BufferedReader(fr);

//定义一个字符串来接受
        String line = null;

        while((line=bufr.readLine())!=null)
        {
            System.out.print(line);
        }


        bufr.close();
    }

}

BufferReader的子类：
LineNumberReader，它里面独特的功能是可以打印出行号，是通过里面的getLineNumber（）方法

写入和读出缓冲流综合利用例子：

/*
通过缓冲区复制一个.java文件。
*/
import java.io.*;

class  CopyTextByBuf
{
    public static void main(String[] args) 
    {//先定义缓冲流
        BufferedReader bufr = null;
        BufferedWriter bufw = null;

        try
        {//读的缓冲流
            bufr = new BufferedReader(new FileReader("BufferedWriterDemo.java"));
            //写的缓冲流
            bufw = new BufferedWriter(new FileWriter("bufWriter_Copy.txt"));

            String line = null;

            while((line=bufr.readLine())!=null)
            {
                bufw.write(line);
                //注意一定要加换行语句
                bufw.newLine();
                bufw.flush();

            }
        }
        //关闭流对象
        catch (IOException e)
        {
            throw new RuntimeException("读写失败");
        }
        finally
        {
            try
            {
                if(bufr!=null)
                    bufr.close();
            }
            catch (IOException e)
            {
                throw new RuntimeException("读取关闭失败");
            }
            try
            {
                if(bufw!=null)
                    bufw.close();
            }
            catch (IOException e)
            {
                throw new RuntimeException("写入关闭失败");
            }
        }
    }
}

Reader的readline方法的实现原理图：

readline的底层实现原理：
明白了BufferedReader类中特有方法readLine的原理后，
可以自定义一个类中包含一个功能和readLine一致的方法。
来模拟一下BufferedReader

private Reader r;
    MyBufferedReader(Reader r)
    {
        this.r = r;
    }

    //可以一次读一行数据的方法。
    public String myReadLine()throws IOException
    {
        //定义一个临时容器。原BufferReader封装的是字符数组。
        //为了演示方便。定义一个StringBuilder容器。因为最终还是要将数据变成字符串。
        StringBuilder sb = new StringBuilder();
        int ch = 0;
        //通过read方法实现readline（）方法
        while((ch=r.read())!=-1)
        {
            if(ch=='\r')
                continue;
            if(ch=='\n')
                return sb.toString();
            else
                sb.append((char)ch);
        }

        if(sb.length()!=0)
            return sb.toString();
        return null;        
    }

增加知识点：
装饰设计模式
当想要对已有的对象进行功能增强时，可以定义类，将已有对象传入，基于已有的功能，并提供加强功能，那么自定义的该类称为装饰类。
例子程序：

class Person
{
    public void chifan()
    {
        System.out.println("吃饭");
    }
}

class SuperPerson 
{
    private Person p ;
    SuperPerson(Person p)
    {
        this.p = p;
    }
    public void superChifan()
    {
        System.out.println("开胃酒");
        p.chifan();
        System.out.println("甜点");
        System.out.println("来一根");
    }
}

注意装饰类和继承的区别：
装饰类具有更好的灵活性，而且代码不会很臃肿。

（二）、字节流：
1、字节流的特点
由于媒体文件数据中都是以字节存储的，所以，字节流对象可直接对媒体文件的数据写入到文件中，而可以不用再进行刷流动作。
字节流和字符流的基本操作是相同的，但字节流还可以操作其他媒体文件。

为何不用进行刷流动作？
因为字节流操作的是字节，即数据的最小单位，不需要像字符流一样要进行转换为字节。所以可直接将字节数据写入到指定文件中。

2、字节流的读写
InputStream 输入流（读）
OutputStream 输出流（写）

3、注意
InputStream特有方法：
int available();//返回文件中的字节个数
注：可以利用此方法来指定读取方式中传入数组的长度，从而省去循环判断。但是如果文件较大，而虚拟机启动分配的默认内存一般为64M。当文件过大时，此数组长度所占内存空间就会溢出。所以，此方法慎用，当文件不大时，可以使用。

/*
复制一个图片
思路：
1，用字节读取流对象和图片关联。
2，用字节写入流对象创建一个图片文件。用于存储获取到的图片数据。
3，通过循环读写，完成数据的存储。
4，关闭资源。

*/

import java.io.*;
class  CopyPic
{
    public static void main(String[] args) 
    {//定义字节读入流和写出流
        FileOutputStream fos = null;
        FileInputStream fis = null;
        try
        {
        //定义写入的文件
            fos = new FileOutputStream("c:\\2.bmp");
            fis = new FileInputStream("c:\\1.bmp");
    //定义字节数组接收
            byte[] buf = new byte[1024];

            int len = 0;

            while((len=fis.read(buf))!=-1)
            {
                fos.write(buf,0,len);
            }
        }
        //通过关闭流
        catch (IOException e)
        {
            throw new RuntimeException("复制文件失败");
        }
        finally
        {
            try
            {
                if(fis!=null)
                    fis.close();
            }
            catch (IOException e)
            {
                throw new RuntimeException("读取关闭失败");
            }
            try
            {
                if(fos!=null)
                    fos.close();
            }
            catch (IOException e)
            {
                throw new RuntimeException("写入关闭失败");
            }
        }
    }
}

4、字节流缓冲区
BufferedOutputStream
BufferedInputStream
例子程序：

    public static void copy_1()throws IOException
    {
    //缓冲读入流
        BufferedInputStream bufis = new BufferedInputStream(new FileInputStream("c:\\0.mp3"));
        //缓冲写出流
        BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("c:\\1.mp3"));
    //注意因为缓冲里面有数组接收，外面不用定义数组接收  
        int by = 0;
        while((by=bufis.read())!=-1)
        {
            bufos.write(by);
        }

        bufos.close();
        bufis.close();


    }
}

注意自定义字节缓冲区：

       privateInputStream in;  
       privatebyte[] by=new byte[1024];  
       privateint count=0,pos=0;  
       MyBufferedInputStream(InputStreamin)  
       {  
              this.in=in;  
       }  


       //自定义读方法，一次读一个字节  
       publicint myRead()throws IOException  
       {  
              //通过in对象读取硬盘上数据，并存储by中。  
              //存储在数组中的数据被读取完，再通过in对象从硬盘上读取数据  
              if(count==0)  
              {  
                     count=in.read(by);  
                     //文件数据全部被读取出来了
                     if(count<0)  
                            return-1;  
                   //初始化指针  
                     pos=0;
                     byteb=by[pos];  
                      //每被读一个字节，表示数组中的字节数少一个 
                     count--;   
                          //指针加1              
//返回的byte类型提升为int类型，字节数增加，且高24位被补1，原字节数据改变。  
//通过与上255，主动将byte类型提升为int类型，将高24位补0，原字节数据不变。  
//而在输出字节流写入数据时，只写该int类型数据的最低8位。  
                     returnb&255;
              }  
              //如果数组中的数据没被读取完，则继续读取  
              elseif(count>0)
              {  
                     byteb=by[pos];  

                     count--;  
                     pos++;  
                     returnb&0xff;  
              }  
              return-1;  
       }  

       //自定义关闭资源方法  
       publicvoid close()throws IOException  
       {  
              in.close();  
       }  
}  

自定义字节缓冲区的总结：
1、字节流的读一个字节的read方法为什么返回值类型不是byte，而是int。
因为有可能会读到连续8个二进制1的情况，8个二进制1对应的十进制是-1.那么就会数据还没有读完，就结束的情况。因为我们判断读取结束是通过结尾标记-1来确定的。
所以，为了避免这种情况将读到的字节进行int类型的提升。并在保留原字节数据的情况前面了补了24个0，变成了int类型的数值。而在写入数据时，只写该int类型数据的最低8位。
2、byte类型的-1提升为int类型时还是-1。原因：因为在bit8个1前面补的全是1导致的。如果在bit8个1前面补0，即可以保留原字节数据不变，又可以避免-1的出现。这时将byte型数据&0xff即255即可。

字节流和字符流的总结：
字符流：
FileReader
FileWriter。

BufferedReader
BufferedWriter

字节流：
FileInputStream
FileOutputStream

BufferedInputStream
BufferedOutputStream

（三）、转换流
将字节流转换为字符流的格式：
InputStreamReader将字节流通向字符流
a、获取键盘录入对象。
InputStream in=System.in;
b、将字节流对象转成字符流对象，使用转换流。
InputStreamReaderisr=new InputStreamReader(in);
c、为了提高效率，将字符串进行缓冲区技术高效操作。使用BufferedReader
BufferedReaderbr=new BufferedReader(isr);
注意：键盘录入最常见写法
BufferedReaderin=new BufferedReader(new InputStreamReader(System.in));
接受键盘录入或输出：

例子程序：

//键盘输入的最常见写法。
        BufferedReader bufr = 
new BufferedReader(new InputStreamReader(System.in));
//输出最常见的写法
        BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));

        String line = null;
//读取数据
        while((line=bufr.readLine())!=null)
        {
            if("over".equals(line))
                break;
            bufw.write(line.toUpperCase());
            bufw.newLine();
            bufw.flush();
        }
//关闭资源
        bufr.close();
    }
}       

（四）、IO流操作规律
流操作的基本规律：
最痛苦的就是流对象有很多，不知道该用哪一个。所以IO流选择流对象的思路

通过三个明确来完成。

1，明确源和目的。
源：输入流。InputStream Reader
目的：输出流。OutputStream Writer。

2，操作的数据是否是纯文本。
是：字符流。
不是：字节流。

3，当体系明确后，在明确要使用哪个具体的对象。
通过设备来进行区分：
源设备：内存，硬盘。键盘
目的设备：内存，硬盘，控制台。

例子一：将一个文本文件中数据存储到另一个文件中，复制文件。
思路：
源：因为是源，所以使用读取流。InputStream Reader
是不是操作文本文件。
是！这时就可以选择Reader
这样体系就明确了。

接下来明确要使用该体系中的哪个对象。
明确设备：硬盘。上一个文件。
Reader体系中可以操作文件的对象是 FileReader
是否需要提高效率：是！。加入Reader体系中缓冲区 BufferedReader.

FileReader fr = new FileReader("a.txt");
BufferedReader bufr = new BufferedReader(fr);

目的：OutputStream Writer
是否是纯文本。
是！Writer。
设备：硬盘，一个文件。
Writer体系中可以操作文件的对象FileWriter。
是否需要提高效率：是！。加入Writer体系中缓冲区 BufferedWriter

FileWriter fw = new FileWriter("b.txt");
BufferedWriter bufw = new BufferedWriter(fw);

例子二：需求：将键盘录入的数据保存到一个文件中。
这个需求中有源和目的都存在。
那么分别分析
**源：**InputStream Reader
是不是纯文本？是！Reader
设备：键盘。对应的对象是System.in.
不是选择Reader吗？System.in对应的不是字节流吗？
为了操作键盘的文本数据方便。转成字符流按照字符串操作是最方便的。
所以既然明确了Reader，那么就将System.in转换成Reader。
用了Reader体系中转换流,InputStreamReader

InputStreamReader isr = new InputStreamReader(System.in);

需要提高效率吗？需要！BufferedReader
BufferedReader bufr = new BufferedReader(isr);

**目的：**OutputStream Writer
是否是存文本？是！Writer。
设备：硬盘。一个文件。使用 FileWriter。
FileWriter fw = new FileWriter(“c.txt”);
需要提高效率吗？需要。
BufferedWriter bufw = new BufferedWriter(fw);

例子三：扩展一下，想要把录入的数据按照指定的编码表（utf-8），将数据存到文件中。
**目的：**OutputStream Writer
是否是存文本？是！Writer。
设备：硬盘。一个文件。使用 FileWriter。
但是FileWriter是使用的默认编码表。GBK.
但是存储时，需要加入指定编码表utf-8。而指定的编码表只有转换流可以指定。
所以要使用的对象是OutputStreamWriter。
而该转换流对象要接收一个字节输出流。而且还可以操作的文件的字节输出流。FileOutputStream

OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("d.txt"),"UTF-8");

需要高效吗？需要。
BufferedWriter bufw = new BufferedWriter(osw);

所以，记住。转换流什么使用。起哄一个作用就是字符和字节之间的桥梁，通常，涉及到字
符编码转换时，需要用到转换流。

例子程序：

class  TransStreamDemo2  
{  
    public static void main(String[] args)throws IOException  
    {  

        //键盘录入  
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));  

        //存入文件中，利用转换流，按照指定的编码表（UTF-8）   
        BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("readin1.txt"),"UTF-8"));  

        String line=null;  
        while((line=br.readLine())!=null)  
        {  
            if("over".equals(line))  
                break;  
            bw.write(line);  
            bw.newLine();  
            bw.flush();  
        }  

小知识点：
异常的日志信息：
当程序在执行的时候，出现的问题是不希望直接打印给用户看的，是需要作为文件存储起来，方便程序员查看，并及时调整的。

例子程序部分代码：

//创建时间对象
  Date d=new Date();  
  //时间模块格式对象  
SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");  
                String s=sdf.format(d);  
  //打印流对象  
                PrintStream ps=new PrintStream("info.log");
                System.setOut(ps);  //修改输出流设备
                ps.println(s);//输出时间  

系统属性信息存入文本
例子程序：

PrintStream ps = null;    
       try    
       {    
          //获取系统信息：    
          Properties pop = System.getProperties();    
          //创建输出流对象，将输出流中数据存入指定文件中    
          ps = new PrintStream("systeminfo.txt");    
          //将属性列表输出到指定的输出流    
          pop.list(ps);    
       }