对象序列化主要是为了支持两种主要的特性，一是Java远程方法调用(RMI)，另外一个是序列化Java Beans。

1.        实现了Serializable接口的对象的序列化

要序列化一个对象，首先要创建OutputStream对象，然后将其封装在一个ObjectOutputStream对象内。此时，调用writeObject()方法将对象序列化并发送给OutputStream。在反序列化时，需要将一个InputStream封装在ObjectInputStream内，然后调用readObject()，得到的结果是一个Object对象，需要进行转型得到最后所需的对象。需要注意的是，在对一个Serializable对象进行反序列化的过程中，没有调用任何构造器，包括缺省的构造器，整个对象都是通过从InputStream中取得数据恢复过来的。对象序列化是面向字节的，因此采用InputStream和OutputStream层次结构。

2.        实现了Externalizable接口的对象的序列化

Externalizable接口继承了Serializable接口，同时添加了writeExternal()和readExternal()，它们在序列化和反序列化过程中会被自动调用。出于安全的考虑，可以将需要序列化的对象在上述方法中显式处理，否则不用在上述两个方法内考虑。注意，对于实现了Serializable接口的对象，对象完全以它存储的二进制位为基础来构造，不调用构造器。而对于一个Externalizable对象，所有普通的缺省构造器都会被调用，然后调用readExternal()。

3.        transient关键字

在某些情况下，有些特定的子对象不希望Java序列化机制自动保存与恢复，即使对象中的这些信息是private的，经过序列化处理，就可以通过读取文件或者拦截网络传输的方式来访问到它。实现了Externalizable接口的对象的writeExternal()方法可以对需要的对象进行显式的序列化，但是如果我们操作的是一个实现了Serializable接口的对象，就只能用transient关键字逐个字段的关闭序列化，只需要在字段定义前加上该关键字即可。

4.        实现了Serializable接口的同时，提供两个方法

private void writeObject(ObjectOutputStream stream) throws IOException

private void readObject(ObjectInputStream stream)

throws IOException, ClassNotFoundException

这种方法使用起来比较混乱，仅仅提供了这样的一种功能，绝大多数情况下，使用前面三种方法就能满足需求。

作者：Flyingis

    文件加锁是JDK1.4引入的一种机制，它允许我们同步访问某个作为共享资源的文件。竞争同一文件的两个线程可能在不同的Java虚拟机上，或者一个是Java线程，另一个是操作系统中的某个本地线程。文件锁对其他的操作系统进程是可见的，因为Java的文件加锁直接映射到了本地操作系统的加锁工具。

通过对FileChannel调用tryLock()或lock()，就可以获得整个文件的FileLock。特殊的是，SocketChannel/DatagramChannel/ServerSocketChannel不需要加锁，因为它们是从单进程实体继承而来，我们通常不在两个进程之间共享网络的socket。

tryLock()是非阻塞式的，它设法获取锁，但如果不能获得，例如因为其他一些进程已经持有相同的锁，而且不共享时，它将直接从方法调用返回。

lock()是阻塞式的，它要阻塞进程直到锁可以获得，或调用lock()的线程中断，或调用lock()的通道关闭。

对独占锁和共享锁的支持必须由底层的操作系统提供。锁的类型可以通过FileLock.isShared()进行查询。另外，我们不能获取缓冲器上的锁，只能是通道上的。

文件加锁的实际应用之一：文件映射通常应用于大型的文件，我们可能需要对巨大的文件进行部分加锁，以便其他的进程可以修改文件中未被加锁的部分，数据库就是如此，使得多用户可以访问到未加锁的部分数据。其他的应用还知之甚少。

    在基于Java的各种开发中，字符编码是常见的问题之一，在最基本的Java I/O中也存在这种问题。新的Java I/O通过通道和缓冲器来读写数据，缓冲器容纳的是普通的字节，为了把它们转换成字符，我们要么在输入的时候对其进行编码，要么在从缓冲器输出时对它们进行解码。

import java.io.*;

import java.nio.*;

import java.nio.channels.*;

import java.nio.charset.*;

public class ByteToCharacter {

  private static final int SIZE = 1024;

  public static void main(String[] args) throws Exception {

FileChannel fc = new FileOutputStream(“Output.txt”).getChannel();

ByteBuffer buffer = ByteBuffer.allocate(SIZE);

/**

* 在输入的时候进行编码方式一

*/

fc.write(ByteBuffer.wrap(“Good holiday!”.getBytes(“UTF-16BE”)));  // UTF-16BE可以更换为其他编码方式

fc.close();

fc = new FileInputStream(“Output.txt”).getChannel();

fc.read(buffer);

buffer.flip();  //准备从缓冲区读取已经写入的数据

System.out.println(buffer.asCharBuffer());

/**

* 在输入的时候进行编码方式二

* 通过asCharBuffer()方法直接以char形式将字符写入

*/

fc = new FileOutputStream(“Output.txt”).getChannel();

buffer.clear();

buffer.asCharBuffer.put(“Good holiday has passed!”);

fc.write(buffer);

fc.close();

fc = new FileInputStream(“Output.txt”).getChannel();

buffer.clear();

fc.read(buffer);

buffer.flip();

System.out.println(buffer.asCharBuffer());

/**

* 从缓冲器输出时进行编码

*/

fc = new FileOutputStream(“Output.txt”).getChannel();

fc.write(ByteBuffer.wrap(“Once again!”.getBytes()));

fc.close();

fc = new FileInputStream(“Output.txt”).getChannel();

buffer.clear();

fc.read(buffer);

buffer.flip();

String encode = System.getProperty(“file.encoding”);  // 平台缺省字符集，更加通用的方法，跨平台特性的体现之一

System.out.println(Charset.forName(encode).decode(buffer));

}

}

    在上述代码中，如果不对从缓冲器写入的数据进行正确编码，那么当再次通过缓冲器读取这些数据时，将不能显示任何所需要的数据。

    JDK中的java.nio.charset.Charset类提供了把数据编码成多种不同类型的字符集的工具，满足在各种应用中的编码需求。

