黑马程序员--javaSE--对象序列化-字符串-Properties类

------- android培训、java培训、期待与您交流！ ----------

已经12点多了，但想了一下还是将今天下午的看的内容整理完，毕竟现在的时间很紧，又要为期末考

复习，又要努力完成黑马的报名流程，想到这里突然间感觉很幸运，自己还很年轻，有精力，熬得起！

今天下午没看什么特别的java技术，只是突然间想到java中一些琐碎的知识点，就根据记忆，一边回想，

一边在晚上查资料，查jdk的帮助文档，总算有点收获，所以这边学习日记内容很杂，但对于某个知识点还是

很清晰的，嘿嘿-。。-。

一、java序列化

java的序列化技术可以将一个对象的状态写入一个字节流中，并且可以从其他地方把字节流中的数据读出来，重新构造一个相同的对象。

这种机制允许我们将对象通过网络进行传播，并可以随时把对象持久化到数据库、文件系统中。

用途：利用对象的序列化实现保存应用程序的当前工作状态，下次启动时将自动的恢复到上次执行的状态。

说白了序列化就是一种处理对象流的机制，所谓对象流就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可以将

流化后的对象传输于网络之间。序列化是为了解决在对对象进行读写操作时所引发的的问题。

java中jdk对序列化的支持：

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

可序列化类的所有子类型本身都是可序列化的。序列化接口没有方法或字段，仅用于标识可序列化的语义。

要允许不可序列化类的子类型序列化，可以假定该子类型负责保存和恢复超类型的公用 (public)、受保护的 (protected) 和（如果可访问）包 (package) 字段的状态。

仅在子类型扩展的类有一个可访问的无参数构造方法来初始化该类的状态时，才可以假定子类型有此职责。如果不是这种情况，则声明一个类为可序列化类是错误的。

该错误将在运行时检测到。

在反序列化过程中，将使用该类的公用或受保护的无参数构造方法初始化不可序列化类的字段。可序列化的子类必须能够访问无参数构造方法。可序列化子类的字段将从该流中恢复。

ObjectOutputStream 类：继承了java.io.ObjectStream类,用于定义序列化对象的类

方法：

public final void writeObject(Object obj) throws IOException --将指定的对象写入 ObjectOutputStream。

ObjectInputStream 类：继承了java.io.ObjectStream类用于定义反序列化的类。

方法：

public final void readObject(Object obj) throws IOException --readObject方法负责使用通过对应的 writeObject 方法写入流的数据，为特定类读取和恢复对象的状态。

代码实现：

package com.itheima.objectIO;

import java.io.File;
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;

public class ObjectSerializable {
	public static void main(String[] args) throws Exception {
		//创建要被序列化的对象
		User user = new User("张三","123456");
		
		//创建存储对象序列化的文件（序列化）
		File file = new File("ser.txt");
		//创建序列化的写入流
		ObjectOutputStream oot = new ObjectOutputStream(new FileOutputStream(file));
		//将对象以序列化的方式写入文件
		oot.writeObject(user);
		
		//从文件中读出被序列化的对象（反序列化）
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
		//创建序列化的输出流,从文件读出的对象类型是Object，需要将其强转为User类的对象
		User userSer = (User) ois.readObject();
		
		//测试反序列化的对象
		System.out.println("userSer的username的字段："+userSer.getUsername());
		//打印结果是 ，userSer的username的字段：张三  说明该字段序列化正常
		System.out.println("userSer的password的字段："+userSer.getPassword());
		//打印结果是，userSer的password的字段：null 因为加了transient，该字段不能被序列化
		System.out.println("userSer的password的字段："+userSer.classnum);
		//打印结果：userSer的password的字段：1 ，static修饰的字段对序列化无影响
		
		
	}
}

//定义要序列化的类，实现Serializable接口
class User implements Serializable{
	//指定serialVersionUID 字段，这样即使这个被序列化的类的机构被改变，仍可以被还原
	private static final long serialVersionUID = 1L;
	//用static修饰的字段属于整个类，不会被序列化,但对序列化无影响
	public static int classnum = 001;
	private String username;
	//添加transient关键字，这个password字段不会被序列化 
	private transient  String password;
	
