day19

<1 IO流（BufferedWriter）>

 

package day19;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

/**
 * 缓冲区 出现时为了提高流的操作效率而出现的
 * 所以在创建缓冲区之前，必须要先有流对象
 * 
 * 该缓冲区中提供了一个跨平台的换行符：newLine()
 * 注意：像这样的方法，都是只有 缓冲区对象才有的。所以一定要先有缓冲区对象。
 * Created by Administrator on 2017/2/8.
 */
public 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();

    }
}

<02 IO流（BufferedReader）>

 

 

package day19;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

/**
 * 字符读取流缓冲区
 *
 * 一行一行的读，是最方便的
 *
 * 该缓冲区提供了一个一次读一行的方法readLine(),方便于对文本数据的读取。
 * 当返回null时，表示读到文件末尾。
 *
 * readLine方法返回的时候只返回回车符之前的数据内容。并不返回回车符。
 * Created by Administrator on 2017/2/8.
 */
public class BufferedReaderDemo {
    public static void main(String[] args) throws IOException {
        //创建一个读取流对象和文件相关联
        FileReader fr = new FileReader("buf.txt");

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

//        String s1 = bufr.readLine();   //一行一行的读
//        System.out.println(s1);

        //循环读
        String line = null;
        while((line = bufr.readLine()) != null){
            System.out.println(line);
        }
    }
}

<03 IO流（通过缓冲区复制文本文件）>

 

 

package day19;

import com.sun.org.apache.regexp.internal.RE;

import java.io.*;

/**
 * 通过缓冲区复制一个.java文件.
 * Created by Administrator on 2017/2/8.
 */
public class CopyTestByBuf {
    public static void main(String[] args){
        BufferedReader bufr = null;
        BufferedWriter bufw = null;

        try {
            bufr = new BufferedReader(new FileReader("D:\\code\\javacode\\src\\day19\\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("写入关闭失败");
            }


        }

    }
}

<04 readLine的原理>

 

readLine()方法的原理：

无论是读一行，还是读取多个字符。其实最终都是从硬盘上一个一个的读取。

所以最终使用的还是read()方法来一个一个的读。

 

只要遇到回车符\n，就表示前面的数据是一行。于是会把前面的数据一次性的输出。 （而read()是读一个 返回一个）

<05 自定义MyBufferedReader>

<06 装饰设计模式/装饰类>

装饰类的方式：

构造函数的传递，基本功能增强。

 

package day19;

/**
 * 装饰设计模式：
 * 当想要对已有的对象进行功能增强时，
 * 可以定义类，将已有对象传入，基于已有的功能，并提供加强功能。
 * 那么自定义的类称为装饰类
 *
 * 装饰类通常会通过构造方法接收被装饰的对象。
 * 并基于被装饰的对象的功能，提供更强的功能。
 * Created by Administrator on 2017/2/9.
 */
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("来一根");
    }
}

public class PersonDemo {
    public static void main(String[] args){
        Person p = new Person();
        p.chifan();
    }
}

<07 装饰和继承的区别>（再听）

 

装饰更灵活。

不要继承太多。

 

/*


MyReader//专门用于读取数据的类。
	|--MyTextReader
		|--MyBufferTextReader
	|--MyMediaReader
		|--MyBufferMediaReader
	|--MyDataReader
		|--MyBufferDataReader

class MyBufferReader
{
	MyBufferReader(MyTextReader text)
	{}
	MyBufferReader(MyMediaReader media)
	{}
}
上面这个类扩展性很差。
找到其参数的共同类型。通过多态的形式。可以提高扩展性。

class MyBufferReader extends MyReader
{
	private MyReader r;
	MyBufferReader(MyReader r)
	{}
}	


MyReader//专门用于读取数据的类。
	|--MyTextReader
	|--MyMediaReader
	|--MyDataReader
	|--MyBufferReader


以前是通过继承将每一个子类都具备缓冲功能。
那么继承体系会复杂，并不利于扩展。

现在优化思想。单独描述一下缓冲内容。
将需要被缓冲的对象。传递进来。也就是，谁需要被缓冲，谁就作为参数传递给缓冲区。
这样继承体系就变得很简单。优化了体系结构。





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

装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强功能。
所以装饰类和被装饰类通常是都属于一个体系中的。




*/


class  
{
	public static void main(String[] args) 
	{
		System.out.println("Hello World!");
	}
}

<08 自定义装饰类>

 

要重写Reader中的抽象方法。

<09 LineNumberReader>

它里面有个属性LineNumber，报告对应的get和set方法：getLineNumber()、setLineNumber()

 

package day19;


