[Java知识库]二刷java基础第二十一天——Properties类，序列化和反序列化，PrintWriter类

一：Properties类

• 学习/工作
• 遇到陌生的类，Properties

二:Properties概述

继承体系：

java.lang.Object 
java.util.Dictionary<K,V> 
java.util.Hashtable<Object,Object> 
java.util.Properties

• 它的底层是Map双列集合
• 父类是HashTable

• Propertis（双列集合）

• 可以和IO流（数据）结合：（本地化的存储）
• 这个类是线程安全的：多个线程可以共享一个Properties对象，而不需要外部同步。
• 构造方法：Properties()
  创建一个没有默认值的空属性列表。
• 常用成员方法：

String getProperty(String key) 
使用此属性列表中指定的键搜索属性 
void load(InputStream inStream) 
从输入字节流读取属性列表（键和元素对）。  
void load(Reader reader) 
以简单的线性格式从输入字符流读取属性列表（关键字和元素对）。 
void store(OutputStream out, String comments) 
将此属性列表（键和元素对）写入此 Properties表中，以适合于使用 load(InputStream)方法加载到 Properties表中的格式输出流。  
void store(Writer writer, String comments) 
将此属性列表（键和元素对）写入此 Properties表中，以适合使用 load(Reader)方法的格式输出到输出字符流。 
Set<String> stringPropertyNames() 
返回此属性列表中的一组键，其中键及其对应的值为字符串，包括默认属性列表中的不同键，如果尚未从主属性列表中找到相同名称的键。

三：Properties的使用

• 构造方法

  • Properties?()
    

• 成员方法

  • setProperty?(String key, String value):添加数据
    Set<String> stringPropertyNames?() ：获取所有的键（keySet()）
    String getProperty?(String key) :通过键找值
    

• 代码演示：

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Properties;
import java.util.Set;