	public User(String username, String password) {
		super();
		this.username = username;
		this.password = password;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	
}
           

上述代码实现的是对对象的序列化，读者如果有兴趣，可以自己测试基本数据类型的序列化。

注意点:

a.SERIALVERSIONUID属性:当序列化对象时会把这个属性写入， 当反序列化时则会把这个属性取出，然后与JAVA类中的serialVersionUID属性值对比，

如果一致，则认为是同一个版本， 正常反序列化，如果不一致则认为版本不同，抛出InvalidClassException异常。

不写这个serialVersionUID属性，但仍然可以正常序列化。 那是因为如果没有这个属性，JVM将会根据这个类的属性和方法，

计算出一个值作为serialVersionUID的值。 这种做法会带来潜在的风险。不同的JVM产生serialVersionUID的算法可能会不一致，

如果在不同的环境下产生的serialVersionUID不一致，将导致反序列化失败。

当我们对类的结构做简单的改变时，可以保持类的兼容性，但有时却不能，所以最好的处理时自己指定这个属性，而不是让他自动生成。

序列化的总结：

1. 被序列化的类要继承 Serializable 接口，如果字段中包含复杂对象，它也需要是 Serializable的。如果不需要对此字段进行序列化，声明字段时添加 transient 关键字。 

2. 最终通过 ObjectOutputStream 和 ObjectInputStream 实现。 

3. 只有非静态的字段才会被序列化，静态字段和方法对序列化的结果没有影响。 

4. 可序列化的类有个 serialVersionUID 字段，如果不去指定，它会根据非静态字段的类型和名称来生成。此ID保持一致是反序列化成功的必要条件，因此序列化和反序列化时字段不一样，就会抛出异常。

5. 当声明了指定的 serialVersionUID 时，反序列化时便不做全部字段匹配的校验，并遵循如下原则：

例如，序列化时 class A { int b; }，反序列化时 class A { int c; }则无法识别的字段b不会被读取，新增的字段c会被赋予默认的值0，不会抛出异常。

二、 String,StringBuffer与StringBuilder

String类：String的值是不可变的，这就导致每次对String的操作都会生成新的String对象，不仅效率低下，而且大量浪费有限的内存空间。

我们对String的操作都是改变复制地址而不是改变值操作。

String类和字符串常量池：

二、 String,StringBuffer与StringBuilder

String类：String的值是不可变的，这就导致每次对String的操作都会生成新的String对象，不仅效率低下，而且大量浪费有限的内存空间。

我们对String的操作都是改变复制地址而不是改变值操作

1.单独使用""引号创建的字符串都是常量,编译期就已经确定存储到String Pool中；

2，使用new String("")创建的对象会存储到heap中,是运行期新创建的；

3，使用只包含常量的字符串连接符如"aa" + "aa"创建的也是常量,编译期就能确定,已经确定存储到String Pool中；

4，使用包含变量的字符串连接符如"aa" + s1创建的对象是运行期才创建的,存储在heap中；

StringBuffer类：

StringBuffer是可变类，和线程安全的字符串操作类，任何对它指向的字符串的操作都不会产生新的对象。

每个StringBuffer对象都有一定的缓冲区容量，当字符串大小没有超过容量时，不会分配新的容量，当字符串大小超过容量时，会自动增加容量。

常用方法：

1:存储数据

append(数据类型)：可以是任意数据类型。

insert(索引位置,数据类型)：把数据类型的值插入到索引位置。

2:删除数据

StringBuffer delete(int start, int end):移除此序列的子字符串中的字符。 

StringBuffer deleteCharAt(int index):移除此序列指定位置的 char。

3.从字符串到StringBuffer对象，可以通过带参构造。

 StringBuffer(String str)

4.从StringBuffer到字符串，可以通过toString()方法。

  String toString()

StringBuilder类：

java.lang.StringBuilder一个可变的字符序列是5.0新增的。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。

该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，

建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。两者的方法基本相同。

总结（大家都是这么说的-。。-）：

（1）.如果要操作少量的数据用 = String 

（2）.单线程操作字符串缓冲区 下操作大量数据 = StringBuilder 

（3）.多线程操作字符串缓冲区 下操作大量数据 = StringBuffer 

类的加载：

1. 类的加载过程：JVM将类加载过程分为三个步骤：装载（Load），链接（Link）和初始化(Initialize)链接又分为三个步骤。

1) 装载：查找并加载类的二进制数据；

2)链接：

验证：确保被加载类的正确性；

准备：为类的静态变量分配内存，并将其初始化为默认值；

解析：把类中的符号引用转换为直接引用；

3)初始化：为类的静态变量赋予正确的初始值；

 那为什么我要有验证这一步骤呢？首先如果由编译器生成的class文件，它肯定是符合JVM字节码格式的，但是万一有高手自己写一个class文件，让JVM加载并运行，

 用于恶意用途，就不妙了，因此这个class文件要先过验证这一关，不符合的话不会让它继续执行的，也是为了安全考虑吧。

准备阶段和初始化阶段看似有点牟盾，其实是不牟盾的，如果类中有语句：private static int a = 10，它的执行过程是这样的，

首先字节码文件被加载到内存后，先进行链接的验证这一步骤，验证通过后准备阶段，给a分配内存，因为变量a是static的，

所以此时a等于int类型的默认初始值0，即a=0,然后到解析（后面在说），到初始化这一步骤时，才把a的真正的值10赋给a,此时a=10。

2. 类的初始化

    类什么时候才被初始化：

