Java基础46类对象流Serializable接口 RandomAccessFile

对象流

当创建对象时,程序运行时它就会存在,但是程序停止时,对象也就消失了.但是如果希望对象在程序不运行的情况下仍能存在并保存其信息，将会非常有用，对象将被重建并且拥有与程序上次运行时拥有的信息相同。可以使用对象的序列化。

对象的序列化： 将内存中的对象直接写入到文件设备中
对象的反序列化： 将文件设备中持久化的数据转换为内存对象

基本的序列化由两个方法产生：一个方法用于序列化对象并将它们写入一个流，另一个方法用于读取流并反序列化对象。

对象序列化：

1.声明类实现了Serializable接口。是一个标示器，没有要实现的方法。
2.新建对象。
3.新建字节流对象（FileOutputStream）进序列化对象保存在本地文件中。如果没有该文件，利用输入流
4.新建ObjectOutputStream对象，调用writeObject方法序列对象。
5.writeObject方法会执行两个工作：序列化对象，然后将序列化的对象写入文件中。
6.异常处理和流的关闭动作要执行。

Serializable接口

类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。

可序列化类的所有子类型本身都是可序列化的——父类有系列化接口实现，那么子类都可以序列化

序列化接口没有方法或字段，仅用于标识可序列化的语义。
所以需要被序列化的类必须是实现Serializable接口，该接口中没有描述任何的属性和方法，称之为标记接口。
如果对象没有实现接口Serializable，在进行序列化时会抛出：NotSerializableException 异常。

简单地说，就是可以将一个对象(标志对象的类型)及其状态转换为字节码，保存起来（可以保存在数据库，内存，文件等）,然后可以在适当的时候再将其状态恢复(也就是反序列化)

serialVersionUID

serialVersionUID适用于Java的序列化机制。简单来说，Java的序列化机制是通过判断类的serialVersionUID来验证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体类的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常，即是InvalidCastException。

序列化之前的类型与序列化之后的类型要一致

练习：模拟用户注册，将注册根据用户名字来写入到文件，下次登录的时候进行，读取对应的文件来判断是否正确

RandomAccessFile

一个可以读写一体的类，而且可以随意访问文件位置。

在API手册的解释是: 这个类的实例支持对随机存取文件的读和写。

这个类在很多资料上翻译成中文都是：随机访问文件，在中文里，随机是具有不确定的含义，指一会访问这里，一会访问那里的意思。
如果以这种语义来解释的话，就会感到很困惑。其实，Random在英文中不仅仅有随机，还有任意的意思。
如果中文名为任意访问文件是不是就会更好的理解。任意表示我们可以指定文件中任何一个位置去操作一个文件。

它的父类是Object，没有继承字节流、字符流家族中任何一个类。并且它实现了DataInput、DataOutput这两个接口，也就意味着这个类既可以读也可以写。

RandomAccessFile：可以访问文件随意位置，并且可以有读写功能

存在的意义

1、是JAVA I/O流体系中功能最丰富的文件内容访问类，它提供了众多方法来访问文件内容。
2、由于可以自由访问文件的任意位置，所以如果需要访问文件的部分内容，RandomAccessFile将是更好的选择。
3、可以用来访问保存数据记录的文件，文件的记录的大小不必相同，但是其大小和位置必须是可知的。

RandomAccessFile的构造函数mod的值作用：

值	内容
r	以只读方式打开。调用结果对象的任何 write 方法都将导致抛出 IOException。
rw	打开以便读取和写入。只有关闭流的时候才同步内容
rws	打开以便读取和写入。相对于 “rw”，“rws” 还要求对“文件的内容”或“元数据（文件信息）”的每个更新都同步写入到基础存储设备。
rwd	打开以便读取和写入，相对于 “rw”，“rwd” 还要求对“文件的内容”的每个更新都同步写入到基础存储

避免乱码，使用writeUTF modified UTF-8 编码以与机器无关的方式将一个字符串写入该文件，这个方法就是将字符串写入文件，而且不用担心会出现乱码，因为使用的编码方式是UTF-8

Class1:hw

