java对象的序列化&流

对象序列化

把对象以流的形式修路到文件中保存，也叫对象的序列化
对象中包含的不仅仅是字符，使用字节流
ObjectOutputStream : 对象的序列化流
把文件中保存的对象，以流的方式读取出来，叫做读对象，也叫对象的反序列
读取的文件保存的都是字节，所以使用字节流
ObjectInputStream : 对象的反序列化
使用Object类型来接收
java.io.ObjectOutputStream extends OutputStream
ObjectOutputStream 对象的序列化流
把对象以流的方式写入到文件中进行保存
构造方法
ObjectOutputStream(OutputStream out)
创建写入指定OutputStream的ObjectOutputStream
参数
OutputStream out 字节输出流
特有的成员方法
void writerObject(Object obj) 将指定的对象写入ObjectOutPutStream
使用
创建
使用方法writerObject把对象写入文件
释放资源
类通过 java.io.Serializable接口以启用此序列化
=========================

public class ObjectFile {
	//对象的序列化
	public static void main(String[] args) throws IOException {
		ObjectOutputStream oos = new ObjectOutputStream(new 
				FileOutputStream("D:\\1907testjava\\day01\\person.txt"));
		//创建对象需要new
		oos.writeObject(new Person("张三",24));
		oos.close();//NotSerializableException没有序列化异常
	}

}
------------------------------------
 * 	对象的反序列化流
 * 	java.io.ObjectInputStream extends InputStream
 *  	ObjectInputStream:对象的反序列化流
 *  	把文件保存的对象，以流的方法读取出来使用
 * 		构造方法
 * 			ObjectInputStream(InputStream in)
 * 				创建从指定InputStream读取ObjectInputStream
 * 		参数
 * 			InputStream in
 * 		特有的成员方法
 * 			Object readObject() 从ObjectInputStream读取对象
 * 			
 * 		使用
 * 			创建，构造方法中传递字节输入流
 * 			使用方法readObject读取保存对象文件
 * 			释放资源
 * 			使用读取出来的对象打印
 * 		反序列化
 * 			必须实现Serializable	
 * 			必须存在类对应的class文件
--------------------------
public class ObjectInputStreamDemo {
	public static void main(String[] args) throws Exception {
		ObjectInputStream ois = new ObjectInputStream(new 
				FileInputStream("D:\\1907testjava\\day01\\person.txt"));
		Object o = ois.readObject();
		ois.close();
		//打印输出
		System.out.println(o);
		Person p = (Person)o;//强转一下
		System.out.println(p.getName()+p.getAge());
	}
}

-------------------------------
* 	序列化和反序列化会抛出NotSerializableException没有序列化异常
 * 	类通过 java.io.Serializable接口以启用此序列化
 * 		标记型接口
 * 		要进行序列化和反序列化的的类必须实现Serializable接口，就会给类添加一个标记
 * 		当我们进行序列化和反序列化的时候就会检测类上是否有这个标记
 * 			有就可以进行
 * 			没有就会抛出异常
 * 
 * 		static 关键字
 * 			静态优先于非静态加载到内存中（静态优先于对象加载到内存中）
 * 			被static修饰的成员变量，不能被序列化，序列化的都是对象
 * 		transient 关键字，瞬态关键字
 * 			功能和静态差不多，但是没有静态的含义
 * 			被这个关键字休修饰的成员变量，不能被序列化
 * 
 * 		序列号每次运行都会生成新的class，修改代码会使序列化产生异常，class文件和txt文件的序列号不同
 * 			防止这种异常手动给类添加一个序列化
 * 			Serializable:
 * 				static final long serialVersionUID = 
 -------------------------------------
 //实现这个标记型接口
public class Person implements Serializable{
	//添加序列号42L，可以自己修改
	static final long serialVersionUID = 42L;
	
	private String name;
//	private static int age;//如果被static修饰，则这个age不能被序列化，读出来是0
//	private  int age;//
	private transient int age;//如果被transient修饰，则这个age不能被序列化，读出来是0
	
