文件流

流

流根据方向不同分为输入流与输出流，参照点为当前程序。
输入流用来读取数据，输出流用来写出数据。
java.io.InputStream
抽象类，定义了输入流的读取字节方法，所有的字节输入流都继承自它
java.io.OutputStream则是所有字节输出流的父类

流分为节点流和处理流
节点流，也叫低级流，是真是负责读写数据的流
读写操作中必须要有低级流，数据源明确
处理流，也叫高级流，读写可以没有高级流，高级流也不能独立存在，必须用于处理其他流，处理其他流的目的是简化读写数据中的操作。

java.io.FileOutputStream
文件输出流，是一个低级流，作用是向文件中写出字节
eg:

/*
* 默认创建的FOS是覆盖写操作
* FOS会先将文件数据(若有数据)全部删除，然后再开始写。
*/
FileOutputStream fos = new FileOutputStream("fos.txt");

String str = "我爱北京天安门";
/*
 * String->byte[]
 * 
 * byte getBytes()
 * 将当前字符串按照系统默认字符集转换为一组字节
 * 
 * byte getBytes(String csn)
 * 按照给定的字符集将当前的字符串转换为一组字节
 */
byte[] data = str.getBytes("utf-8");

fos.write(data);
System.out.println("写出完毕!");

fos.close();

/*
* 在创建FOS时，若指定第二个参数，并且该值为true时，则是追加写操作，
* 那么本次通过FOS写出的内容会被追加到文件末尾。
*/
FileOutputStream fos = new FileOutputStream("fos.txt",true);
fos.write("天安门上太阳升".getBytes("utf-8"));
System.out.println("写出完毕!");
fos.close();

java.io.FileInputStream
文件输入流，是一个低级流，用于从文件中读取字节
eg:

FileInputStream fis = new FileInputStream("fos.txt");
byte[] data = new byte[100];
int len = fis.read(data);
String str = new String(data,0,len,"utf-8");
System.out.println(str);
fis.close();

对象流
对象流是一对高级流，作用是方便读写java中的对象。
java.io.ObjectOutputStream
对象输出流，可以将给定的对象转换为一组字节后写出。
eg:

/**
 * 该类用于测试作为对象流读写对象使用
 * 当一个类需要被对象流读写，那么该类必须实现java.io.Serializable接口
 */
public class Person implements Serializable {
	/**
	 * 当一个类实现了Serializable接口后应当添加一个常量:serialVersionUID
	 * 该常量为当前类的序列化版本号，若不定义，系统会根据当前类的结构生成，
	 * 但是只要类的结构发生变化，版本号也会相应发生改变。
	 * 
	 * 版本号影响着反序列化的结果，即：
	 * 当OIS对一个对象进行反序列化时，会检查该对象与类的版本是否一致:
	 * 若一致:反序列化成功，但是若该对象与类的机构不一致时，则采用兼容模式，能还原的属性都还原。
	 * 若不一致:反序列化直接抛出版本不一致异常
	 */
	private static final long serialVersionUID = 1L;
	private String name;
	private int age;
	private String gender;
	private transient List<String> otherInfo;
	/*
	 * transient关键字用来修饰属性
	 * 当被修饰后，该类实例在使用OOS进行对象序列化时，该属性值被忽略
	 * 从而达到对象"瘦身"的目的
	 */
	public Person() {
		
	}