public class Test1 {
	public static void main(String[] args) {
		// 复制一份文件，使用reader writer
		// 创建好了2个通道了， //FileReader：字节流+字符集编码、如果字符集编码不对应的时候，就会出现乱码问题
		Reader reader = null;
		Writer writer = null;
		try {
			reader = new FileReader("D:\\TestDic\\aa.txt");
			writer = new FileWriter("D:\\TestDic\\aa2.txt");
			// 读取数据，比并且写入数据
			int i = 0;
			char[] cs = new char[1024];
			while ((i = reader.read(cs)) != -1) {
//				System.out.println(new String(cs, 0, i));
				// 写入文件
				writer.write(cs, 0, i);

			} // read()读取一次文件数据，返回int：一次能读到多少内容， 0-1024，如果什么都读不到就返回-1（就代表读取完了）。

		} catch (FileNotFoundException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		} // 新建的文本文件.txt 默认使用的系统的gb2312
		catch (IOException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		} finally {
			try {
				if (writer != null) {
					writer.flush();
					writer.close();
				}
				if (reader != null) {
					reader.close();
				}
			} catch (Exception e) {
				// TODO: handle exception
				e.printStackTrace();
			}

		}

	}

}

Class2:字节流转为字符流完成转码

public class Test1 {
	public static void main(String[] args) {
		// 复制一份文件，使用reader writer
		// 创建好了2个通道了， //FileReader：字节流+字符集编码、如果字符集编码不对应的时候，就会出现乱码问题
		Reader reader = null;
		Writer writer = null;
		try {

			// FileReader 是字符流：出现乱码问题
			// FileReader使用的字符集编码是程序文件的编码集、原本的编码集是gbk，所以我们读取文件是utf-8的时候、编码集不一致、出现了乱码（编码集==字符集编码)
			// 出现乱码情况原因是：字符集编码不一致，解决方案：把字符集编码设置为一致就可以了

			// FileReader,没有字符集的设置，使用的字符集是默认的

			// 可以使用这种方式，改变读取文件的字符集编码：使用字节流获取文件，在设置字符集编码
			// 就要用到字节流和字符流
			InputStream inputStream = new FileInputStream("D:\\TestDic\\aa.txt");
			// 再设置流的字符集编码（就是把字节流转为字符流）InputStreamReader
			Reader reader2 = new InputStreamReader(inputStream,"utf-8");//charsetName:字符集编码的名字，传入一个编码名
			
			

			reader = new FileReader("D:\\TestDic\\aa.txt");
			writer = new FileWriter("D:\\TestDic\\aa2.txt");
			// 读取数据，比并且写入数据
			int i = 0;
			char[] cs = new char[1024];
			while ((i = reader2.read(cs)) != -1) {
				System.out.println(new String(cs, 0, i));
				// 写入文件
//				writer.write(cs, 0, i);

			} // read()读取一次文件数据，返回int：一次能读到多少内容， 0-1024，如果什么都读不到就返回-1（就代表读取完了）。

		} catch (FileNotFoundException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		} // 新建的文本文件.txt 默认使用的系统的gb2312
		catch (IOException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		} finally {
			try {
				if (writer != null) {
					writer.flush();
					writer.close();
				}
				if (reader != null) {
					reader.close();
				}
			} catch (Exception e) {
				// TODO: handle exception
				e.printStackTrace();
			}

		}

	}

}

Class3:序列化与反序列化
Person

import java.io.Serializable;

//1.声明类
//2.实现了Serializable接口，序列化接口
//Serializable，就是一个标识，标识Person类型可以进行序列化
public class Person implements Serializable {// 没有要求实现任何方法

	private String name;
	private int age;
	private String sex;

	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 getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}
}

Test1:序列化

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

public class Test1 {