import java.io.*;

/**
 * Created by Administrator on 2017/2/9.
 */
public class LineNumberReader {
    public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader("D:\\code\\javacode\\src\\day19\\PersonDemo.java");
        java.io.LineNumberReader lnr = new java.io.LineNumberReader(fr);

        String line = null;
        lnr.setLineNumber(100);

        while((line = lnr.readLine()) != null){
            System.out.println(lnr.getLineNumber() + ": " + line);
        }
        lnr.close();
    }
}

//练习：模拟一个带行号的缓冲区对象。

<10 MyLineNumberReader>

再看

<11 字节流FileOutputStream FileInputStream>

 

package day19;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 字符流：
 * FileReader
 * FileWriter
 *
 * BufferedReader
 * BufferedWriter
 *
 * 字节流:
 * InputStream OutputStream
 *
 * 要求：想要操作图片数据。这时就要用到字节流。
 *
 * Created by Administrator on 2017/2/9.
 */
public class FileStream {
    public static void main(String[] args) throws IOException {
//        writeFile();
        readFile_3();
    }

    public static void readFile_3() throws IOException {
        FileInputStream fis = new FileInputStream("fos.txt");

        byte[] buf = new byte[fis.available()];
        System.out.println(new String(buf));
        fis.close();
    }

    public static void readFile_2() throws IOException {
        FileInputStream fis = new FileInputStream("fos.txt");

        byte[] buf = new byte[1024];
        int len = 0;
        while((len = fis.read(buf)) != -1){
            System.out.println(new String(buf, 0, len));
        }
        fis.close();
    }

    public static void readFile_1() throws IOException {
        FileInputStream fis = new FileInputStream("fos.txt");
        int ch = 0;
        while((ch = fis.read()) != -1){
            System.out.println((char)ch);
        }
        fis.close();
    }

    public static void writeFile() throws IOException {
        FileOutputStream fos = new FileOutputStream("fos.txt");
        fos.write("abcde".getBytes());
    }
}

 

<12 拷贝图片>

字符流只用来处理文字数据，不要用它来处理媒体数据。

package day19;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 复制一个图片
 *
 * 思路：
 * 1.用字节读取流对象和图片关联。
 * 2.用字节写入流对象创建一个图片文件。用于存储获取到的图片数据。
 * 3.通过循环读写，完成数据的存储。
 * 4.关闭资源。
 * Created by Administrator on 2017/2/9.
 */
public class CopyPic {
    public static void main(String[] args){
        FileOutputStream fos = null;
        FileInputStream fis = null;

        try {
            fos = new FileOutputStream("c:\\2.bmp");
            fis = new FileInputStream("1.bmp");

            byte[] buf = new byte[1024];

            int len = 0;
            while((len = fis.read(buf)) != -1){
                fos.write(buf, 0, len);
            }
        } catch (java.io.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("写入关闭失败");
            }
        }
    }
}

<13 字节流缓冲区>

 

package day19;

import java.io.*;

/**
 * 演示mp3的复制，通过缓冲区
 * Created by sws on 17-2-9.
 */
public class CopyMp3 {
    public static void main(String[] args){

    }
    public static void copy_1() throws IOException{
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("0.mp3"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("1.mp3"));

        int by = 0;

        while((by = bis.read()) != -1){
            bos.write(by);
        }
        bis.close();
        bos.close();
    }
}

<14 自定义字节流缓冲区>（再看）

read()在提升：byte提升为in。（避免了-1的发生）

write()在强转：只取最低的8位。

<15 读取键盘录入>

 

package day19;

import java.io.IOException;
import java.io.InputStream;
import java.io.SyncFailedException;

/**
 * 读取键盘录入：
 * System.out:对应的是标准输出设备，控制台。
 * System.in：对应的是标准输入设备，键盘。
 *
 * 需求：
 * 通过键盘录入数据。
 * 当录入一行数据后，就将该行数据进行打印。
 * 如果录入的数据是over，那么停止录入。
 * Created by Administrator on 2017/2/10.
 */
public class ReadIn {
    public static void main(String[] args) throws IOException {
        InputStream in = System.in;
        StringBuilder sb = new StringBuilder();

        while(true){
            int ch = in.read();
            if(ch == '\r')
                continue;
            if(ch == '\n'){
                String s = sb.toString();
                if("over".equals(s))
                    break;
                System.out.println(sb.toString().toUpperCase());
                sb.delete(0, sb.length());
            }else{
                sb = sb.append((char)ch);
            }
        }
    }
}

<16 读取 转转换流>

 

package day19;

import java.io.*;

