黑马程序员-IO字符流一些原理与应用

------------------------------- Android培训                      Java培训   期待与您的交流！---------------------

//通过缓存类将文件从F盘复制到G盘
import java.io.*;

class Buffcopy 
{
    public static void main(String[] args) 
    {
        BufferedReader buffr=null;    
        BufferedWriter buffw=null;

        try
        {
            buffr=new BufferedReader(new FileReader("F:\\Demo15.java"));//通过绝对路径和文件相关联
            buffw=new BufferedWriter(new FileWriter("G:\\Demo15_copy.java"));

            String s=null;
            while ((s=buffr.readLine())!=null)
            {
                buffw.write(s);
                buffw.newLine();                                        //由于readLine()并没有返回换行字符，所以写要换行
                buffw.flush();
            }
        }
        catch (IOException e)
        {
            System.out.println(e.toString());
        }finally{
            try
            {
                if(buffr!=null)
                    buffr.close();
            }
            catch (IOException e)
            {
                System.out.println(e.toString());
            }finally{
                try
                {
                    if(buffw!=null)
                        buffw.close();
                }
                catch (IOException e)
                {
                    System.out.println(e.toString());
                }
            }
        }
    }
}
//   字符缓存读   返回一个字符串的readLine()整行(不包含换行字符)的读取方法，末尾返回null;

import java.io.*;

class IO_1902 
{
    public static void main(String[] args) throws IOException
    {
        FileReader fr=new FileReader("demo.txt");//创建于文件相关联的流对象

        BufferedReader buffr=new BufferedReader(fr);

        //对文件进行全部信息读取
        String s=null;
        while ((s=buffr.readLine())!=null)
        {
            System.out.println(s);
        }
        buffr.close();
                                                    
    }
}

/*
    自己做一个类，模拟BufferedReader的readLine方法

    装饰设计模式

    当想要对已有的对象进行功能增强时，
    可以定义类，将已有对象传入，基于已有的功能，并提供加强功能
    那么自定义的该类称为装饰类
    MyReader就是对FileReader的装饰类



    装饰模式与继承模式的区别

    继承是为了将父类更加的细致化操作对象

    装饰是将子类通过多态，进行扩展

    装饰模式比继承模式要灵活，避免了继承的臃肿
    而且降低了类与类之间个关系

    装饰类因为是装饰已有对象，功能是一样的，但是加强了，属于同一体系的
*/
import java.io.*;

class MyBufferedReader extends Reader            //定义类
{
    private Reader fr;                            //创建已有对象
    public MyBufferedReader(Reader fr){            //将已有对象作为参数传入装饰类的构造方法
        this.fr=fr;
    }
    public void close()throws IOException
    {
        fr.close();
    }
    public int read(char [] aa,int off,int len)throws IOException
    {
        return fr.read(aa,off,len);
    }


    public String myReadLine() throws IOException{     //public 是可以对外提供的方法
        StringBuffer stb=new StringBuffer();         //字符缓存。容器
        
        int ch=0;
        while ((ch=fr.read())!=-1)
        {
            if(ch=='\r')
                continue;
            if(ch=='\n')
                return stb.toString();
            else
                stb.append((char)ch);                //将字符加到缓存区去
        }
        if(stb.length()!=0){
            return stb.toString();
        }
        return null;
        
    }
    public void myclose() throws IOException{
        fr.close();
    }
    
}

class DemoMyReadLine 
{
    public static void main(String[] args) throws IOException
    {
        FileReader fr=new FileReader("F:\\Demo15.java");
        MyBufferedReader mr=new MyBufferedReader(fr);

        String s=null;

        while ((s=mr.myReadLine())!=null)
        {
            System.out.println(s);
        }
        mr.myclose();
    }
}

/*
*缓存区的操作对象是流，为了提高流的操作效率而出现的
所以在缓存类的构造方法中都有一个流对象的参数
newline方法是一个跨平台的提供换行符的方法。
*/

import java.io.*;
class IO_1901 
{
    public static void main(String[] args) throws IOException
    {
        FileWriter fw=new FileWriter("demo.txt",true);    //创建一个字符写入流对象。
            
        BufferedWriter buffw=new BufferedWriter(fw);    //与流对象相关联,

        buffw.write("hello");                            //只是将字符写入缓存，并未写入文件

        buffw.newLine();                                //统一的换行标示

        buffw.flush();                                    //将缓存的数据写入目的文件，并清空缓存，只有刷新才能真的写入进文件

        buffw.close();                                    //原理是关闭与缓存对象相关联的流对象
    }
}

 //   根据读取有行号的原理，模拟有行号的读取方式类的设计，及应用复用提高代码效率
import java.io.*;
    //复用，取代下面运用效率不高的代码块
    class MyNumberLine extends MyBufferedReader
{
    private int number;                                    //行号 包装对象
    public MyNumberLine(Reader r)                        //将被装饰的对象传入
    {
        super(r);                                        //类的复用
    }
    public int getnumber(){
        return number;
    }
    public void setnumber(int number){
        this.number=number;
    }
    public String myNumberLine() throws IOException{
        number++;
        return super.myReadLine();                        //等价于调用父类的myread();
    }
}


/*
此代码的利用率不高

class MyNumberLine 
{
    private int number;//行号
    private Reader r;//包装对象
    public MyNumberLine(Reader r)//将被装饰的对象传入
    {
        this.r=r;
    }
    public int getnumber(){
        return number;
    }
    public void setnumber(int number){
        this.number=number;
    }
    public String myNumberLine() throws IOException{
        number++;
        StringBuffer sbf=new StringBuffer();
        int ch=0;

        while((ch=r.read())!=-1) 
        {
            if(ch=='\r'){
            
            }else if(ch=='\n')
            {
                return sbf.toString();
            }else
            {
                sbf.append((char)ch);
            }
        }
        if(sbf.length()!=0)
        {
            return sbf.toString();
        }
        return null;
                                        //等价于调用父类的myread();
        
    }
    public void myclose()throws IOException{
        r.close();
    } 
}
*/
class MyNumberLineDemo
{
    public static void main(String[] args) throws IOException
    {
        FileReader fr=new FileReader("F:\\Demo15.java");     //与相关文件建立连接

        MyNumberLine mnl=new MyNumberLine(fr);                 //用自己写的类
        
        String line=null;
        mnl.setnumber(100);
        while ((line=mnl.myNumberLine())!=null)
        {
            System.out.println(mnl.getnumber()+":"+line);
        }
        mnl.myclose();
    }
}