Java的I/O使用“流”这个抽象的概念，它屏蔽了实际的I/O设备中处理数据的细节。在实际的应用中，我们很少使用单一的类来创建流对象，而是通过多个对象来提供所需要的I/O功能。Java从1.0到1.1到1.4多I/O类库作了多次重大修改，具体的可以参考相关的书籍或Sun官方网站。这里是从模式的角度来分析Java的I/O类库的设计。

Strategy设计模式

将会发生变化的代码封装在单独的类(Strategy对象)中，供其他保持不变的类使用，实现某种算法或应用，这是Strategy设计模式的一般思想。在Java I/O中，一个典型的应用是File类，它可以代表一个特定文件的名称，也可以代表一个目录下一组文件的名称。当我们要查询显示一个目录下特定文件类型的所有文件对象信息时，就需要将这个目录下的文件过滤，找到所需要的对象。

import java.io.*;

import java.util.*;

import java.util.regex.*;

 

public class AlphabeticComparator implements Comparator {

public int compare(Object o1, Object o2) {

  String s1 = (String)o1;

  String s2 = (String)o2;

  return s1.toLowerCase().compareTo(s2.toLowerCase());  //比较时不考虑大小写

}

}

 

public class FruitList {

  public static FilenameFilter filter(final String regex) {

return new FilenameFilter() {

  private Pattern pattern = Pattern.compile(regex);

  public boolean accept(File dir, String name) {

    return pattern.matcher(new File(name).getName()).matches();

}

};

}

public static void main(String[] args) {

  File path = new File(“.”);

  String[] list;

  if (args.length == 0)

    list = path.list();  //搜索出该目录下所有类型的文件

else

  list = path.list(filter(args[0]));  //搜索出该目录下指定类型的文件

Arrays.sort(list, new AlphabeticComparator());

for (int i = 0; i < list.length; i++)

  System.out.println(list[i]);

}

}在上述代码中，有两个地方使用了Strategy设计模式，一个是AlphabeticComparator类，用来在忽略字符串大小写的情况下提供排序的规则，另一个就是FilenameFilter接口，使用了匿名内部类的设计，然后将其中实现的accept()规则提供给File类的list方法使用。这里是用来判断正则表达式regex是否和文件名匹配，当运行程序在命令操作符中输入“E.*\.java”时，搜索到的是该目录下所有.java文件。

File类除了上述用法外，还可以创建或删除目录，查看文件的信息，包括文件大小、最后修改日期，读写状态等，具体的可以参考JDK文档。

Decorator设计模式

在http://www.j2eesp.com上有对Decorator设计模式的定义：动态给一个对象添加一些额外的职责，就像在墙上刷油漆。使用Decorator模式相比用生成子类方式达到功能的扩充显得更为灵活。Decorator模式规定所有封装于初始对象内部的对象具有相同的接口，这使得该模式的应用具有透明性。

在Java I/O设计中，Decorator模式主要体现在filter类的设计上，抽象类filter是所有Decorator模式类的基类。但是Decorator模式同样存在缺点：在编写程序时，它在给开发人员提供了灵活性的同时，增加了代码的复杂性，造成了Java I/O类操作不便，因为很多I/O设计中都需要应用Decorator模式，增加一些类来完成该设计。

例如在Java 1.0中，FilterInputStream从InputStream中读取数据，FilterOutPutStream向OutputStream中写入数据，在Java 1.1中，相应的有FilterReader和FilterWriter(抽象类，没有子类)用于Decorator模式设计。举个简单的例子：

import java.io.*;

public class DecoratorDemo {

  public static void main(String[] args) {

BufferedReader in = new BufferedReader(new FileReader(“FruitList.java”));

String s = new String();

while ((s = in.readLine()) != null)

  System.out.println(s);

in.close();

}

}

    BufferedReader和FileReader完成了Decorate模式设计，这两个类可以更换为其他具有相同功用的类(在Thinking in Java中称为“修饰器”类)来组合完成特定的任务，正如上文所述，这给开发者提供了多种组合方式，同时也相对的增加了复杂度。

    最后，祝blogjava所有成员和Java、开源爱好者元旦快乐！幸福安康！

Flyingis 2005-12-30 21:47 发表评论

]]>

