IO流(二)

BufferedWriter

缓冲区的出现是为了提高流的操作效率而出现的。所以在创建缓冲区之前必须要先有流对象。
下面代码演示BufferedWriter

import java.io.*;

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

		//提高字符写入流效率，加入缓冲技术。
		//只要将需要被提高效率的流对象作为参数传递该缓冲区的构造函数即可。
		BufferedWriter bufw = new  BufferedWriter(fw);
		bufw.write("abcde");
		bufw.flush();
		bufw.close();
	}

只要用到缓冲区就要记得刷新

该缓冲区中提供了一个跨平台的换行符。
newLine();

public static void BufferedWriterStr() throws IOException
	{
		FileWriter fw = new FileWriter("demo.txt");

		BufferedWriter bufw = new BufferedWriter(fw);

		for(int x=1; x<5; x++)
		{
			bufw.write("abcd"+x);
			bufw.newLine();
			bufw.flush
			bufw.close();
		}
	}

BufferedReader

字符读取流缓冲区
例(读取文本文件)：

	public static void BufferedReadTxt() throws IOException
	{
		FileReader fr = new FileReader("demo.txt");
		BufferedReader bufr = new BufferedReader(fr);
		
		char[] buf = new char[1024];
		int len = 0;

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

readLine ：该缓冲区提供的一个一次读一行的方法，方便对文本数据的获取，当返回null时，表示读到文件末尾。
示例：

//方法一：
public static void Buffered_readLine_1() throws IOException
	{
		FileReader fr = new FileReader("buf.txt");
		BufferedReader bufr = new BufferedReader(fr);

		String s1 = bufr.readLine();
		System.out.println("s1: "+s1);

		String s2 = bufr.readLine();
		System.out.println("s2: "+s2);

		bufr.close();
	}
//方法二：
public static void Buffered_readLine_2() throws IOException
	{
		FileReader fr = new FileReader("demo.txt");
		BufferedReader bufr = new BufferedReader(fr);
		String line = null;
		
		while((line = bufr.readLine()) != null)
		{
			System.out.println(line);
		}
	}

小练习：
思考：通过缓冲区复制文本文件？
代码：

import java.io.*;
class CopyTextByBuf
{
	public static void main(String[] args)
	{
		CopyByBufTest();
	}

	public static void CopyByBufTest()
	{
		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;

			//readLine方法返回的时候只返回回车符之前的数据内容，并不返回回车符
			while ((line = buwr.readLine()) != null)
			{
				//System.out.println("");
				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("写入关闭失败");

			}
		}		
	}
}

---

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

import java.io.*;

class MyBufferedReaderLine 
{
	private FileReader r;
	MyBufferedReaderLine(FileReader r)
	{
		this.r = r;
	}

	//可以一次读一行数据的方法。
	public String myReadLine() throws IOException
	{
		//定义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();
	}
}

class MyBufferedReaderDemo
{
	public static void main(String[] args) throws IOException
	{
		FileReader fr = new FileReader("demo.txt");

		MyBufferedReaderLine myBuf = new MyBufferedReaderLine(fr);

		String line = null;

		while ((line = myBuf.myReadLine()) != null)
		{
			System.out.println(line);
		}
		myBuf.myClose();
	}
}

---

装饰设计模式

当想要对已有的对象进行功能增强时，可以定义类，将已有对象传入，基于已有的功能，并提供加强功能。此时自定义的类可以称为装饰类。
装饰类通常会通过构造方法介绍被装饰的对象。并基于被装饰的对象的功能提供更强的功能。

class Person 
{
	public void Eat()
	{
		System.out.println("eat");
	}
}

class SuperPerson
{
	private Person p;
	SuperPerson (Person p)
	{
		this.p = p;
	}
	public void superEat()
	{
		System.out.println("superEat");
		System.out.println("smoking");
	}
}

class PersonDemo
{
	public static void main(String[] args) {
		Person p = new Person();
		//p.Eat();
		SuperPerson sp = new SuperPerson();
		sp.superEat();
	}
}

装饰类和继承的区别
装饰设计模式比继承要灵活。避免了继承体系的臃肿，而且降低了类与类之间的关系。
装饰类因为增强已有的对象，具备的功能和已有的是相同的，只不过提供了更强功能，所以装饰类和被装饰类通常都是一个体系中的。
例：

//当想要对已有的对象进行功能增强时，可以定义类，将已有对象传入，
//基于已有的功能，并提供加强功能。此时自定义的类可以称为装饰类。
class Person 
{
	public void Eat()
	{
		System.out.println("eat");

	}
}

class SuperPerson
{
	private Person p;
	SuperPerson (Person p)
	{
		this.p = p;

	}
	public void superEat()
	{
		p.Eat();
		System.out.println("superEat");
		System.out.println("smoking");
	}
}

class PersonDemo
{

	public static void main(String[] args) {
		Person p = new Person();

		//p.Eat();
		SuperPerson sp = new SuperPerson();
		sp.superEat();
	}
}