	public static void main(String[] args) {
		// 对象流（对象的序列化）
		// 程序运行的时候，创建的对象，是程序运行完成之后，就没有的
		// 现在我们想要保存程序中创建的对象，是可以的，我们可以使用对象流（对象的序列化），进行保存

		FileOutputStream fileOutputStream = null;
		ObjectOutputStream objectOutputStream = null;
		try {
			// 怎么实现对象的序列化
			// 序列化对象的步骤：
			// 1.声明类实现了Serializable接口。是一个标示器，没有要实现的方法。Person

			// 2.新建对象。
			Person person = new Person();
			person.setName("jason");
			person.setAge(20);
			person.setSex("男");

			// 3.新建字节流对象（FileOutputStream）进序列化对象保存在本地文件中。如果没有该文件，利用输入流

			fileOutputStream = new FileOutputStream("D:\\TestDic\\Test\\Person.txt");// 文件输出流，文件路径

			// 4.新建ObjectOutputStream对象，调用writeObject方法序列对象。
			objectOutputStream = new ObjectOutputStream(fileOutputStream);

			// 5.writeObject方法会执行两个工作：序列化对象，然后将序列化的对象写入文件中。
			objectOutputStream.writeObject(person);// 参数就是把对象序列化

		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			// 6.异常处理和流的关闭动作要执行。

			try {

				// 要记得判断对象是否为空
				if (objectOutputStream != null) {
					objectOutputStream.flush();// 刷新，没有判断这里就可能出现空指针异常
					objectOutputStream.close();// 关闭
				}

				if (fileOutputStream != null) {
					fileOutputStream.flush();
					fileOutputStream.close();
				}
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

			// 流程就是把对象序列化，存储到文件中

			// 反序列化，就可以获取到里面的内容了

			// 序列化，就是保存对象的内容、以后的话，序列化还可以用来进行互联网传输对象
			
//			对象的序列化：   将内存中的对象直接写入到文件设备中
//			对象的反序列化： 将文件设备中持久化的数据转换为内存对象
//
//			基本的序列化由两个方法产生：一个方法用于序列化对象并将它们写入一个流，另一个方法用于读取流并反序列化对象。

		}

	}
}

Test2:反序列化

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

public class Test2 {

	public static void main(String[] args) {

		// 反序列化//代码内容和序列化基本一样，就是用的对象不同了而已；
		FileInputStream fileInputStream = null;
		ObjectInputStream inputStream = null;
		try {
			// 对象序列化：

			// 1.声明类实现了Serializable接口。是一个标示器，没有要实现的方法。
			// 注意：序列化，与反序列化的类型要用相同的

			// 3.新建字节流对象（FileOutputStream）进序列化对象保存在本地文件中。如果没有该文件，利用输入流//写出数据，现在需要的是读取数据

			fileInputStream = new FileInputStream("D:\\TestDic\\Test\\Person.txt");
			// 4.新建ObjectOutputStream对象，调用writeObject方法序列对象。//ObjectInputStream返修乐华
			inputStream = new ObjectInputStream(fileInputStream);

			// 5.writeObject方法会执行两个工作：序列化对象，然后将序列化的对象写入文件中。//读取对象
			Object object = inputStream.readObject();

			if (object instanceof Person) {
				Person person = (Person) object;
				System.out.println(person.getName());
				System.out.println(person.getAge());
			}
			// 6.异常处理和流的关闭动作要执行。
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			// 要记得判断对象是否为空

			try {
				if (fileInputStream != null) {
					fileInputStream.close();
				}
				if (inputStream != null) {
					inputStream.close();
				}
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} // 关闭

		}

	}
}

Class4:RandomAccessFile，以访问文件随意位置，并且可以有读写功能

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

public class Test1 {
	public static void main(String[] args) {
		// RandomAccessFile
		RandomAccessFile accessFile = null;
		try {
			accessFile = new RandomAccessFile("D:\\TestDic\\Test\\新建文本文档.txt", "rws");
			// 移动指针下标
			// 啊师傅飒飒撒撒旦撒的撒dsa01但是啊 2312312231231231
			// 撒dsa01但是啊 2312312231231231
			accessFile.seek(0);

			int i = 0;
			byte[] bs = new byte[1024];
			while ((i = accessFile.read(bs)) != -1) {
				System.out.println(new String(bs, 0, i));
			}

			accessFile.writeUTF("我是超级靓仔");
//			String string = accessFile.readLine();// Line读一行内容
//			System.out.println(new String(string.getBytes(),"gb2312"));
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			if (accessFile != null) {
				try {
					accessFile.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
}