	public Person() {
		super();
	}
	
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

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

	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	
	
}
-------------------------------
import java.io.FileNotFoundException;
import java.io.PrintStream;

/*
 * 	打印流
 * 		java.io.PrintStream:打印流
 * 		  PrintStream为其他输出流添加了功能，使他们能够方便打印各种数据值表示形式。
 * 		只负责数据的输出，不负责数据的读取
 * 		这个流永远不会抛出IOException
 * 		有特有的方法print,println,可以输出任意类型的值
 * 	构造方法
 * 		PrintStream(File file) 输出的目的地是一个文件
 * 		PrintStream(OutputStream out) 目的地是一个字节输出流
 * 		PrintStream(String fileName) 目的地是一个文件路径
 * 	extends OutputStream
 * 		继承自父类的成员方法
 * 		如果使用继承自父类的write方法查看数据的时候会查看编码表。如果使用自己特有的方法print写数据原样输出
 * 		
 */
public class PrintFile {

	public static void main(String[] args) throws Exception {
		//打印流。
		PrintStream ps = new PrintStream("D:\\1907testjava\\day01\\print.txt");
		//使用继承自父类
		ps.write(97);//a
		ps.println(97);//97,可以输出任意类型
		ps.close();
		
	}
}
-----------------------------
import java.io.FileNotFoundException;
import java.io.PrintStream;

/*
 * 	可以改变输出语句的目的地
 * 		打印流的流向
 * 	默认在控制台输出
 * 		System类
 * 			static void setOut(PrintStream out)方法
 * 			改变输出语句的目的地为参数传递的打印流的目的地
 * 			
 */
public class PrintFile02 {

	public static void main(String[] args) throws Exception {
		System.out.println("在控制台输出");
		PrintStream ps = new PrintStream("D:\\1907testjava\\day01\\目的地.txt");
		System.setOut(ps);//改变目的地改变为打印流的目的地
		System.out.println("目的地输出");
		ps.close();
	} 
}
------------------------------
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.util.ArrayList;

/*
 * 	序列化集合
 * 		当我们想在文件中保存多个对象时
 * 		可以把对象存储到一个集合当中
 * 		对集合进行序列化和反序列化
 * 	创建集合
 * 	存储对象
 * 	创建一个序列化流
 * 	使用方法对集合进行序列化
 * 	创建一个反序列化
 * 	使用对象中的方法读取文件中保存的集合
 * 	把Object类型的集合转换为ArrayList类型
 * 	遍历集合
 * 	 释放资源	
 * 
 */
public class XuLieHuaTest {

	public static void main(String[] args) throws Exception {
		ArrayList<Person> list = new ArrayList<>();
		list.add(new Person("杨悦",18));
		list.add(new Person("张三",19));
		list.add(new Person("李四",20));
		list.add(new Person("王五",21));
		//准备流对象
		ObjectOutputStream oos = new ObjectOutputStream(new 
				FileOutputStream("D:\\1907testjava\\day01\\list.txt"));
		oos.writeObject(list);
		ObjectInputStream ois = new ObjectInputStream(new 
				FileInputStream("D:\\1907testjava\\day01\\list.txt"));
		Object o = ois.readObject();
		//把o转换为集合
		ArrayList<Person> list02 = (ArrayList<Person>)o;
		//遍历
		for (Person person : list02) {
			System.out.println(person);
		}
		ois.close();
		oos.close();
		
	}
}

=====================

