Java Day 21

复制文本文件
 思路：
 1、需要读取源
 2、将读到的源数据写入目的地
 3、使用字符流
 
 方式二
 

字符流 - 缓冲区
 BufferedWriter
 newLine();
 BufferedReader
 readLine();

readLine原理

package com.company.Day021;

import java.io.*;

/**
 * Created by junius on 2016/10/18.
 */
public class CopyOfFile {

    public static final int BUFFER_SIZE = 4096;
    public static final int BUFF_SIZE = 1024;

    public static void main(String[] args) throws IOException {
        //demo_1();
        //demo_2();
//        demo_3();
//        demo_4();
//        demo_5();
        demo_6();
    }

    private static void demo_6() throws IOException{
        FileReader fr = new FileReader("buf.txt");
        MyBufferedReader bufr = new MyBufferedReader(fr);

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

        String line =null;
        while((line=bufr.myReadLine())!=null){
            bufw.write(line);
            bufw.newLine();
            bufw.flush();
        }
        bufw.close();
        bufr.myClose();
    }


    private static void demo_5() throws IOException{
        FileReader fr = new FileReader("buf.txt");
        BufferedReader bufr = new BufferedReader(fr);

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

        String line =null;
        while((line=bufr.readLine())!=null){
            bufw.write(line);
            bufw.newLine();
            bufw.flush();
        }
        //方法一：
        /*int ch =0;
        while((ch=bufr.read())!=-1){
            bufw.write(ch);
        }*/
        bufw.close();
        bufr.close();
    }

    private static void demo_4() throws IOException {
        FileReader fr = new FileReader("buf.txt");
        BufferedReader bufr = new BufferedReader(fr);
        String line1=null;
        while((line1=bufr.readLine())!=null){
            System.out.println(line1);
        }

        bufr.close();

        //FileReaderDemo();
    }

    private static void FileReaderDemo() throws IOException {
        FileReader fr = new FileReader("buf.txt");
        char[] buf = new char[BUFF_SIZE];

        int len =0;
        while((len=fr.read(buf))!=-1){
            System.out.println(new String(buf,0,len));
        }
        fr.close();
    }

    private static void demo_3() throws IOException {
        FileWriter fw = new FileWriter("buf.txt");
        //创建一个字符写入流的缓冲区对象，并和指定要缓冲的流对象相关联
        BufferedWriter bufw =  new BufferedWriter(fw);

        bufw.write("abc");
        bufw.newLine();
        bufw.write("eeee");
        bufw.flush();
        //关闭缓存区，就是关闭流
        bufw.close();
    }

    private static void demo_2() {
        FileReader fr = null;
        FileWriter fw = null;
        try {
            fr = new FileReader("IO_2.txt");
            fw = new FileWriter("copytext_2.txt");
            //创建临时容器，用于缓存读取到的字符
            char[] buf = new char[BUFFER_SIZE];
            //定义一个变量记录读取到的字符数（其实就是往数组里装的字符个数）
            int len = 0;
            while((len=fr.read(buf))!=-1){
                fw.write(buf,0,len);
            }

        }catch (Exception e){
            throw  new RuntimeException("读写失败");
        }finally {
            if(fw!=null)
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            if(fr!=null)
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
        }
    }

    private static void demo_1() throws IOException{
        //1、使用字符读取流和文件相关联
        FileReader fr = new FileReader("IO_2.txt");
        //2、创建一个目的文本，用于存储读到的数据
        FileWriter fw = new FileWriter("copytext_1.txt");
        //3、频繁操作读写操作
        int ch = 0;
        while((ch=fr.read())!=-1){
            fw.write(ch);
        }
        //4、关闭流资源
        fw.close();
        fr.close();
    }
}

package com.company.Day021;

import java.io.File;
import java.io.FileReader;
import java.io.IOException;

/**
 * Created by junius on 2016/10/21.
 * 自定义读取缓冲区
 * 缓冲区封装一个数组
 *
 */
public class MyBufferedReader {
    public static final int BUFF_SIZE = 1024;
    private FileReader r;
    private char[] buf = new char[BUFF_SIZE];
    //操作指针，最后一个元素，指针为0
    private int pos = 0;
    //计数器，数据减为0，继续读取源
    private int count = 0;

    MyBufferedReader(FileReader r){
        this.r = r;
    }

    public int myRead()throws IOException{
        if(count==0){
            count = r.read(buf);
            pos = 0;
        }
        if(count<0)
            return -1;
        char ch = buf[pos++];
        count--;
        return ch;
    }

    public String myReadLine()throws IOException{
        StringBuilder sb = new StringBuilder();
        int ch = 0;
        while((ch=myRead())!=-1){
            if(ch=='
')
                continue;
            if(ch=='
')
                return sb.toString();
            sb.append((char)ch);
        }
        if(sb.length()!=0)
            return sb.toString();
        return null;
    }

    public void myClose() throws IOException{
        r.close();
    }
}

 
装饰设计模式
 将对象的功能进行增强

装饰和继承的区别
 装饰类和被装饰类都必须所属同一个接口或父类

LineNumberReader

package com.company.Day021;

import java.io.FileReader;
import java.io.IOException;
import java.io.LineNumberReader;

/**
 * Created by junius on 2016/10/23.
 */
public class Demo {
    public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader("buf_copy_4.txt");
        LineNumberReader lnr = new LineNumberReader(fr);
        String line = null;
        while((line=lnr.readLine())!=null){
            System.out.println(lnr.getLineNumber()+":"+line);
        }
        lnr.close();
        fr.close();
    }
}

 
字节流
 InputStream
 OutputStream

 不需要临时存储，直接源码写入目的地中