1.Map的功能方法

Map(interface): 维护label和value的关联性，使得可以通过label查找value。

HashMap: Map基于散列表的实现，取代了Hashtable。插入和查询label/value的开销是固定的，并且可以通过构造器设置容量和负载因子，以调整容器的性能。

LinkedHashMap: 在HashMap的基础上做了一些改进，在迭代遍历它时，取得label/value的顺序是其插入的次序，或者是最近最少使用(LRU)的次序，速度上比HashMap要慢一点，但在迭代访问时速度会更快，主要原因是它使用了链表维护内部次序。

TreeMap: 查看label或label/value时，元素会被排序，其次序由Comparable或Comparator决定，因此查询所得到的结果是经过排序的。另外，它是唯一带有subMap()方法的Map具体类，即返回一个子树。它也是SortedMap接口的唯一实现，subMap()方法也是从该接口继承的。

WeakHashMap: Weak Key映射，允许释放映射所指向的对象。当映射之外没有引用指向某个label时，此label可以被垃圾收集器回收。

IdentityHashMap: 使用==代替equals()对label进行比较的散列映射。

2.hashCode()

         当使用标准库中的类Integer作为HashMap的label时，程序能够正常运行，但是使用自己创建的类作为HashMap的label时，通常犯一个错误。

         在HashMap中通过label查找value时，实际上是计算label对象地址的散列码来确定value的。一般情况下，我们是使用基类Object的方法hashCode()来生成散列码，它默认是使用对象的地址来计算的，因此由第一个对象new Apple(5)和第二个对象new Apple(5)生成的散列码是不同的，不能完成正确的查找。通常，我们可以编写自己的hashCode()方法来覆盖基类的原始方法，但与此同时，我们必须同时实现equals()方法来判断当前的label是否与表中存在的label相同。正确的equals()方法满足五个条件：

(1)     自反性。对于任意的x，x.equals(x)一定返回true。

(2)     对称性。对于任意的x和y，如果y.equals(x)返回true，则x.equals(y)也返回true。

(3)     传递性。对于任意的x、y、z，如果有x.equals(y)返回true，y.equals(z)返回true，则x.equals(z)一定返回true。

(4)     一致性。对于任意的x和y，如果对象中用于等价比较的信息没有改变，那么无论调用x.equals(y)多少次，返回的结果应该保持一致，要么一直是true，要么一直是false。

(5)     对任何不是null的x，x.equals(null)一定返回false。

equals()比较的是对象的地址，如果要使用自己的类作为HashMap的label，必须同时重载hashCode()和equals()方法。

使用散列的目的：想要使用一个对象来查找另一个对象。使用TreeSet或TreeMap也能实现此目的。另外，还可以自己实现一个Map，此时，必须提供Map.entrySet()方法来生成Map.Entry对象的Set。

使用散列的价值：速度，散列使得查询可以快速进行。散列将label保存载数组中方便快速查询，因为存储一组元素最快的数据结构是数组，用它来表示label的信息(后面有信息的描述)，而不是label本身。通过label对象计算得到一个数字，作为数组的下标，这个数字就是散列码(即前面所述的信息)。该散列码具体是通过定义在基类Object中，可能由程序员自定义的类覆盖的hashCode()方法，即散列函数生成。为了解决数组容量带来的限制，可以使不同的label生成相同的下标，保存在一个链表list中，每一个链表就是数组的一个元素。查询label时就可以通过对list中的信息进行查找，当散列函数比较好，数组的每个位置中的list长度较短，则可以快速查找到数组元素list中的某个位置，提高了整体速度。

散列表中的slot通常称为bucket，为了使散列分步均匀，bucket的值一般取质数。但事实证明，质数实际上并不是散列bucket的理想容量，近来Java散列实现都使用2的幂，具体如何验证以后再续。

3.HashMap的性能因子

容量(capacity): 散列表中bucket的数量。

初始化容量(initial capacity): 创建散列表时bucket的数量。可以在构造方法中指定HashMap和HashSet的初始化容量。

尺寸(size): 散列表中记录的数量。(数组的元素个数，非list中元素总和)

负载因子(load factor): 尺寸/容量。负载因子为0，表示空的散列表，0.5表示半满的散列表。轻负载的散列表具有冲突少，适宜插入与查询的特点，但是使用迭代器遍历会比较慢。较高的负载会减少所需空间大小。当负载达到指定值时，容器会自动成倍地增加容量，并将原有的对象重新分配，存入新的bucket中，这个过程称为“重散列”。

4.重写hashCode()的关键

(1)     对同一个对象调用hashCode()都应该生成同样的值。

(2)     hashCode()方法不要依赖于对象中易变的数据，当数据发生变化时，hashCode()就会生成一个不同的散列码，即产生了一个不同的label。

(3)     hashCode()不应依赖于具有唯一性的对象信息，例如对象地址。

(4)     散列码应该更关心速度，而不是唯一性，因为散列码不必是唯一的。

(5)     好的hashCode()应该产生分步均匀的散列码。在Effective Java(Addison-Wesley 2001)中，Joshua Bloch给hashCode()给出了设计指导，可以参考。