	public Person(String name, int age, String gender, List<String> otherInfo) {
		super();
		this.name = name;
		this.age = age;
		this.gender = gender;
		this.otherInfo = otherInfo;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getGender() {
		return gender;
	}

	public void setGender(String gender) {
		this.gender = gender;
	}

	public List<String> getOtherInfo() {
		return otherInfo;
	}

	public void setOtherInfo(List<String> otherInfo) {
		this.otherInfo = otherInfo;
	}
	
	public String toString() {
		return name+","+age+","+gender+","+otherInfo;
	}
}

public static void main(String[] args) throws IOException {
		Person p = new Person();
		p.setName("王潇洒");
		p.setAge(20);
		p.setGender("男");
		
		List<String> otherInfo = new ArrayList<String>();
		otherInfo.add("是一名演员");
		otherInfo.add("爱好是跳舞");
		otherInfo.add("帅气英俊潇洒");
		otherInfo.add("低调奢华有内涵");
		p.setOtherInfo(otherInfo);
		
		FileOutputStream fos = new FileOutputStream("person.obj");
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		/*
		 * ObjectOutputStream的writeObject方法可以将给定对象转换为一组字节后写出。
		 * 这些字节比该对象实际内容要大，因为除了数据外还有结构等描述信息
		 * 
		 * 下面的代码实际上经历了两个操作:
		 * 1:oos将Person对象转换为一组字节
		 *   将一个对象转换一组字节的过程称为:对象序列化
		 *   
		 * 2:再通过fos将这组字节写入到硬盘
		 *   将该对象转换的字节写入到硬盘做长久保存的过程称为:对象持久化
		 */
		oos.writeObject(p);
		System.out.println("写出对象完毕!");
		oos.close();
}

java.io.ObjectInputStream
对象输入流，作用是可以进行对象反序列化，读取一组字节并还原对象。
ObjectInputStream读取的字节必须是由ObjectOutputStream将对象序列化得到的字节，否则会抛出异常。
eg:

FileInputStream fis = new FileInputStream("person.obj");
ObjectInputStream ois = new ObjectInputStream(fis);
//对象反序列化
Person p = (Person)ois.readObject();
System.out.println(p);
ois.close();

缓存流
java.io.BufferedInputStream
java.io.BufferedOutputStream
缓存字节输入输出流是一对高级流，使用它们可以加快读写效率
高级流可以处理其他流，但是无论添加了多少高级流，最底下都要有低级流，因为低级流是真实读写数据的流，高级流都是处理数据的。
高级流处理其他流就形成了流的链接，并且有效的组合不同的高级流可以得到叠加的效果。
缓存流内部有一个缓冲区，BufferedInputStream会一次性读取一组字节并存入内部的字节数组中，然后将第一个字节返回，当再次调用read方法时，BufferedInputStream直接从字节数组中将第二个字节返回，直到字节数组中所有字节全部返回后，才会再次读取一组字节。 所以缓冲流也是依靠提高一次读写的数据量减少读写次数来达到提高读写效率的。
缓冲输出流写出数据的缓冲区问题

FileOutputStream fos = new FileOutputStream("bos.txt");
		
BufferedOutputStream bos = new BufferedOutputStream(fos);

bos.write("呵呵".getBytes("UTF-8"));
//强制将缓冲区中的字节一次性写出
bos.flush();
System.out.println("写出完毕！");

bos.close();

字符流
字符流的读写单位为字符，字符流都是高级流，虽然以字符为单位读写数据，但是实际底层还是读写字节，只是从字节与字符的转换工作交给了字符流来完成。
java.io.Reader:字符输入流的顶级父类
java.io.Writer:字符输出流的顶级父类

转换流
java.io.OutputStreamWriter
特点是可以按照指定的字符集写出字符
java.io.InputStreamReader
字符输入流，可以按照给定的字符集读取字符

之所以称OutputStreamWriter与InputStreamReader为转换流，是因为大多数的字符流都只处理其他字符流，而低级流又是字节流，这就是导致字符流不能处理字节流的问题，转换流相当于是一个转换器的作用，它们可以将字节流先转换为字符流，这样其他的字符流就可以处理了。

FileOutputStream fos = new FileOutputStream("osw.txt");
OutputStreamWriter osw = new OutputStreamWriter(fos,"UTF-8");
osw.write("我爱北京天安门");
osw.write("天安门上太阳升");

System.out.println("写出完毕！");
osw.close();

FileInputStream fis = new FileInputStream("osw.txt");
InputStreamReader isr = new InputStreamReader(fis,"utf-8");

int d = -1;
while((d = isr.read())!=-1) {
	System.out.print((char)d);
}
isr.close();

缓冲字符流
BufferedWriter,BufferedReader
特点是可以按行读写字符串
缓冲字符输入流
java.io.BufferedReader
特点:按行读取字符串
java.io.BufferedWriter
缓存字符输出流
特点：按行写入字符串

FileInputStream fis = new FileInputStream("src/day08/BRDemo.java");
InputStreamReader isr = new InputStreamReader(fis);
BufferedReader br = new BufferedReader(isr);

/*
 * BufferedReader提供了按行读取方法:
 * String readLine()
 * 连续读取若干字符，直到读取到换行符为止，
 * 并将换行符之间读取的字符以一个字符串返回。
 * 若返回值为NULL，则表示读取到末尾。
 * 注意:该字符串不包含最后的换行符
 */
String line = null;
while((line = br.readLine())!=null) {
 System.out.println(line);
}

br.close();
	

java.io.printWriter
具有自动行刷新的缓冲字符输出流
创建PW时，它一定会在内部创建BufferedWriter作为缓冲功能的叠加

/*
 * 提供了多种构造方法
 * 其中有两个可以直接对文件进行写出操作的构造方法:
 * 
 * PrintWriter(File file)
 * PrintWriter(String path)
 */
 PrintWriter pw = new PrintWriter("pw.txt","utf-8");

 pw.println("锄禾日当午");
 pw.println("清明上河图");

 System.out.println("写出完毕!");
 pw.close();
	

PrintWriter也提供了可以处理其他流的构造方法
提供的方法可以传入字节流，也可以处理字符流，并且，当时用这类构造方法时，可以再传入第二个参数，该参数为boolean值，该值为true时，则具有了自动行刷新功能。

FileOutputStream fos = new FileOutputStream("pw1.txt");
OutputStreamWriter osw = new OutputStreamWriter(fos,"utf-8");
PrintWriter pw = new PrintWriter(osw);

pw.println("呵呵");
pw.print("嘿嘿");
System.out.println("写出完毕!");
pw.close();