转换

 * java.io.OutputStreamWriter extends Writer
 * 	  OuputStreamWriter字符通向字节的桥梁可使用指定的charset将要写入流中的字符编码成字节
 * 	  	把能看懂的变成看不懂的
 * 		继承自父类中共性的成员方法
 * 		构造方法
 * 			OutputStreamWriter(OutputStream out)
 * 				创建使用默认字符编码的OutputStreamWriter
 * 			OutputStreamWriter(OutputStream out, String charsetName)
 * 				创建使用指定字符集的OutputStreamWriter
 * 		参数:
 * 			OutputStream字节输出流，可以用来写转换之后的字节到文件中 				
 * 			charsetName指定的编码表名称，不区分大小写utf-8, UTF-8.....	
 * 		使用步骤
 * 			创建
 * 			使用对象中的方法writer,把字符转换为字节存储到缓冲区中
 * 			使用方法flush刷新
 * 			释放资源
	==========================
	public class ZhuanHuanFile {

	public static void main(String[] args) throws Exception {
//		write_utf_8();
//		write_gbk();
	}
	/*	使用转换流OutputStream写utf-8格式的文件	*/
//	private static void write_utf_8() throws Exception{
		OutputStreamWriter osw = new OutputStreamWriter(new 
//				FileOutputStream("D:\\1907testjava\\day01\\UTF_8.txt"),"utf-8");
//		//不指定默认utf-8
//		OutputStreamWriter osw = new OutputStreamWriter(new 
//				FileOutputStream("D:\\1907testjava\\day01\\UTF_8.txt"),"utf-8");
	
//		osw.write("你好");
//		osw.flush();
//		osw.close();
//	}
//	/*
//	 * 写gbk格式
//	 * 
//	 */
//	private static void write_gbk() throws Exception{
//		OutputStreamWriter osw = new OutputStreamWriter(new 
//				FileOutputStream("D:\\1907testjava\\day01\\gbk.txt"),"GBK");
//		osw.write("你好");
//		osw.flush();
//		osw.close();
//	}

}
---------------------------
 * java.io.InputStreamReader extends Readers
 * 		InputStreamReader字节流通向字符的桥梁，他指定charset读取字节并将其解码为字符
 * 			把看不懂的变成能看懂的
 * 			继承自父类的成员方法
 * 		构造方法
 * 			InputStreamReader(InputStream in)创建一个使用默认字符集的InputStreamReader
 * 			InputStreamReader(InputStream in,String charsetName)
 * 				创建一个使用指定字符集的InputStreamReader
 * 		参数
 * 			InputStream字节输入，读取文件中保存的字节
 * 			String charsetName:指定编码表名称，不区分大小写，不指定默认utf-8
 * 		使用
 * 			创建
 * 			使用
 * 			释放资源
 * 				构造方法中指定的编码表名称要和文件的编码相同否则会发生乱码
	

---

public class ZhuanHuanInputStreamReader {
	public static void main(String[] args) throws Exception {
		read_utf_8();
//		read_gbk();
	}
	//读取utf-8
	private static void read_utf_8() throws Exception{
		//utf-8读取不了，gbk可以，设置编码字符集 为utf-8
		//默认为gbk现在
		InputStreamReader isr =  new InputStreamReader(new 
				FileInputStream("D:\\1907testjava\\day01\\gbk.txt"),"utf-8");
		int len = 0;
		while((len = isr.read())!=-1){
			System.out.println((char)len);
		}
		isr.close();
	}
	//读取gbk
	private static void read_gbk() throws Exception{
		//编码表名称要和文件的名称相同，否则发生软吗
		InputStreamReader isr =  new InputStreamReader(new 
				FileInputStream("D:\\1907testjava\\day01\\gbk.txt"),"gbk");
		int len = 0;
		while((len = isr.read())!=-1){
			System.out.println((char)len);
		}
		isr.close();
	}
}

---

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;

/*
 * 	转换文件编码	
 * 		将GBK文件转换为UTF-8
 * 		查看几个字节可以看出来
 */
public class ZhuanHuanTest {

	public static void main(String[] args) throws Exception {
		InputStreamReader isr = new InputStreamReader(new 
				FileInputStream("D:\\1907testjava\\day01\\gbk.txt"),"gbk");
		OutputStreamWriter osw = new OutputStreamWriter(new 
				FileOutputStream("D:\\1907testjava\\day01\\我是uf.txt"),"utf-8");
		int len = 0;
		while((len = isr.read())!=-1){
			osw.write(len);
		}
		osw.close();
		isr.close();
	}
}