public class 读取properties文件 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Properties p = new Properties(); //继承父类为hashtable 是双列集合
		
		/*
load(InputStream inStream)   字节
从输入字节流读取属性列表（键和元素对）。  
load(Reader reader) 
以简单的线性格式从输入字符流读取属性列表（关键字和元素对）。   字符

		 */
		InputStream s=null;
		try {
			 s = new FileInputStream("D:\\bc.properties");
			p.load(s);
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		finally {
			if(s!=null) {
				try {
					s.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			
		}
		
		Set<Map.Entry<Object, Object>> entrySet =p.entrySet();
		for(Map.Entry<Object, Object> str:entrySet) {
			System.out.println(str.getKey());
			System.out.println(str.getValue());
		}
		
	}

}

四：和IO流进行结合

• 将集合写入流中

  • void store?(OutputStream out, String comments) :字节流
    void store?(Writer writer, String comments) :字符流
    comments：对所存数据的描述
    

• 从流中读取集合

void load?(InputStream inStream) 从输入字节流读取属性列表（键和元素对）。  
void load?(Reader reader) 

五：序列化流和反序列化流（对象流）

序列化和反序列化的定义：

Java序列化就是指把Java对象转换为字节序列的过程

Java反序列化就是指把字节序列恢复为Java对象的过程。

序列化最重要的作用：在传递和保存对象时.保证对象的完整性和可传递性。对象转换为有序字节流,以便在网络上传输或者保存在本地文件中。

反序列化的最重要的作用：根据字节流中保存的对象状态及描述信息，通过反序列化重建对象。

总结：核心作用就是对象状态的保存和重建。（整个过程核心点就是字节流中所保存的对象状态及描述信息）

六：ObjectOutputStream

java.lang.Object 
java.io.OutputStream 
java.io.ObjectOutputStream

• 将对象写入到文件中

• 使用

• 构造方法

•   ObjectOutputStream(OutputStream out) :创建一个写入指定的OutputStream的ObjectOutputStream。 
  

• 成员方法

void write(byte[] buf) 
写入一个字节数组。  
void write(byte[] buf, int off, int len) 
写入一个子字节数组。  
void write(int val) 
写一个字节。  
void writeBoolean(boolean val) 
写一个布尔值。  
void writeByte(int val) 
写入一个8位字节。  
void writeBytes(String str) 
写一个字符串作为字节序列。  
void writeChar(int val) 
写一个16位的字符。  
void writeChars(String str) 
写一个字符串作为一系列的字符。  
protected void writeClassDescriptor(ObjectStreamClass desc) 
将指定的类描述符写入ObjectOutputStream。  
void writeDouble(double val) 
写一个64位的双倍。  
void writeFields() 
将缓冲的字段写入流。  
void writeFloat(float val) 
写一个32位浮点数。  
void writeInt(int val) 
写一个32位int。  
void writeLong(long val) 
写一个64位长  
void writeObject(Object obj) 
将指定的对象写入ObjectOutputStream。

    Serializable：标志；如果实现了该接口，就意味着子类具备了序列化

序列化运行时使用一个称为 serialVersionUID 的版本号与每个可序列化类相关联，该序列号在反序列化过程中用于验证序列化对象的发送者和接收者是否为该对象加载了与序列化兼容的类。

七：ObjectInputStream

• 构造方法：

ObjectInputStream(InputStream in) 
创建从指定的InputStream读取的ObjectInputStream

• 成员方法：

int read() 
读取一个字节的数据。  
int read(byte[] buf, int off, int len) 
读入一个字节数组。  
boolean readBoolean() 
读取布尔值。  
byte readByte() 
读取一个8位字节。  
char readChar() 
读一个16位字符。  
float readFloat() 
读32位浮点数。  
void readFully(byte[] buf) 
读取字节，阻塞直到读取所有字节。  
void readFully(byte[] buf, int off, int len) 
读取字节，阻塞直到读取所有字节。  
int readInt() 
读取一个32位int。  
DataInputStream。  
long readLong() 
读64位长。  
Object readObject() 
从ObjectInputStream读取一个对象 

• 找的是.class文件
• 类的串行版本 ：class 的身份证

八：关键字 transient

• 当我们序列化时，某个对象属性不想参与进去；

private transient int age;  序列化时就为0
private String name;      transient 序列化就会为null

• 代码演示：
  对象类

import java.io.Serializable;

public class Student对象 implements Serializable {

	//只有实现了Serializable或者Externalizable接口的类的对象才能被序列化为字节序列
	private int age;
	//private transient int age;  序列化时就为0
	private String name;      //transient 序列化就会为null
//	public int ss;
//	public int code;
//	public int id;
	//public static final long serialVersionUID = 1980596043305313649l;
	public Student对象() {
		
	}
	public Student对象(int age, String name) {
		
		this.age = age;
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student对象 other = (Student对象) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	@Override
	public String toString() {
		return "Student对象 [age=" + age + ", name=" + name + "]";
	}
	
	
	
}

序列化:

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

public class 序列化标准写法 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Student对象 s1 = new Student对象(188,"toms");
		OutputStream o = null;
		ObjectOutputStream os=null;
		try {
			o = new FileOutputStream("d:\\x.txt");
			 os = new ObjectOutputStream(o);
			os.writeObject(s1);
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			if(os!=null) {
				try {
					os.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			
		}
		
		
	}

}

反序列化

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

public class 反序列 {

	public static void main(String[] args) throws IOException, ClassNotFoundException {
		// TODO Auto-generated method stub

		
		InputStream i = new FileInputStream("d:\\x.txt");
		
		ObjectInputStream  oi = new ObjectInputStream(i);
		
		Student对象 s1=(Student对象) oi.readObject();  //强转类型后才可以去调用自己类中的方法。
		//System.out.println(s1.getAge()+s1.getName());
		System.out.println(s1);
		oi.close();
		i.close();
	}
  //结论： 序列化最终源码显示是找.class文件
	//类对象一旦发生改变，甚至加个空格 ，他的.class文件就会改变 ，这样他的classID号就会发生改变 ，就不能再次反序列化，
	//为此我们需要在类对象中定义一个静态最终变量public static final long serialVersionUID = 1980596043305313649l;
	//这就我们就把ID给固定住了，我们再次反序列化的时候就可以不用再次生成新的ID号，就可以根据这个固定的ID号找到这个.class文件
	//而序列化则不需要
}

九：打印流

java.lang.Object 
java.io.Writer 
java.io.PrintWriter 

• 更加方便的输出各种i形式的数据
• 字节打印流 : PrintStream
• 字符打印流：PrintWriter
• 重点学习PrintWriter类，因为他包含了全部的PrintStream的方法。
• 构造方法：

PrintWriter(File file) 
使用指定的文件创建一个新的PrintWriter，而不需要自动的线路刷新。  
PrintWriter(File file, String csn) 
使用指定的文件和字符集创建一个新的PrintWriter，而不需要自动进行线条刷新。  
PrintWriter(OutputStream out) 
从现有的OutputStream创建一个新的PrintWriter，而不需要自动线路刷新。  
PrintWriter(String fileName) 
使用指定的文件名创建一个新的PrintWriter，而不需要自动执行行刷新。  
PrintWriter(String fileName, String csn) 
使用指定的文件名和字符集创建一个新的PrintWriter，而不需要自动线路刷新。  
PrintWriter(Writer out) 
创建一个新的PrintWriter，没有自动线冲洗。  

• 成员方法：

PrintWriter append(char c) 
将指定的字符附加到此作者。 void print(char c) 
打印一个字符  
void print(char[] s) 
打印字符数组。  
void print(double d) 
打印双精度浮点数。  
void print(float f) 
打印浮点数。  
void print(int i) 
打印一个整数。  
void print(long l) 
打印一个长整数。  
void print(Object obj) 
打印一个对象。  
void print(String s) 
void print(boolean b) 
打印布尔值。  
void print(char c) 
打印一个字符  
void print(char[] s) 
打印字符数组。  
void print(double d) 
打印双精度浮点数。  
void print(float f) 
打印浮点数。  
void print(int i) 
打印一个整数。  
void print(long l) 
打印一个长整数。  
void print(Object obj) 
打印一个对象。  
void print(String s) 
打印字符串。  
PrintWriter printf(Locale l, String format, Object... args) 
使用指定的格式字符串和参数将格式化的字符串写入该writer的方便方法。  
PrintWriter printf(String format, Object... args) 
使用指定的格式字符串和参数将格式化的字符串写入该writer的方便方法。  
void println() 
通过写入行分隔符字符串来终止当前行。  
void println(boolean x) 
打印一个布尔值，然后终止该行。  
void println(char x) 
打印一个字符，然后终止该行。  
void println(char[] x) 
打印字符数组，然后终止行。  
void println(double x) 
打印双精度浮点数，然后终止行。  
void println(float x) 
打印一个浮点数，然后终止该行。  
void println(int x) 
打印一个整数，然后终止该行。  
void println(long x) 
打印一个长整型，然后终止行。  
void println(Object x) 
打印一个对象，然后终止该行。  
void println(String x) 
打印一个字符串，然后终止行。  
protected void setError() 
表示发生错误。  
void write(char[] buf) 
写入一个字符数组。  
void write(char[] buf, int off, int len) 
写一个字符数组的一部分。  
void write(int c) 
写一个字符  
void write(String s) 
写一个字符串  
void write(String s, int off, int len) 

代码演示

import java.io.IOException;
import java.io.PrintWriter;

public class 打印流 {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub

		
		PrintWriter p = new PrintWriter("D:\\a.txt");
		p.print("无敌");
		p.print(123);
		p.close();
	}

}