1）创建类的实例，也就是new一个对象

2）访问某个类或接口的静态变量，或者对该静态变量赋值

3）调用类的静态方法

4）反射（Class.forName("com.lyj.load")）

5）初始化一个类的子类（会首先初始化子类的父类）

6）JVM启动时标明的启动类，即文件名和类名相同的那个类

只有这6中情况才会导致类的类的初始化。

类的初始化步骤：

1）如果这个类还没有被加载和链接，那先进行加载和链接

2）假如这个类存在直接父类，并且这个类还没有被初始化（注意：在一个类加载器中，类只能初始化一次），那就初始化直接的父类（不适用于接口）

3)加入类中存在初始化语句（如static变量和static块），那就依次执行这些初始化语句。

3. 类的加载 

类的加载指的是将类的.class文件中的二进制数据读入到内存中，将其放在运行时数据区的方法区内，然后在堆区创建一个这个类的java.lang.Class对象，

用来封装类在方法区类的对象。

类的加载的最终产品是位于堆区中的Class对象， Class对象封装了类在方法区内的数据结构，并且向Java程序员提供了访问方法区内的数据结构的接口

加载类的方式有以下几种：

 1）从本地系统直接加载

2）通过网络下载.class文件

3）从zip，jar等归档文件中加载.class文件

4）从专有数据库中提取.class文件

5）将Java源文件动态编译为.class文件（服务器）

JVM的类加载是通过ClassLoader及其子类来完成的：

1）Bootstrap ClassLoader

负责加载$JAVA_HOME中jre/lib/rt.jar里所有的class，由C++实现，不是ClassLoader子类

2）Extension ClassLoader

负责加载java平台中扩展功能的一些jar包，包括$JAVA_HOME中jre/lib/*.jar或-Djava.ext.dirs指定目录下的jar包

3）App ClassLoader

负责记载classpath中指定的jar包及目录中class

4）Custom ClassLoader

属于应用程序根据自身需要自定义的ClassLoader，如tomcat、jboss都会根据j2ee规范自行实现ClassLoader

加载过程中会先检查类是否被已加载，检查顺序是自底向上，从Custom ClassLoader到BootStrap ClassLoader逐层检查，只要某个classloader已加载就视为已加载此类，保证此类只所有ClassLoader加载一次。而加载的顺序是自顶向下，也就是由上层来逐层尝试加载此类。

（以上绝大部分内容是引用这里的：http://blog.csdn.net/gjanyanlig/article/details/6818655）

三、Properties类

Properties类：用来读取.xml和.properties的文件，继承了HashTable类

构造方法：

public Properties() --创建一个无默认值的空属性列表。 

public Properties(Properties defaults) --创建一个带有指定默认值的空属性列表。

常用方法：

String getProperty(String key) -- 用指定的键在此属性列表中搜索属性。 

void load(InputStream inStream) --从输入流中读取属性列表（键和元素对）。 

void loadFromXML(InputStream in) --将指定输入流中由 XML 文档所表示的所有属性加载到此属性表中。 

Object setProperty(String key, String value) --调用 Hashtable 的方法 put。 

public void store(OutputStream out,String comments) throws IOException ---第一个参数是输出的流，第二个是注释

void storeToXML(OutputStream os, String comment, String encoding) --使用指定的编码发出一个表示此表中包含的所有属性的 XML 文档 

代码实现：

定义    prop.properties 文件
内容：
username=zhangsan
password=123456

定义   propXML.xml  文件
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
<entry key="username">zhangsan</entry>
<entry key="password">123456</entry>
</properties>

主代码

package com.itheima.propertities;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.Properties;

public class PropertitiesTest {
	public static void main(String[] args) throws Exception {
		/*读取.propertities的资源文件*/
		File file = new File("prop.properties");
		Properties prop = new Properties();
		//加载资源文件流
		prop.load(new FileInputStream(file));
		//根据key，读取相应的值
		String username = (String) prop.get("username");
		String password = prop.getProperty("password");
		
		System.out.println("username:"+username);
		System.out.println("password:"+password);
		
		//向资源文件中写入键值对
		prop.setProperty("id", "001");
		prop.store(new FileOutputStream(file), "self-write-id");
		
		/*读取.xml的资源文件*/
		File fileXML = new File("propXML.xml");
		//加载资源文件流
		prop.loadFromXML(new FileInputStream(fileXML));
		//根据key，读取相应的值
		username = (String) prop.get("username");
		password = prop.getProperty("password");
		
		System.out.println("username:"+username);
		System.out.println("password:"+password);
		prop.setProperty("id", "001");
		prop.storeToXML(new FileOutputStream(fileXML), "self-write-id");
		
	}
}
           

好了终于搞定了，对于Properties类的总结就不写了，太困了，睡觉了，明天还要早起准备期末考呢。。。。。