黑马程序员_字符流的缓冲区

                      ----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------  

字符流的缓冲区

 1.缓冲区的出现提高了对数据的读写效率，所以在创建缓冲区之前，必须要先有流对象
 2.对应类：1.BufferedWriter 2.BufferedReader
 3.缓冲区要结合流才可以使用
 4.在流的基础上对流的功能进行了增强
 5.字符流只适合用来处理文本文件
 
一：BufferedWriter类
 1.FileWriter fw=new FileWriter("buf.txt");     //创建一个字符写入流对象   
    BufferedWriter bufw=new BufferedWriter(fw);  //为了提高字符写入流效率。加入了缓冲技术，将    需要被提高效率的流对象作为参数传递给缓冲区的构造函数
 2.只要用到缓冲区，就要记得刷新
 3.其实关闭缓冲区，就是关闭缓冲区中的流对象


二：BufferedReader类
 1.String line=null;
    while((line=bufr.readLine())!=null)
    {
        System.out.println(line);
    } 
   //一行一行的读取文件中的数据
 2.缓冲区提供了一个一次读一行的方法readLine，方便与对文本数据的获取，当返回为空时，
   表示读到文件的末尾处


三：readline方法的原理
   无论是读一行，获取读取的多个字符。其中最终都是在硬盘上一个一个读取。所以最终使用的还是       read方法一次读一个的方法。


四：StringBuilder类
 1.一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作     StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍），它比    StringBuffer 要快。
 2.StringBuilder 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数。
    append 方法始终将这些字符添加到生成器的末端；而 insert 方法则在指定的点添加字符。 
 3.如果 sb 引用 StringBuilder 的实例，则 sb.append(x) 和 sb.insert(sb.length(), x) 具有相同     的效果。 每个字符串生成器都有一定的容量。只要字符串生成器所包含的字符序列的长度没有超出此    容量，就无需分配新的内部缓冲区。如果内部缓冲区溢出，则此容量自动增大。 
 4.将 StringBuilder 的实例用于多个线程是不安全的。如果需要这样的同步，则建议使用StringBuffer 
 5.明白了BufferedReader类中的特有方法readline的原理后，可以自定义一个类中包含一个功能和         readline一致的方法。来模拟一下BufferedReader
   class  myBufferedReader
   {
private FileReader r;
myBufferedReader(FileReader r)
{
this.r=r;
}
//可以一次读一行数据的方法
public String myReadLine() throws IOException
{
//定义一个临时容器，原BufferReader封装的是字符数组。
//为了演示方便，定义一个StringBuilder容器，因为最终还要将数据变为字符串
        StringBuilder sb=new StringBuilder();
int ch=0;
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;
}
public void myCLose() throws IOException
{
r.close();
}
   }


五：装饰类
 1.装饰设计模式：
   当想要对已有的对象进行功能增强时，可以定义类，将已有对象传入，基于已有的功能，并提供加强     功能，那么，该自定义的类被称为装饰类。
 2.装饰类通常会通过构造方法接受被装饰的对象，并基于被装饰的对象的功能，提供更强的功能。
 3.装饰类在结构上类似实现了继承，在功能上类似实现了封装。
  eg：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("来一根");
}
      }
      class PersonDemo 
      {
public static void main(String[] args) 
{
    Person p=new Person();
    //p.chifan();
    SuperPerson sp=new SuperPerson(p);
    sp.superChifan();
}
      }
 4.装饰模式：
   class MyBufferReader extends MyReader
   {
  private MyReader r;
MyBufferReader(MyReader r)
{}
   }
   MyReader//专门用于读取数据的类
    |--MyTextReader
|--MyMediaReader
    |--MyDataReader
    |--MyBufferReader
 5.装饰模式比继承模式灵活。避免了继承体系臃肿。而且降低了类与类之间的关系。
 6.装饰类因为增强已有的对象，具备的功能和已有的是相同的，只不过提供了更强功能，
   所以装饰类和被装饰类通常是都属于一个体系中的。


六：模拟一个带行号的流类
   class  LineNumberReaderDemo
   {
public static void main(String[] args) throws IOException
{
FileReader fr=new FileReader("PersonDemo.java");
LineNumberReader lnr=new LineNumberReader(fr);
String line=null;
lnr.setLineNumber(100); //设置从多少行开始
while((line=lnr.readLine())!=null)
{
System.out.println(lnr.getLineNumber()+":"+line);
                        //getLineNumber():获取代码的行号
}
lnr.close();
}
   }


七：模拟一个带行号的缓冲区
    class  MyLineNumberReader
    {
private Reader r;
private int lineNumber;
MyLineNumberReader(Reader r)
{
this.r=r;


}
public String myReaderLine() throws IOException
{
lineNumber++;
StringBuilder sb=new StringBuilder();
int ch=0;
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;
}
public void setLineNumber(int lineNumber)
{
this.lineNumber=lineNumber;
}
public int getLineNumber()
{
return lineNumber;
}
    }
    FileReader fr=new FileReader("copyTextByBuf.java");
MyLineNumberReader mylnr=new MyLineNumberReader(fr);
String line=null;
while((line=mylnr.myReaderLine())!=null)
{
System.out.println(line);
}
mylnr.myClose(mylrn.gerLineNumber()+"::"+line);


八：简化缓冲区
   class MyLineNumberReader extends myBufferedReader   
   {    
private int lineNumber;
MyLineNumberReader(Reader r)
{
super(r);  //只要父类有的方法可以直接调用，不要再重复写，这就是继承的好处
}
public String myReaderLine() throws IOException
{
lineNumber++;
return super.myReadLine();
}

   }

----------------------- android培训、java培训、java学习型技术博客、期待与您交流！ ----------------------