/**
 * 字符流：
 * FileReader
 * FileWriter
 *
 * BufferedReader
 * BufferedWriter
 *
 * 字节流：
 * FileInputStream
 * FileOutputStream
 *
 * BufferedInputStream
 * BufferedOutputStream
 *
 *
 * 通过刚才的键盘录入一行数据并打印其大写，发现其实就是读一行数据的原理。
 * 也就是readLine方法。
 *
 * 能不能直接使用readLine方法来完成键盘录入的一行数据的读取呢？
 *
 * readLine方法是字符流BufferedReader类中的方法。
 * 而键盘录入的方法是字节流InputStream的方法。
 * 那么能不能将字节流转换成字符流 再使用字符流缓冲区的readLine方法呢？
 *
 * Created by Administrator on 2017/2/10.
 */
public class ReadIn {
    public static void main(String[] args) throws IOException {
        //获取键盘录入对象
        InputStream in = System.in;

        //将字节流对象转成字符流对象，使用转换流。InputStreamReader
        InputStreamReader isr = new InputStreamReader(in);

        //为了提高效率，将字符串进行缓冲区技术的高效操作。使用BufferedReader
        BufferedReader bufr = new BufferedReader(isr);
        String line = null;
        while((line = bufr.readLine()) != null){
            if("over".equals(line))
                break;
            System.out.println(line.toUpperCase());
        }
        bufr.close();

    }
}

<17 写入转换流>

 

记住下面这段。只要要求“键盘录入”，就写它。 （键盘录入的最常见写法）

 

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

不写System.in的原因：System.in一次只能读一个字节。而上面这段话能读一行字节。

<18 流操作规律1>

 

package day19;

import java.io.*;

/**
 * 1
 * 源：键盘录入。
 * 目的：控制台
 *
 * 2.需求：想把键盘录入的数据存储到一个文件中。
 * 源：键盘。
 * 目的：文件
 *
 * 3.需求：想要将一个文件的数据打印在控制台上。
 * 源：文件。
 * 目的：控制台。
 *
 * 流操作的基本规律：
 * 最痛苦的就是流对象有很多，不知道该用哪一个。
 *
 * 通过三个明确来完成。
 * 1.明确源和目的。
 *  源：输入流。InputStream Reader
 *  目的：输出流。OutputStream Writer
 * 2.明确操作的数据是否是纯文本。
 *   如果是：用字符流。
 *   不是： 用字节流
 * 3.当体系明确后，再明确要使用哪个具体的对象。
 *   通过设备来进行区分。
 *   源设备包括：内存、硬盘、键盘
 *   目的设备包括：内存、硬盘、控制台。
 *
 * 示例：
 * 1.需求：将一个文本文件中数据存储到另一个文件中。复制文件。
 * 1）源：因为是源，所以使用读取流。InputStream Reader
 * 2）是不是操作文本文件？是！所以可以宣传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);
 *
 *
 * 练习：将一个图片文件中的数据存储到另一个文件中。复制文件。要按照以上格式自己完成三个明确。
 * 1）源：读取。输入流：InputStream 或 Reader
 * 2）操作的数据是不是纯文本？否！所以用字节流：InputStream
 * 3）确定要使用的具体对象：（FileInputStream）
 *
 * FileInputStream fis = new FileInputStream("a.tmp");
 * BufferedInputStream bis = new BufferedInputStream(fis);
 *
 * Created by Administrator on 2017/2/10.
 */
public class ReadIn {
    public static void main(String[] args) throws IOException {
        BufferedReader bufr1 = new BufferedReader(new InputStreamReader(new FileInputStream("out.txt")));
        BufferedWriter bufw1 = new BufferedWriter(new OutputStreamWriter(System.out));

        //键盘录入
        BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("out.txt")));

        String line = null;

        while((line = bufr.readLine()) != null){
            if("over".equals(line))
                break;
            bufw.write(line.toUpperCase());
            bufw.newLine();
            bufw.flush();
        }
    }
}

<19 流操作原理2-转换流>

 

package day19;

import java.io.*;

