文件（四）（合并流，随机流，序列化）

合并流:将多个相同格式和相同编码的文件合并到一起，就要使用到合并流
1、创建字节输入流(多个文件)
2、创建集合(vector)，添加字节输入流
3. 获取迭代器,创建合并流对象
4. 创建字节输出流用于输出合并之后的内容到文件中
5. 使用合并流来读取数据，使用字节输出流输出数据
6.关流

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
import java.util.Vector;

public class SequenceDemo {
	public static void main(String[] args) throws IOException {
		// 创建字节输入流
		FileInputStream fis1 = new FileInputStream("F:\\a.txt");
		FileInputStream fis2 = new FileInputStream("F:\\b.txt");
		FileInputStream fis3 = new FileInputStream("F:\\c.txt");
		FileInputStream fis4 = new FileInputStream("F:\\d.txt");
		// 创建集合
		Vector<FileInputStream> vector = new Vector<>();
		// 添加需要合并的流
		vector.add(fis1);
		vector.add(fis2);
		vector.add(fis3);
		vector.add(fis4);
		
		// 获取迭代器 并创建合并流对象
		SequenceInputStream sis = new SequenceInputStream(vector.elements());
		
		// 创建字节输出流
		FileOutputStream fos = new FileOutputStream("F:\\502.txt");
		
		// 创建字节数组用作缓冲区
		byte[] bys = new byte[5];
		// 定义长度
		int len;
		while ((len = sis.read(bys)) != -1){
			// 表示读取到了内容
			fos.write(bys, 0, len);
		}
		fos.close();
		sis.close();
	}
}

随机获取流
r ：读
rw :读写
rws:读写并保存到硬盘
rwd:读写并保存到硬盘，立即保存
rwd模式比rws模式的效率低，但是更安全
随机获取流底层将文件看作一个大型的字节数组，里面有一个索引，
默认从0索引开始向后读写(双向流).如果读取失败，结果是-1

import java.io.IOException;
import java.io.RandomAccessFile;

public class RandomDemo {
	public static void main(String[] args) throws IOException {
		// 创建随机获取流对象
		RandomAccessFile raf = new RandomAccessFile("F:\\b.txt", "rw");
		// 随机获取流是将文件内容看做一个字节数组
		// 默认是从字节数组的0索引开始向后写
		// 需要存放的是字节数组
		// [1,2,3,d...]
		raf.write("123".getBytes());
		// 本次写入的索引是上一次写入的索引后一位
		raf.write("4".getBytes());
		// 设置索引
		raf.seek(0);
//		raf.write("abc".getBytes());
		// 向后跳跃索引
		raf.skipBytes(4);
		System.out.println((char)raf.read());
		// 关流
		raf.close();
	}
}

序列化：将对象转换为字节数组。从而在网络中进行传输
反序列化：将字节数组转换为对象。方便程序员开发使用。

java.io.NotSerializableException: cn.tedu.code02.Person
这个异常表示类不能被序列化
java规定，能够序列化的类必须实现接口Serializable.这个接口是一个空接口，只是对要序列化的类做了一个标记。
一旦有这个标记，就表明可以被序列化。

static修饰的内容不能被序列化:static修饰是所有对象共享的，序列化没有实际意义。

Transient修饰的内容被强制性规定不能序列化。

stream classdesc serialVersionUID = -746338140338775312,
local class serialVersionUID = -6019822729399143338
serialVersionUID不相等:
每一个需要序列化的类都有一个serialVersionUID。java会根据类中的属性和方法生成一个serialVersionUID。也可以手动指定。
生成UID后类中的代码一旦改变，那么意味者类的UID会重新计算，就会改变。
生成的UID会和类中其他内容一个序列化，当反序列化时会拿类中的新的UID和序列化中内容的UID进行比较。如果相等，允许反序列化，如果不相等，就抛异常。

集合和映射都不能被序列化(有一个序列化没有意义)，那么如果想要使用集合或者映射进行序列化时，只能通过遍历形式一个一个的序列化，反序列化相同。

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Vector;

public class SerialDemo {
	public static void main(String[] args) throws IOException, ClassNotFoundException {
		
		// 将对象转换为字节数组
//		Person p = new Person();
//		p.setName("周杰伦");
//		p.setAge(39);
//		
//		// 序列化 
//		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("p.data"));
//		oos.writeObject(p);
//		oos.close();
		
//		// 反序列化
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("p.data"));
		Person p1 = (Person)ois.readObject();
		ois.close();
		System.out.println(p1.getAge());
		System.out.println(p1.getName());
	
	}
}

class Person implements Serializable{
	/**
	 * 
	 */
	private static final long serialVersionUID = -6019822729399143338L;
	private String name;
	private int age;
	static int classroom = 502;
	transient double height;
	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;
	}
	
}