/**
 * 1
 * 源：键盘录入。
 * 目的：控制台
 *
 * 2.需求：想把键盘录入的数据存储到一个文件中。
 * 源：键盘。
 * 目的：文件
 *
 * 3.需求：想要将一个文件的数据打印在控制台上。
 * 源：文件。
 * 目的：控制台。
 *
 * 流操作的基本规律：
 * 最痛苦的就是流对象有很多，不知道该用哪一个。
 *
 * 通过三个明确来完成。
 * 1.明确源和目的。
 *  源：输入流。InputStream Reader
 *  目的：输出流。OutputStream Writer
 * 2.明确操作的数据是否是纯文本。
 *   如果是：用字符流。
 *   不是： 用字节流
 * 3.当体系明确后，再明确要使用哪个具体的对象。
 *   通过设备来进行区分。
 *   源设备包括：内存、硬盘、键盘
 *   目的设备包括：内存、硬盘、控制台。
 *
 * 示例：
 * 1.需求：将一个文本文件中数据存储到另一个文件中。复制文件。
 * 1）源：因为是源，所以使用读取流。InputStream Reader
 * 2）是不是操作文本文件？是！所以可以宣传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);
 *
 *
 * 练习：将一个图片文件中的数据存储到另一个文件中。复制文件。要按照以上格式自己完成三个明确。
 * 1）源：读取。输入流：InputStream 或 Reader
 * 2）操作的数据是不是纯文本？否！所以用字节流：InputStream
 * 3）确定要使用的具体对象：（FileInputStream）
 *
 * FileInputStream fis = new FileInputStream("a.tmp");
 * BufferedInputStream bis = new BufferedInputStream(fis);
 *
 * Created by Administrator on 2017/2/10.
 *
 * 2.需求：将键盘录入的数据保存到一个文件中。
 * 这个需求中，源和目的都存在。则分别分析。
 * 源：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);
 *
 * 1）目的：OutputStream 或 Writer
 * 2）是否是纯文本？是！用Writer
 * 3）设备：硬盘。一个文件。使用FileWriter
 * FileWriter fw = new FileWriter("c.txt");
 * 需要提高效率吗？需要！
 * BufferedWriter bufw = new BufferedWriter(fw);
 *
 * 扩展一下：想要把录入的数据按照指定的编码表（utf-8），将数据存到文件中。
 * 1）目的：OutputStream 或 Writer
 * 2）是否是纯文本？是！用Writer
 * 3）设备：硬盘。一个文件。使用FileWriter
 * 但是FileWriter是使用的默认编码表GBK。
 *
 * 但是 存储时，需要加入指定的编码表utf-8。而指定的编码表只有转换流可以指定。
 * 所以要使用的对象是OutputStreamWriter。
 * 而该转换流对象要接收一个字节输出流。而且还可以操作文件的字节输出流。所以用FileOutputStream。
 *
 * OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("d.txt"), "UTF-8");
 *
 * 需要高效吗？
 * BufferedWriter bufw = new BufferedWriter(osw);
 *
 * 所以，记住，转换流什么时候使用？字符和字节之间的桥梁，通常，涉及到字符编码转换时，
 * 需要用到转换流。
 *
 * FileWriter fw = new FileWriter("c.txt");
 * 需要提高效率吗？需要！
 * BufferedWriter bufw = new BufferedWriter(fw);
 *
 *
 */
public class ReadIn {
    public static void main(String[] args) throws IOException {
        //键盘的最常见写法
        BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("d2.txt"), "UTF-8"));

        String line = null;
        while((line = bufr.readLine()) != null){
            if("over".equals(line))
                break;
            bufw.write(line.toUpperCase());
            bufw.newLine();
            bufw.flush();
        }
        bufr.close();
    }
}

<20 改变标准输入输出设备>

System.setIn()

System.setOut()

public class ReadIn {
    public static void main(String[] args) throws IOException {
        System.setIn(new FileInputStream("/media/sws/DC941A51941A2F10/code/javacode/src/day19/PersonDemo.java"));
        System.setOut(new PrintStream("zz.txt"));

        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();
    }
}

<21 异常的日志信息>

 

package day19;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PrintStream;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * Created by Administrator on 2017/2/12.
 */
public class ExceptionInfo {
    public static void main(String[] args){
        try{
            int[] arr = new int[2];
            System.out.println(arr[3]);
        }catch(Exception e){
            try{
                Date d = new Date();
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                String s = sdf.format(d);

                PrintStream ps = new PrintStream("exception.log");
                ps.println(s);
                System.setOut(ps);

            }catch(IOException e1){
                throw new RuntimeException("日志文件创建失败");
            }
            e.printStackTrace(System.out);
        }
    }
}
//网上下载log4j工具。日志信息的建立

<22 系统信息>

 

package day19;

import java.io.FileNotFoundException;
import java.io.PrintStream;
import java.util.Properties;

/**
 * Created by Administrator on 2017/2/12.
 */
public class SystemInof {
    public static void main(String[] args) throws FileNotFoundException {
        Properties prop = System.getProperties();
//        System.out.println(prop);
        prop.list(new PrintStream("sysinfo.txt"));  //流就是用来操作数据的。
    }
}