java精华（2）

1.1.1.1.1 栈类Stack

Stack类是Vector类的子类。它向用户提供了堆栈这种高级的数据结构。栈的基本特性就是先进后出。即先放入栈中的元素将后被推出。Stack类中提供了相应方法完成栈的有关操作。
　　基本方法：
　　public Object push(Object Hem)
　　将Hem压入栈中，Hem可以是任何类的对象。
　　public Object pop()
　　弹出一个对象。
　　public Object peek()
　　返回栈顶元素，但不弹出此元素。
　　public int search(Object obj)
　　搜索对象obj,返回它所处的位置。
　　public boolean empty()
　　判别栈是否为空。
　　例1.4 StackApp.java使用了上面的各种方法。
　　例1.4 StackApp.java。
　　import java.lang.*;
　　import java.util.*;
　　public class StackApp{
　　　public static void main(String args[]){
　　　　Stack sta=new Stack();
　　　　sta.push("Apple");
　　　　sta.push("banana");
　　　　sta.push("Cherry");
　　　　//压入的为字符串对象
　　　　sta.push(new Integer(2));
　　　　//压入的为Integer的对象，值为2
　　　　sta.push(new Float(3.5));
　　　　//压入的为Float的对象，值为3.5
　　　　System.out.println("The stack is,"+sta);
　　　　//对应栈sta
　　　　System.out.println("The top of stack is:"+sta.peek());
　　　　//对应栈顶元素，但不将此元素弹出
　　　　System.out.println("The position of object Cherry is:"
　　　　+sta.search("cherry"));
　　　　//打印对象Cherry所处的位置
　　　　System.out.print("Pop the element of the stack:");
　　　　while(!sta.empty())
　　　　System.out.print(sta.pop()+" ");
　　　　System.out.println();
　　　　//将栈中的元素依次弹出并打印。与第一次打印的sta的结果比较，可看出栈
　　　　//先进后出的特点
　　　}
　　}
　　运行结果(略)

1.1.1.1.2 哈希表类Hashtable

哈希表是一种重要的存储方式，也是一种常见的检索方法。其基本思想是将关系码的值作为自变量，通过一定的函数关系计算出对应的函数值，把这个数值解释为结点的存储地址，将结点存入计算得到存储地址所对应的存储单元。检索时采用检索关键码的方法。现在哈希表有一套完整的算法来进行插入、删除和解决冲突。在Java中哈希表用于存储对象，实现快速检索。
　　Java.util.Hashtable提供了种方法让用户使用哈希表，而不需要考虑其哈希表真正如何工作。
　　哈希表类中提供了三种构造方法，分别是：
　　public Hashtable()
　　public Hashtable(int initialcapacity)
　　public Hashtable(int initialCapacity,float loadFactor)
　　参数initialCapacity是Hashtable的初始容量，它的值应大于0。loadFactor又称装载因子，是一个0.0到0.1之间的float型的浮点数。它是一个百分比，表明了哈希表何时需要扩充，例如，有一哈希表，容量为100，而装载因子为0.9，那么当哈希表90%的容量已被使用时，此哈希表会自动扩充成一个更大的哈希表。如果用户不赋这些参数，系统会自动进行处理，而不需要用户操心。
　　Hashtable提供了基本的插入、检索等方法。
　　■插入
　　public synchronized void put(Object key,Object value)
给对象value设定一关键字key,并将其加到Hashtable中。若此关键字已经存在，则将此关键字对应的旧对象更新为新的对象Value。这表明在哈希表中相同的关键字不可能对应不同的对象(从哈希表的基本思想来看，这也是显而易见的)。
　　■检索
　　public synchronized Object get(Object key)
　　根据给定关键字key获取相对应的对象。
　　public synchronized boolean containsKey(Object key)
　　判断哈希表中是否包含关键字key。
　　public synchronized boolean contains(Object value)
　　判断value是否是哈希表中的一个元素。
　　■删除
　　public synchronized object remove(object key)
　　从哈希表中删除关键字key所对应的对象。
　　public synchronized void clear()
　　清除哈希表
　　另外，Hashtalbe还提供方法获取相对应的枚举集合：
　　public synchronized Enumeration keys()
　　返回关键字对应的枚举对象。
　　public synchronized Enumeration elements()
　　返回元素对应的枚举对象。
　　例1.5 Hashtable.java给出了使用Hashtable的例子。
　　例1.5 Hashtalbe.java。
　　//import java.lang.*;
　　import java.util.Hashtable;
　　import java.util.Enumeration;
　　public class HashApp{
　　　public static void main(String args[]){
　　　　Hashtable hash=new Hashtable(2,(float)0.8);
　　　　//创建了一个哈希表的对象hash，初始容量为2，装载因子为0.8
　　　　hash.put("Jiangsu","Nanjing");
　　　　//将字符串对象“Jiangsu”给定一关键字“Nanjing”,并将它加入hash
　　　　hash.put("Beijing","Beijing");
　　　　hash.put("Zhejiang","Hangzhou");
　　　　System.out.println("The hashtable hash1 is: "+hash);
　　　　System.out.println("The size of this hash table is "+hash.size());
　　　　//打印hash的内容和大小
　　　　Enumeration enum1=hash.elements();
　　　　System.out.print("The element of hash is: ");
　　　　while(enum1.hasMoreElements())
　　　　　System.out.print(enum1.nextElement()+" ");
　　　　System.out.println();
　　　　//依次打印hash中的内容
　　　　if(hash.containsKey("Jiangsu"))
　　　　　System.out.println("The capatial of Jiangsu is "+hash.get("Jiangsu"));
　　　　hash.remove("Beijing");
　　　　//删除关键字Beijing对应对象
　　　　System.out.println("The hashtable hash2 is: "+hash);
　　　　System.out.println("The size of this hash table is "+hash.size());
　　　}
　　}
　　运行结果：
　　The hashtable hash1 is: {Beijing=Beijing, Zhejiang=Hangzhou, Jiangsu=Nanjing}
　　The size of this hash table is 3
　　The element of hash is: Beijing Hangzhou Nanjing
　　The capatial of Jiangsu is Nanjing
　　The hashtable hash2 is: {Zhejiang=Hangzhou, Jiangsu=Nanjing}
　　The size of this hash table is 2
　　Hashtable是Dictionary(字典)类的子类。在字典类中就把关键字对应到数据值。字典类是一个抽象类。在java.util中还有一个类Properties，它是Hashtable的子类。用它可以进行与对象属性相关的操作。

1.1.1.1.3 位集合类BitSet

　位集合类中封装了有关一组二进制数据的操作。
　　我们先来看一下例8.6 BitSetApp.java。
　　例8.6 BitSetApp.java
　　//import java.lang.*;
　　import java.util.BitSet;
　　public class BitSetApp{
　　　private static int n=5;
　　　public static void main(String[] args){
　　　　BitSet set1=new BitSet(n);
　　　　for(int i=0;i<N;I++)&NBSP;SET1.SET(I);
　　　　//将set1的各位赋1，即各位均为true
　　　　BitSet set2= new BitSet();
　　　　set2=(BitSet)set1.clone();
　　　　//set2为set1的拷贝
　　　　set1.clear(0);
　　　　set2.clear(2);
　　　　//将set1的第0位set2的第2位清零
　　　　System.out.println("The set1 is: "+set1);
　　　　//直接将set1转换成字符串输出，输出的内容是set1中值true所处的位置
　　　　//打印结果为The set1 is:{1,2,3,4}
　　　　System.out.println("The hash code of set2 is: "+set2.hashCode());
　　　　//打印set2的hashCode
　　　　printbit("set1",set1);
　　　　printbit("set2",set2);
　　　　//调用打印程序printbit(),打印对象中的每一个元素
　　　　//打印set1的结果为The bit set1 is: false true true true true
　　　　set1.and(set2);
　　　　printbit("set1 and set2",set1);
　　　　//完成set1 and set2,并打印结果
　　　　set1.or(set2);
　　　　printbit("set1 or set2",set1);
　　　　//完成set1 or set2,并打印结果
　　　　set1.xor(set2);
　　　　printbit("set1 xor set2",set1);
　　　　//完成set1 xor set2,并打印结果
　　　}
　　　//打印BitSet对象中的内容
　　　public static void printbit(String name,BitSet set){
　　　　System.out.print("The bit "+name+" is: ");
　　　　for(int i=0;i<N;I++)
　　　　　System.out.print(set.get(i)+" ");
　　　　System.out.println();
　　　}
　　}
　　运行结果：
　　The set1 is: {1, 2, 3, 4}
　　The hash code of set2 is: 1225
　　The bit set1 is: false true true true true
　　The bit set2 is: true true false true true
　　The bit set1 and set2 is: false true false true true
　　The bit set1 or set2 is: true true false true true
　　The bit set1 xor set2 is: false false false false false
　　程序中使用了BitSet类提供的两种构造方法：
　　　　public BitSet();
　　　　public BitSet(int n);
　　参数n代表所创建的BitSet类的对象的大小。BitSet类的对象的大小在必要时会由系统自动扩充。
　　其它方法：
　　public void set(int n)
　　将BitSet对象的第n位设置成1。
　　public void clear(int n)
　　将BitSet对象的第n位清零。
　　public boolean get(int n)
　　读取位集合对象的第n位的值，它获取的是一个布尔值。当第n位为1时，返回true；第n位为0时，返回false。
　　另外，如在程序中所示，当把一BitSet类的对象转换成字符串输出时，输出的内容是此对象中true所处的位置。
　　在BitSet中提供了一组位操作，分别是：
　　public void and(BitSet set)
　　public void or(BitSet set)
　　public void xor(BitSet set)
利用它们可以完成两个位集合之间的与、或、异或操作。
　　BitSet类中有一方法public int size()来取得位集合的大小，它的返回值与初始化时设定的位集合大小n不一样，一般为64。

1.1.1.1 Vector类与Enumeration接口

Vector类用于保存一组对象，由于java不支持动态数组，Vector可以用于实现跟动态数组差不多的功能。如果要将一组对象存放在某种数据结构中，但是不能确定对象的个数时，Vector是一个不错的选择。

例：将键盘上输入的一个数字序列的每位数字存储在vector对象中，然后在屏幕上打印出各位数字相加的结果。

import java.util.*;  //Vector类和Enumeration接口都在这个包中

public class TestVector

{

public static void main(String[] args)

{

Vector v=new Vector();

int b=0;

int num=0;

System.out.println("Please enter number:");

while(true)

{

try

{

b=System.in.read(); //从键盘读入一个字节内容

}

catch(Exception e)

{

e.printStackTrace();

}

if(b=='\r'||b=='\n') //如果是回车或换行的话，则退出while循环，即一串数据输入完成

{

break;

}

else

{

num=b-'0';

/*由于输入的是字符数字，它的数值是它的ascii码，例如‘0’=32；‘1’=33，

所以要想让输入的‘1’在计算机里为1，必须减去32，即‘0’*/

v.addElement(new Integer(num)); //将数字存入vector

}

}

int sum=0;

Enumeration e=v.elements();

//取出Vector中的所有元素，必须使用elements()方法，它返回一个Enumeration接口。

while(e.hasMoreElements())//如果当前指示器还指向一个对象，即还有数据

{

Integer intobj=(Integer)e.nextElement();

//取出当前指示器所指的对象，并将指示器指向下一个对象。

sum+=intobj.intValue(); //将Integer对象中所包装的整数取出来，并且加到sum中。

}

System.out.println(sum);//打印出这个和

}

}

Enumeration的nextelement（）方法返回的是指示器指示的对象，然后将指示器指向下一个对象。

由于vector可以存储各种类型的对象，所以编译器无法知道存储的是什么类型的对象，所以即使我们知道里面存储的是什么类型的，也要显示的说明它是什么类型的，如本例中的(Integer)e.nextElement();

Enumeration接口实现了一种机制，通过这种机制，我们就可以只用hasMoreElements()方法以及nextElement()方法就可以实现所有对象的访问。

1.1.1.2 Collection接口与Iterator接口

Collection接口的实现类跟Vector相似。要从实现了Collection接口的类的实例中取出保存在其中的元素对象，必须通过Collection接口的Iterator()方法，返回一个Iterator接口。

Iterator接口与Enumeration接口非常相似。该接口的优点是其中的方法名比较简短。

Arraylist类实现了Collection接口

例：将上例改写为用ArrayList类和Iterator接口来实现。

import java.util.*;

public class TestCollection

{

public static void main(String[] args)

{

ArrayList v=new ArrayList();

int b=0;

int num=0;

System.out.println("Please enter number:");

while(true)

{

try

{

b=System.in.read();

}

catch(Exception e)

{

e.printStackTrace();

}

if(b=='\r'||b=='\n')

{

break;

}

else

{

num=b-'0';

v.add(new Integer(num)); //方法为add（）而不是addelement（）

}

}

int sum=0;

Iterator e=v.iterator();

while(e.hasNext())//判断是否有数据时，使用的是hasNext()方法

{

Integer intobj=(Integer)e.next(); //取数据时使用next()方法，而不是nextElement()

sum+=intobj.intValue();

}

System.out.println(sum);

}

}

这两组实现的结果都是一样的，那什么时候使用哪种呢？

Vector类中的所有方法都是线程同步的，所有有两个以上的线程访问并发访问vector对象时，是安全的，但是只有一个线程访问时，仍然存在同步监视器检查的情况，需要额外的开销，影响了效率。而ArrayList中的所有方法是不同步的，所以程序中如果不存在多线程安全的问题，则ArrayList比Vector的效率高。如果存在多线程安全的问题，使用ArrayList要自己编写同步处理，而使用Vector则不要。

Collection,Set,List的区别如下：

Set,List是Collection的子类。

Collection各元素对象之间没有指定的顺序，允许有重复元素和多个Null元素对象。所以不可以排序，也不可以找出第几个第几个元素。

Set各元素对象之间没有指定的顺序，不允许有重复元素，最多允许有一个Null元素对象。

List各元素对象之间有指定的顺序，允许有重复元素和多个Null元素对象。

import java.util.*;

public class TestSort

{

public static void main(String[] args)

{

ArrayList al=new ArrayList();   //新建一个arraylist ，由于它也实现了list接口，所以可以进行排序

al.add(new Integer(1));

al.add(new Integer(3));

al.add(new Integer(2));   //添加三个数字，随便添加，没有排序

System.out.println(al.toString());  //打印

Collections.sort(al);   //排序

/*Collections类本身并不是一个集合类，它只是提供了各种方法来操作集合类*/

System.out.println(al.toString());

}

}

1.1.1.3 Vector、ArrayList、List使用深入剖析

线性表，链表，哈希表是常用的数据结构，在进行Java开发时，JDK已经为我们提供了一系列相应的类来实现基本的数据结构。这些类均在java.util包中。本文试图通过简单的描述，向读者阐述各个类的作用以及如何正确使用这些类。
Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│　└Stack
└Set
Map
├Hashtable
├HashMap
└WeakHashMap
Collection接口
　　Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）。一些Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接继承自Collection的类，Java SDK提供的类都是继承自Collection的“子接口”如List和Set。
　　所有实现Collection接口的类都必须提供两个标准的构造函数：无参数的构造函数用于创建一个空的Collection，有一个Collection参数的构造函数用于创建一个新的Collection，这个新的Collection与传入的Collection有相同的元素。后一个构造函数允许用户复制一个Collection。
　　如何遍历Collection中的每一个元素？不论Collection的实际类型如何，它都支持一个iterator()的方法，该方法返回一个迭代子，使用该迭代子即可逐一访问Collection中每一个元素。典型的用法如下：
　　　　Iterator it = collection.iterator(); // 获得一个迭代子
　　　　while(it.hasNext()) {
　　　　　　Object obj = it.next(); // 得到下一个元素
　　　　}
　　由Collection接口派生的两个接口是List和Set。
List接口
　　List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，这类似于Java的数组。
和下面要提到的Set不同，List允许有相同的元素。
　　除了具有Collection接口必备的iterator()方法外，List还提供一个listIterator()方法，返回一个ListIterator接口，和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，允许添加，删除，设定元素，还能向前或向后遍历。
　　实现List接口的常用类有LinkedList，ArrayList，Vector和Stack。
LinkedList类
　　LinkedList实现了List接口，允许null元素。此外LinkedList提供额外的get，remove，insert方法在LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈（stack），队列（queue）或双向队列（deque）。
　　注意LinkedList没有同步方法。如果多个线程同时访问一个List，则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List：
　　　　List list = Collections.synchronizedList(new LinkedList(...));
ArrayList类
　　ArrayList实现了可变大小的数组。它允许所有元素，包括null。ArrayList没有同步。
size，isEmpty，get，set方法运行时间为常数。但是add方法开销为分摊的常数，添加n个元素需要O(n)的时间。其他的方法运行时间为线性。
　　每个ArrayList实例都有一个容量（Capacity），即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加，但是增长算法并没有定义。当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。
　　和LinkedList一样，ArrayList也是非同步的（unsynchronized）。
Vector类
　　Vector非常类似ArrayList，但是Vector是同步的。由Vector创建的Iterator，虽然和ArrayList创建的Iterator是同一接口，但是，因为Vector是同步的，当一个Iterator被创建而且正在被使用，另一个线程改变了Vector的状态（例如，添加或删除了一些元素），这时调用Iterator的方法时将抛出ConcurrentModificationException，因此必须捕获该异常。
Stack 类
　　Stack继承自Vector，实现一个后进先出的堆栈。Stack提供5个额外的方法使得Vector得以被当作堆栈使用。基本的push和pop方法，还有peek方法得到栈顶的元素，empty方法测试堆栈是否为空，search方法检测一个元素在堆栈中的位置。Stack刚创建后是空栈。
Set接口
　　Set是一种不包含重复的元素的Collection，即任意的两个元素e1和e2都有e1.equals(e2)=false，Set最多有一个null元素。
　　很明显，Set的构造函数有一个约束条件，传入的Collection参数不能包含重复的元素。
　　请注意：必须小心操作可变对象（Mutable Object）。如果一个Set中的可变元素改变了自身状态导致Object.equals(Object)=true将导致一些问题。
Map接口
　　请注意，Map没有继承Collection接口，Map提供key到value的映射。一个Map中不能包含相同的key，每个key只能映射一个value。Map接口提供3种集合的视图，Map的内容可以被当作一组key集合，一组value集合，或者一组key-value映射。

Hashtable类
　　Hashtable继承Map接口，实现一个key-value映射的哈希表。任何非空（non-null）的对象都可作为key或者value。
　　添加数据使用put(key, value)，取出数据使用get(key)，这两个基本操作的时间开销为常数。
Hashtable通过initial capacity和load factor两个参数调整性能。通常缺省的load factor 0.75较好地实现了时间和空间的均衡。增大load factor可以节省空间但相应的查找时间将增大，这会影响像get和put这样的操作。
使用Hashtable的简单示例如下，将1，2，3放到Hashtable中，他们的key分别是”one”，”two”，”three”：
　　　　Hashtable numbers = new Hashtable();
　　　　numbers.put(“one”, new Integer(1));
　　　　numbers.put(“two”, new Integer(2));
　　　　numbers.put(“three”, new Integer(3));
　　要取出一个数，比如2，用相应的key：
　　　　Integer n = (Integer)numbers.get(“two”);
　　　　System.out.println(“two = ” + n);
　　由于作为key的对象将通过计算其散列函数来确定与之对应的value的位置，因此任何作为key的对象都必须实现hashCode和equals方法。hashCode和equals方法继承自根类Object，如果你用自定义的类当作key的话，要相当小心，按照散列函数的定义，如果两个对象相同，即obj1.equals(obj2)=true，则它们的hashCode必须相同，但如果两个对象不同，则它们的hashCode不一定不同，如果两个不同对象的hashCode相同，这种现象称为冲突，冲突会导致操作哈希表的时间开销增大，所以尽量定义好的hashCode()方法，能加快哈希表的操作。
　　如果相同的对象有不同的hashCode，对哈希表的操作会出现意想不到的结果（期待的get方法返回null），要避免这种问题，只需要牢记一条：要同时复写equals方法和hashCode方法，而不要只写其中一个。
　　Hashtable是同步的。
HashMap类
　　HashMap和Hashtable类似，不同之处在于HashMap是非同步的，并且允许null，即null value和null key。，但是将HashMap视为Collection时（values()方法可返回Collection），其迭代子操作时间开销和HashMap的容量成比例。因此，如果迭代操作的性能相当重要的话，不要将HashMap的初始化容量设得过高，或者load factor过低。
WeakHashMap类
　　WeakHashMap是一种改进的HashMap，它对key实行“弱引用”，如果一个key不再被外部所引用，那么该key可以被GC回收。
总结
　　如果涉及到堆栈，队列等操作，应该考虑用List，对于需要快速插入，删除元素，应该使用LinkedList，如果需要快速随机访问元素，应该使用ArrayList。
　　如果程序在单线程环境中，或者访问仅仅在一个线程中进行，考虑非同步的类，其效率较高，如果多个线程可能同时操作一个类，应该使用同步的类。
　　要特别注意对哈希表的操作，作为key的对象要正确复写equals和hashCode方法。
　　尽量返回接口而非实际的类型，如返回List而非ArrayList，这样如果以后需要将ArrayList换成LinkedList时，客户端代码不用改变。这就是针对抽象编程。
同步性
Vector是同步的。这个类中的一些方法保证了Vector中的对象是线程安全的。而ArrayList则是异步的，因此ArrayList中的对象并不是线程安全的。因为同步的要求会影响执行的效率，所以如果你不需要线程安全的集合那么使用ArrayList是一个很好的选择，这样可以避免由于同步带来的不必要的性能开销。
数据增长
从内部实现机制来讲ArrayList和Vector都是使用数组(Array)来控制集合中的对象。当你向这两种类型中增加元素的时候，如果元素的数目超出了内部数组目前的长度它们都需要扩展内部数组的长度，Vector缺省情况下自动增长原来一倍的数组长度，ArrayList是原来的50%,所以最后你获得的这个集合所占的空间总是比你实际需要的要大。所以如果你要在集合中保存大量的数据那么使用Vector有一些优势，因为你可以通过设置集合的初始化大小来避免不必要的资源开销。
使用模式
在ArrayList和Vector中，从一个指定的位置（通过索引）查找数据或是在集合的末尾增加、移除一个元素所花费的时间是一样的，这个时间我们用O(1)表示。但是，如果在集合的其他位置增加或移除元素那么花费的时间会呈线形增长：O(n-i)，其中n代表集合中元素的个数，i代表元素增加或移除元素的索引位置。为什么会这样呢？以为在进行上述操作的时候集合中第i和第i个元素之后的所有元素都要执行位移的操作。这一切意味着什么呢？
这意味着，你只是查找特定位置的元素或只在集合的末端增加、移除元素，那么使用Vector或ArrayList都可以。如果是其他操作，你最好选择其他的集合操作类。比如，LinkList集合类在增加或移除集合中任何位置的元素所花费的时间都是一样的?O(1)，但它在索引一个元素的使用缺比较慢－O(i),其中i是索引的位置.使用ArrayList也很容易，因为你可以简单的使用索引来代替创建iterator对象的操作。LinkList也会为每个插入的元素创建对象，所有你要明白它也会带来额外的开销。
最后，在《Practical Java》一书中Peter Haggar建议使用一个简单的数组（Array）来代替Vector或ArrayList。尤其是对于执行效率要求高的程序更应如此。因为使用数组(Array)避免了同步、额外的方法调用和不必要的重新分配空间的操作。

1.1.1.4 HashTable类

HashTable类不紧可以像Vector类一样动态的存储一系列的对象，而且对存储的每一个对象（称为值）都安排另一个对象（称为关键字）与它相关联。

用做关键字的类必须覆盖Object.hashCode方法和Object.equals方法，

因为要取出数据时，传递给get（）方法的参数要跟里面的关键字比较，这时就要使用equals（）方法。另外如果这两个关键字相等，他们的hashcode（）返回值也要相等。

编程举例：使用自定义类作为hashtable（）关键字的类。

public class MyKey

{

String name=null;

int age=0;

public boolean equals(Object obj)  //作为关键字的类要覆盖该方法

{

if(obj instanceof MyKey) //如果它是mykey类型的，则先要转换为mykey类型，因为编译器不知道他是什么类型的

{

MyKey objtemp=(MyKey)obj; //然后下面再比较里面的内容是否相等。

if(name.equals(objtemp.name)&&age==objtemp.age)

{

return true;  //如果内容也相等，则相等

}

else

{

return false; //否则不等

}

}

else

{

return false; //如果它不是mykey类型的，则肯定不相等，因为类型都不同

}

}

public int hashCode()  //作为关键字的类要覆盖该方法

{

return name.hashCode()+age; //因为string类已经覆盖了hashcode（）方法，stringbuffer类没有覆盖该方法，所以不可以用做关键字类。

//如果name和age有一个不等，返回值则不等

}

public MyKey(String name,int age)  //覆盖构造函数

{

this.name=name;

this.age=age;

}

public String toString() //如果不覆盖这个方法，则会产生乱码

{

return name+","+age;

}

}

import java.util.*;

public class HashTableTest

{

public static void main(String[] args)

{

Hashtable numbers=new Hashtable(); //新建一个hashtable类的实例

numbers.put(new MyKey("ZhangSan",18),new Integer(1)); 装入数据

numbers.put(new MyKey("LiSi",20),new Integer(2));

numbers.put(new MyKey("WangWu",16),new Integer(3));

Enumeration e=numbers.keys();

while(e.hasMoreElements())

{

MyKey Key=(MyKey)e.nextElement();

System.out.print(Key+"=");

System.out.println(numbers.get(Key));

}

}

}

1.1.1.5 Properties类

Properties是HashTable的子类。增加了将hashtable对象中的关键字和值保存到文件以及从文件中读取关键字和值到hashtable对象中的方法。

如果要用properties.store（）方法存储properties中的内容，每个属性的关键字和值都必须是string类型。

编程举例：使用properties把程序的启动运行次数记录在文件里，每次运行时打印出它的运行次数。

import java.util.*; //Properties在这个包中

import java.io.*;  //fileinputstream和fileoutputstream在这个包中

public class PropertiesFile

{

public static void main(String[] args)

{

Properties settings=new Properties();

try

{

settings.load(new FileInputStream("count.txt")); //从文件"count.txt"装载

}

catch(Exception e)

{

settings.setProperty("count",String.valueOf(0));

//发生异常，说明第一次运行，第一次运行时还不存在文件“count.txt”，我们只能不从文件中取，而设置它的默认值为0

}

int count=Integer.parseInt(settings.getProperty("count"))+1;

/*

本来可以使用从hashtable中继承的get方法，但是由于我们处理的是字符串，所以使用这个方法，

但由于返回的是字符串，所以转换成整数，由于存的是到上一次为止的运行次数，所以要加一。

*/

System.out.println("这是第"+count+"次运行！");

settings.setProperty("count",new Integer(count).toString());

/*

将次数存入property对象中，由于存入的是字符串，所以要转换成字符串。

*/

try

{

settings.store(new FileOutputStream("count.txt"),"program is used:");

//发生异常，说明第一次运行，这时会创建一个文件。

/*

将property对象中的结果存入文件，第一个参数为文件，第二个参数为标题。

*/

}

catch(Exception e)

{

e.printStackTrace();

}

}

}

1.1.1.6 读取Properties文件六种方法

1。使用java.util.Properties类的load()方法

示例： InputStream in = lnew BufferedInputStream(new FileInputStream(name));

       Properties p = new Properties();

       p.load(in);

2。使用java.util.ResourceBundle类的getBundle()方法

示例： ResourceBundle rb = ResourceBundle.getBundle(name, Locale.getDefault());

3。使用java.util.PropertyResourceBundle类的构造函数

示例： InputStream in = new BufferedInputStream(new FileInputStream(name));

       ResourceBundle rb = new PropertyResourceBundle(in);

4。使用class变量的getResourceAsStream()方法

示例： InputStream in = JProperties.class.getResourceAsStream(name);

       Properties p = new Properties();

       p.load(in);

5。使用class.getClassLoader()所得到的java.lang.ClassLoader的getResourceAsStream()方法

示例： InputStream in = JProperties.class.getClassLoader().getResourceAsStream(name);

       Properties p = new Properties();

       p.load(in);

6。使用java.lang.ClassLoader类的getSystemResourceAsStream()静态方法

示例： InputStream in = ClassLoader.getSystemResourceAsStream(name);

       Properties p = new Properties();

       p.load(in);

补充

Servlet中可以使用javax.servlet.ServletContext的getResourceAsStream()方法

示例：InputStream in = context.getResourceAsStream(path);

       Properties p = new Properties();

       p.load(in);

一般文件的I/O

FileInputStream.read() //从本地文件读取二进制格式的数据 

FileReader.read() //从本地文件读取字符（文本）数据 

FileOutputStream.write() //保存二进制数据到本地文件 

FileWriter.write() //保存字符数据到本地文件

XML文件的I/O

DocumentBuilderFactory.newDocumentBuilder().parse() //解析一个外部的XML文件，得到一个Document对象的DOM树 

DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument() //初始化一棵DOM树 

Document.getDocumentElement().appendChild() //为一个标签结点添加一个子结点 

Document.createTextNode() //生成一个字符串结点 

Node.getChildNodes() //取得某个结点的所有下一层子结点 

Node.removeChild()  //删除某个结点的子结点 

Document.getElementsByTagName() 查找所有指定名称的标签结点 

Document.getElementById() //查找指定名称的一个标签结点，如果有多个符合，则返回某一个，通常是第一个 

Element.getAttribute() //取得一个标签的某个属性的的值 

Element.setAttribute() //设置一个标签的某个属性的的值 

Element.removeAttribute() //删除一个标签的某个属性 

TransformerFactory.newInstance().newTransformer().transform() //将一棵DOM树写入到外部XML文件

1.1.1.7 Timer类与TimerTask类

有个schedule方法，可以指定过多长时间定期的执行某个程序或某段代码，或者过多长时间启动一个线程等。

TimerTask类实现了Runnable接口，要执行的类由它里面实现的run方法来完成。

编程实例：程序启动30秒后启动windows自带的计算器程序。

1.1.1 JAVA IO包
1.1.1.1 存取程序状态几种方法--Java I-O应用
1.1.1.1.1 文件I/O：文件流→序列化


★文件流
    文件操作是最简单最直接也是最容易想到的一种方式，我们说的文件操作不仅仅是通过FileInputStream/FileOutputStream这么“裸”的方式直接把数据写入到本地文件（像我以前写的一个扫雷的小游戏JavaMine就是这样保存一局的状态的），这样就比较“底层”了。
主要类与方法和描述

1. FileInputStream.read() //从本地文件读取二进制格式的数据 

2. FileReader.read() //从本地文件读取字符（文本）数据 

3. FileOutputStream.write() //保存二进制数据到本地文件 

4. FileWriter.write() //保存字符数据到本地文件


★XML
    和上面的单纯的I/O方式相比，XML就显得“高档”得多，以至于成为一种数据交换的标准。以DOM方式为例，它关心的是首先在内存中构造文档树，数据保存在某个结点上（可以是叶子结点，也可以是标签结点的属性），构造好了以后一次性的写入到外部文件，但我们只需要知道文件的位置，并不知道I/O是怎么操作的，XML操作方式可能多数人也实践过，所以这里也只列出相关的方法，供初学者预先了解一下。主要的包是javax.xml.parsers，org.w3c.dom，javax.xml.transform。
主要类与方法和描述

1. DocumentBuilderFactory.newDocumentBuilder().parse() //解析一个外部的XML文件，得到一个Document对象的DOM树 

2. DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument() //初始化一棵DOM树 

3. Document.getDocumentElement().appendChild() //为一个标签结点添加一个子结点 

4. Document.createTextNode() //生成一个字符串结点 

5. Node.getChildNodes() //取得某个结点的所有下一层子结点 

6. Node.removeChild()  //删除某个结点的子结点 

7. Document.getElementsByTagName() 查找所有指定名称的标签结点 

8. Document.getElementById() //查找指定名称的一个标签结点，如果有多个符合，则返回某一个，通常是第一个 

9. Element.getAttribute() //取得一个标签的某个属性的的值 

10. Element.setAttribute() //设置一个标签的某个属性的的值 

11. Element.removeAttribute() //删除一个标签的某个属性 

12. TransformerFactory.newInstance().newTransformer().transform() //将一棵DOM树写入到外部XML文件


★序列化
    使用基本的文件读写方式存取数据，如果我们仅仅保存相同类型的数据，则可以用同一种格式保存，譬如在我的JavaMine中保存一个盘局时，需要保存每一个方格的坐标、是否有地雷，是否被翻开等，这些信息组合成一个“复合类型”；相反，如果有多种不同类型的数据，那我们要么把它分解成若干部分，以相同类型（譬如String）保存，要么我们需要在程序中添加解析不同类型数据格式的逻辑，这就很不方便。于是我们期望用一种比较“高”的层次上处理数据，程序员应该花尽可能少的时间和代码对数据进行解析，事实上，序列化操作为我们提供了这样一条途径。
    序列化（Serialization）大家可能都有所接触，它可以把对象以某种特定的编码格式写入或从外部字节流（即ObjectInputStream/ObjectOutputStream）中读取。序列化一个对象非常之简单，仅仅实现一下Serializable接口即可，甚至都不用为它专门添加任何方法：

1. public class MySerial implements java.io.Serializable

2. {

3.   //...

4. }


但有一个条件：即你要序列化的类当中，它的每个属性都必须是是“可序列化”的。这句话说起来有点拗口，其实所有基本类型（就是int，char，boolean之类的）都是“可序列化”的，而你可以看看JDK文档，会发现很多类其实已经实现了Serializable（即已经是“可序列化”的了），于是这些类的对象以及基本数据类型都可以直接作为你需要序列化的那个类的内部属性。如果碰到了不是“可序列化”的属性怎么办？对不起，那这个属性的类还需要事先实现Serializable接口，如此递归，直到所有属性都是“可序列化”的。
主要类与方法和描述

1. ObjectOutputStream.writeObject() //将一个对象序列化到外部字节流 

2. ObjectInputStream.readObject() //从外部字节流读取并重新构造对象


    从实际应用上看来，“Serializable”这个接口并没有定义任何方法，仿佛它只是一个标记（或者说像是Java的关键字）而已，一旦虚拟机看到这个“标记”，就会尝试调用自身预定义的序列化机制，除非你在实现Serializable接口的同时还定义了私有的readObject()或writeObject()方法。这一点很奇怪。不过你要是不愿意让系统使用缺省的方式进行序列化，那就必须定义上面提到的两个方法：

1. public class MySerial implements java.io.Serializable

2. {

3.   private void writeObject(java.io.ObjectOutputStream out) throws IOException

4.   {

5.     //...

6.   }

7.   private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException

8.   {

9.     //...

10.   }

11.   //...

12. } 


    譬如你可以在上面的writeObject()里调用默认的序列化方法ObjectOutputStream.defaultWriteObject();譬如你不愿意将某些敏感的属性和信息序列化，你也可以调用ObjectOutputStream.writeObject()方法明确指定需要序列化那些属性。关于用户可定制的序列化方法，我们将在后面提到。
★Bean
    上面的序列化只是一种基本应用，你把一个对象序列化到外部文件以后，用notepad打开那个文件，只能从为数不多的一些可读字符中猜到这是有关这个类的信息文件，这需要你熟悉序列化文件的字节编码方式，那将是比较痛苦的（在《Core Java 2》第一卷里提到了相关编码方式，有兴趣的话可以查看参考资料），某些情况下我们可能需要被序列化的文件具有更好的可读性。另一方面，作为Java组件的核心概念“JavaBeans”，从JDK 1.4开始，其规范里也要求支持文本方式的“长期的持久化”（long-term persistence）。
    打开JDK文档，java.beans包里的有一个名为“Encoder”的类，这就是一个可以序列化bean的实用类。和它相关的两个主要类有XMLEcoder和XMLDecoder，显然，这是以XML文件的格式保存和读取bean的工具。他们的用法也很简单，和上面ObjectOutputStream/ObjectInputStream比较类似。
主要类与方法和描述

1. XMLEncoder.writeObject() //将一个对象序列化到外部字节流 

2. XMLDecoder.readObject() //从外部字节流读取并重新构造对象 


    如果一个bean是如下格式：

1. public class MyBean

2. {

3.   int i;

4.   char[] c;

5.   String s;

6.   //...(get和set操作省略)...

7. } 

那么通过XMLEcoder序列化出来的XML文件具有这样的形式：
      1
   
   
          a
    
          b
     
          c
       
     
  
      fox jump!
   
 

    像AWT和Swing中很多可视化组件都是bean，当然也是可以用这种方式序列化的，下面就是从JDK文档中摘录的一个JFrame序列化以后的XML文件：
      frame1
  
        0
        0
        200
        200
     
            Hello
         
       
     
      true
   
 

    因此但你想要保存的数据是一些不是太复杂的类型的话，把它做成bean再序列化也不失为一种方便的选择。
★Properties
    在以前我总结的一篇关于集合框架的小文章里提到过，Properties是历史集合类的一个典型的例子，这里主要不是介绍它的集合特性。大家可能都经常接触一些配置文件，如Windows的ini文件，Apache的conf文件，还有Java里的properties文件等，这些文件当中的数据以“关键字-值”对的方式保存。“环境变量”这个概念都知道吧，它也是一种“key-value”对，以前也常常看到版上问“如何取得系统某某信息”之类的问题，其实很多都保存在环境变量里，只要用一条

1. System.getProperties().list(System.out); 


就能获得全部环境变量的列表：
-- listing properties --
java.runtime.name=Java(TM) 2 Runtime Environment, Stand...
sun.boot.library.path=C:\Program Files\Java\j2re1.4.2_05\bin
java.vm.version=1.4.2_05-b04
java.vm.vendor=Sun Microsystems Inc.
java.vendor.url=http://java.sun.com/
path.separator=;
java.vm.name=Java HotSpot(TM) Client VM
file.encoding.pkg=sun.io
user.country=CN
sun.os.patch.level=Service Pack 1
java.vm.specification.name=Java Virtual Machine Specification
user.dir=d:\my documents\项目\eclipse\SWTDemo
java.runtime.version=1.4.2_05-b04
java.awt.graphicsenv=sun.awt.Win32GraphicsEnvironment
java.endorsed.dirs=C:\Program Files\Java\j2re1.4.2_05\li...
os.arch=x86
java.io.tmpdir=C:\DOCUME~1\cn2lx0q0\LOCALS~1\Temp\
line.separator=
java.vm.specification.vendor=Sun Microsystems Inc.
user.variant=
os.name=Windows XP
sun.java2d.fontpath=
java.library.path=C:\Program Files\Java\j2re1.4.2_05\bi...
java.specification.name=Java Platform API Specification
java.class.version=48.0
java.util.prefs.PreferencesFactory=java.util.prefs.WindowsPreferencesFac...
os.version=5.1
user.home=D:\Users\cn2lx0q0
user.timezone=
java.awt.printerjob=sun.awt.windows.WPrinterJob
file.encoding=GBK
java.specification.version=1.4
user.name=cn2lx0q0
java.class.path=d:\my documents\项目\eclipse\SWTDemo\bi...
java.vm.specification.version=1.0
sun.arch.data.model=32
java.home=C:\Program Files\Java\j2re1.4.2_05
java.specification.vendor=Sun Microsystems Inc.
user.language=zh
awt.toolkit=sun.awt.windows.WToolkit
java.vm.info=mixed mode
java.version=1.4.2_05
java.ext.dirs=C:\Program Files\Java\j2re1.4.2_05\li...
sun.boot.class.path=C:\Program Files\Java\j2re1.4.2_05\li...
java.vendor=Sun Microsystems Inc.
file.separator=\
java.vendor.url.bug=http://java.sun.com/cgi-bin/bugreport...
sun.cpu.endian=little
sun.io.unicode.encoding=UnicodeLittle
sun.cpu.isalist=pentium i486 i386

主要类与方法和描述

1. load() //从一个外部流读取属性 

2. store() //将属性保存到外部流（特别是文件） 

3. getProperty() //取得一个指定的属性 

4. setProperty() //设置一个指定的属性 

5. list() //列出这个Properties对象包含的全部“key-value”对 

6. System.getProperties() //取得系统当前的环境变量 


    你可以这样保存一个properties文件：

1. Properties prop = new Properties();

2. prop.setProperty("key1", "value1");

3. ...

4. FileOutputStream out = new FileOutputStream("config.properties");

5. prop.store(out, "--这里是文件头，可以加入注释--"); 


★Preferences
    如果我说Java里面可以不使用JNI的手段操作Windows的注册表你信不信？很多软件的菜单里都有“Setting”或“Preferences”这样的选项用来设定或修改软件的配置，这些配置信息可以保存到一个像上面所述的配置文件当中，如果是Windows平台下，也可能会保存到系统注册表中。从JDK 1.4开始，Java在java.util下加入了一个专门处理用户和系统配置信息的java.util.prefs包，其中一个类Preferences是一种比较“高级”的玩意。从本质上讲，Preferences本身是一个与平台无关的东西，但不同的OS对它的SPI（Service Provider Interface）的实现却是与平台相关的，因此，在不同的系统中你可能看到首选项保存为本地文件、LDAP目录项、数据库条目等，像在Windows平台下，它就保存到了系统注册表中。不仅如此，你还可以把首选项导出为XML文件或从XML文件导入。

主要类与方法和描述

1. systemNodeForPackage() //根据指定的Class对象得到一个Preferences对象，这个对象的注册表路径是从“HKEY_LOCAL_MACHINE\”开始的 

2. systemRoot() //得到以注册表路径HKEY_LOCAL_MACHINE\SOFTWARE\Javasoft\Prefs 为根结点的Preferences对象 

3. userNodeForPackage() //根据指定的Class对象得到一个Preferences对象，这个对象的注册表路径是从“HKEY_CURRENT_USER\”开始的 

4. userRoot() //得到以注册表路径HKEY_CURRENT_USER\SOFTWARE\Javasoft\Prefs 为根结点的Preferences对象 

5. putXXX() //设置一个属性的值，这里XXX可以为基本数值型类型，如int、long等，但首字母大写，表示参数为相应的类型，也可以不写而直接用put，参数则为字符串 

6. getXXX() //得到一个属性的值 

7. exportNode() //将全部首选项导出为一个XML文件 

8. exportSubtree() //将部分首选项导出为一个XML文件 

9. importPreferences() //从XML文件导入首选项 


    你可以按如下步骤保存数据：

1. Preferences myPrefs1 = Preferences.userNodeForPackage(this);// 这种方法是在“HKEY_CURRENT_USER\”下按当前类的路径建立一个注册表项

2. Preferences myPrefs2 = Preferences.systemNodeForPackage(this);// 这种方法是在“HKEY_LOCAL_MACHINE\”下按当前类的路径建立一个注册表项

3. Preferences myPrefs3 = Preferences.userRoot().node("com.jungleford.demo");// 这种方法是在“HKEY_CURRENT_USER\SOFTWARE\Javasoft\Prefs\”下按“com\jungleford\demo”的路径建立一个注册表项

4. Preferences myPrefs4 = Preferences.systemRoot().node("com.jungleford.demo");// 这种方法是在“HKEY_LOCAL_MACHINE\SOFTWARE\Javasoft\Prefs\”下按“com\jungleford\demo”的路径建立一个注册表项

5. myPrefs1.putInt("key1", 10);

6. myPrefs1.putDouble("key2", -7.15);

7. myPrefs1.put("key3", "value3");

8. FileOutputStream out = new FileOutputStream("prefs.xml");

9. myPrefs1.exportNode(out);


1.1.1.1.2 网络I/O：Socket→RMI


★Socket
    Socket编程可能大家都很熟，所以就不多讨论了，只是说通过socket把数据保存到远端服务器或从网络socket读取数据也不失为一种值得考虑的方式。
★RMI
    RMI机制其实就是RPC（远程过程调用）的Java版本，它使用socket作为基本传输手段，同时也是序列化最重要的一个应用。现在网络传输从编程的角度来看基本上都是以流的方式操作，socket就是一个例子，将对象转换成字节流的一个重要目标就是为了方便网络传输。
    想象一下传统的单机环境下的程序设计，对于Java语言的函数（方法）调用（注意与C语言函数调用的区别）的参数传递，会有两种情况：如果是基本数据类型，这种情况下和C语言是一样的，采用值传递方式；如果是对象，则传递的是对象的引用，包括返回值也是引用，而不是一个完整的对象拷贝！试想一下在不同的虚拟机之间进行方法调用，即使是两个完全同名同类型的对象他们也很可能是不同的引用！此外对于方法调用过程，由于被调用过程的压栈，内存“现场”完全被被调用者占有，当被调用方法返回时，才将调用者的地址写回到程序计数器（PC），恢复调用者的状态，如果是两个虚拟机，根本不可能用简单压栈的方式来保存调用者的状态。因为种种原因，我们才需要建立RMI通信实体之间的“代理”对象，譬如“存根”就相当于远程服务器对象在客户机上的代理，stub就是这么来的，当然这是后话了。
    本地对象与远程对象（未必是物理位置上的不同机器，只要不是在同一个虚拟机内皆为“远程”）之间传递参数和返回值，可能有这么几种情形：

· 值传递：这又包括两种子情形：如果是基本数据类型，那么都是“可序列化”的，统统序列化成可传输的字节流；如果是对象，而且不是“远程对象”（所谓“远程对象”是实现了java.rmi.Remote接口的对象），本来对象传递的应该是引用，但由于上述原因，引用是不足以证明对象身份的，所以传递的仍然是一个序列化的拷贝（当然这个对象也必须满足上述“可序列化”的条件）。

· 引用传递：可以引用传递的只能是“远程对象”。这里所谓的“引用”不要理解成了真的只是一个符号，它其实是一个留在（客户机）本地stub中的，和远端服务器上那个真实的对象张得一模一样的镜像而已！只是因为它有点“特权”（不需要经过序列化），在本地内存里已经有了一个实例，真正引用的其实是这个“孪生子”。


    由此可见，序列化在RMI当中占有多么重要的地位。

1.1.1.1.3 数据库I/O：CMP、Hibernate


★什么是“Persistence”
    用过VMWare的朋友大概都知道当一个guest OS正在运行的时候点击“Suspend”将虚拟OS挂起，它会把整个虚拟内存的内容保存到磁盘上，譬如你为虚拟OS分配了128M的运行内存，那挂起以后你会在虚拟OS所在的目录下找到一个同样是128M的文件，这就是虚拟OS内存的完整镜像！这种内存的镜像手段其实就是“Persistence”（持久化）概念的由来。
★CMP和Hibernate
    因为我对J2EE的东西不是太熟悉，随便找了点材料看看，所以担心说的不到位，这次就不作具体总结了，人要学习……真是一件痛苦的事情java精华（2） - java world - Java World

1.1.1.1.4 序列化再探讨


    从以上技术的讨论中我们不难体会到，序列化是Java之所以能够出色地实现其鼓吹的两大卖点??分布式（distributed）和跨平台（OS independent）的一个重要基础。TIJ（即“Thinking in Java”）谈到I/O系统时，把序列化称为“lightweight persistence”??“轻量级的持久化”，这确实很有意思。
★为什么叫做“序列”化？
    开场白里我说更习惯于把“Serialization”称为“序列化”而不是“串行化”，这是有原因的。介绍这个原因之前先回顾一些计算机基本的知识，我们知道现代计算机的内存空间都是线性编址的（什么是“线性”知道吧，就是一个元素只有一个唯一的“前驱”和唯一的“后继”，当然头尾元素是个例外；对于地址来说，它的下一个地址当然不可能有两个，否则就乱套了），“地址”这个概念推广到数据结构，就相当于“指针”，这个在本科低年级大概就知道了。注意了，既然是线性的，那“地址”就可以看作是内存空间的“序号”，说明它的组织是有顺序的，“序号”或者说“序列号”正是“Serialization”机制的一种体现。为什么这么说呢？譬如我们有两个对象a和b,分别是类A和B的实例，它们都是可序列化的，而A和B都有一个类型为C的属性，根据前面我们说过的原则，C当然也必须是可序列化的。

1. import java.io.*;

2. ...

3. class A implements Serializable

4. {

5.   C c;

6.   ...

7. }

8.

9. class B implements Serializable

10. {

11.   C c;

12.   ...

13. }

14.

15. class C implements Serializable

16. {

17.   ...

18. }

19.

20. A a;

21. B b;

22. C c1;

23. ...


    注意，这里我们在实例化a和b的时候，有意让他们的c属性使用同一个C类型对象的引用，譬如c1，那么请试想一下，但我们序列化a和b的时候，它们的c属性在外部字节流（当然可以不仅仅是文件）里保存的是一份拷贝还是两份拷贝呢？序列化在这里使用的是一种类似于“指针”的方案：它为每个被序列化的对象标上一个“序列号”（serial number），但序列化一个对象的时候，如果其某个属性对象是已经被序列化的，那么这里只向输出流写入该属性的序列号；从字节流恢复被序列化的对象时，也根据序列号找到对应的流来恢复。这就是“序列化”名称的由来！这里我们看到“序列化”和“指针”是极相似的，只不过“指针”是内存空间的地址链，而序列化用的是外部流中的“序列号链”。
    使用“序列号”而不是内存地址来标识一个被序列化的对象，是因为从流中恢复对象到内存，其地址可能就未必是原来的地址了??我们需要的只是这些对象之间的引用关系，而不是死板的原始位置，这在RMI中就更是必要，在两台不同的机器之间传递对象（流），根本就不可能指望它们在两台机器上都具有相同的内存地址。
★更灵活的“序列化”：transient属性和Externalizable
    Serializable确实很方便，方便到你几乎不需要做任何额外的工作就可以轻松将内存中的对象保存到外部。但有两个问题使得Serializable的威力收到束缚：
    一个是效率问题，《Core Java 2》中指出，Serializable使用系统默认的序列化机制会影响软件的运行速度，因为需要为每个属性的引用编号和查号，再加上I/O操作的时间（I/O和内存读写差的可是一个数量级的大小），其代价当然是可观的。
    另一个困扰是“裸”的Serializable不可定制，傻乎乎地什么都给你序列化了，不管你是不是想这么做。其实你可以有至少三种定制序列化的选择。其中一种前面已经提到了，就是在implements Serializable的类里面添加私有的writeObject()和readObject()方法（这种Serializable就不裸了，java精华（2） - java world - Java World），在这两个方法里，该序列化什么，不该序列化什么，那就由你说了算了，你当然可以在这两个方法体里面分别调用ObjectOutputStream.defaultWriteObject()和ObjectInputStream.defaultReadObject()仍然执行默认的序列化动作（那你在代码上不就做无用功了？呵呵），也可以用ObjectOutputStream.writeObject()和ObjectInputStream.readObject()方法对你中意的属性进行序列化。但虚拟机一看到你定义了这两个方法，它就不再用默认的机制了。
    如果仅仅为了跳过某些属性不让它序列化，上面的动作似乎显得麻烦，更简单的方法是对不想序列化的属性加上transient关键字，说明它是个“暂态变量”，默认序列化的时候就不会把这些属性也塞到外部流里了。当然，你如果定义writeObject()和readObject()方法的化，仍然可以把暂态变量进行序列化。题外话，像transient、violate、finally这样的关键字初学者可能会不太重视，而现在有的公司招聘就偏偏喜欢问这样的问题
    再一个方案就是不实现Serializable而改成实现Externalizable接口。我们研究一下这两个接口的源代码，发现它们很类似，甚至容易混淆。我们要记住的是：Externalizable默认并不保存任何对象相关信息！任何保存和恢复对象的动作都是你自己定义的。Externalizable包含两个public的方法：

1. public void writeExternal(ObjectOutput out) throws IOException;

2. public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;


    乍一看这和上面的writeObject()和readObject()几乎差不多，但Serializable和Externalizable走的是两个不同的流程：Serializable在对象不存在的情况下，就可以仅凭外部的字节序列把整个对象重建出来；但Externalizable在重建对象时，先是调用该类的默认构造函数（即不含参数的那个构造函数）使得内存中先有这么一个实例，然后再调用readExternal方法对实例中的属性进行恢复，因此，如果默认构造函数中和readExternal方法中都没有赋值的那些属性，特别他们是非基本类型的话，将会是空（null）。在这里需要注意的是，transient只能用在对Serializable而不是Externalizable的实现里面。
★序列化与克隆
    从“可序列化”的递归定义来看，一个序列化的对象貌似对象内存映象的外部克隆，如果没有共享引用的属性的化，那么应该是一个深度克隆。关于克隆的话题有可以谈很多，这里就不细说了，有兴趣的话可以参考IBM developerWorks上的一篇文章：JAVA中的指针,引用及对象的clone

1.1.1.1.5 一点启示


    作为一个实际的应用，我在写那个简易的邮件客户端JExp的时候曾经对比过好几种保存Message对象（主要是几个关键属性和邮件的内容）到本地的方法，譬如XML、Properties等，最后还是选择了用序列化的方式，因为这种方法最简单， 大约可算是“学以致用”罢。这里“存取程序状态”其实只是一个引子话题罢了，我想说的是??就如同前面我们讨论的关于logging的话题一样??在Java面前对同一个问题你可以有很多种solution：熟悉文件操作的，你可能会觉得Properties、XML或Bean比较方便，然后又发现了还有Preferences这么一个东东，大概又会感慨“天外有天”了，等到你接触了很多种新方法以后，结果又会“殊途同归”，重新反省Serialization机制本身。这不仅是Java，科学也是同样的道理。

1.1.1.2 调整 JavaTM I/O 性能
1.1.1.2.1 加速I/O的基本规则

作为这个讨论的开始，这里有几个如何加速I/O的基本规则:

1. 避免访问磁盘

2. 避免访问底层的操作系统

3. 避免方法调用

4. 避免个别的处理字节和字符

很明显这些规则不能在所有的问题上避免，因为如果能够的话就没有实际的I/O被执行。考虑下面的计算文件中的新行符('\n')的三部分范例。

方法1: read方法

第一个方法简单的使用FileInputStream的read方法:

import java.io.*;

public class intro1 {

public static void main(String args[]) {

if (args.length != 1) {

System.err.println("missing filename");

System.exit(1);

}

try {

FileInputStream fis = new FileInputStream(args[0]);

int cnt = 0;

int b;

while ((b = fis.read()) != -1) {

if (b == '\n')

cnt++;

}

fis.close();

System.out.println(cnt);

} catch (IOException e) {

System.err.println(e);

}

}

}然而这个方法触发了大量的底层运行时系统调用－－FileInputStream.read－－返回文件的下一个字节的本机方法。

方法 2: 使用大缓冲区

第二种方法使用大缓冲区避免了上面的问题:

import java.io.*;

public class intro2 {

public static void main(String args[]) {

if (args.length != 1) {

System.err.println("missing filename");

System.exit(1);

}

try {

FileInputStream fis = new FileInputStream(args[0]);

BufferedInputStream bis = new BufferedInputStream(fis);

int cnt = 0;

int b;

while ((b = bis.read()) != -1) {

if (b == '\n')

cnt++;

}

bis.close();

System.out.println(cnt);

} catch (IOException e) {

System.err.println(e);

}

}

}

BufferedInputStream.read 从输入缓冲区获取下一个字节，仅仅只访问了一次底层系统。

方法 3: 直接缓冲

第三种方法避免使用 BufferedInputStream 而直接缓冲，因此排除了 read 方法的调用:

import java.io.*;

public class intro3 {

public static void main(String args[]) {

if (args.length != 1) {

System.err.println("missing filename");

System.exit(1);

}

try {

FileInputStream fis = new FileInputStream(args[0]);

byte buf[] = new byte[2048];

int cnt = 0;

int n;

while ((n = fis.read(buf)) != -1) {

for (int i = 0; i < n; i++) {

if (buf[i] == '\n')

cnt++;

}

}

fis.close();

System.out.println(cnt);

} catch (IOException e) {

System.err.println(e);

}

}

}

对于一个1 MB 的输入文件，以秒为单位的执行时间是:

  intro1    6.9 intro2    0.9 intro3    0.4

或者说在最慢的方法和最快的方法间是17比1的不同。

这个巨大的加速并不能证明你应该总是使用第三种方法，即自己做缓冲。这可能是一个错误的倾向特别是在处理文件结束事件时没有仔细的实现。在可读性上它也没有其它方法好。但是记住时间花费在哪儿了以及在必要的时候如何矫正是很有用。

方法2 或许是对于大多应用的 "正确" 方法.

1.1.1.2.2 缓冲

方法 2 和 3 使用了缓冲技术, 大块文件被从磁盘读取，然后每次访问一个字节或字符。缓冲是一个基本而重要的加速I/O 的技术,而且有几个类支持缓冲(BufferedInputStream 用于字节, BufferedReader 用于字符)。

一个明显得问题是: 缓冲区越大I/O越快吗？典型的Java缓冲区长1024 或者 2048 字节，一个更大的缓冲区有可能加速 I/O但是只能占很小的比重，大约5 到10%。

方法4: 整个文件

缓冲的极端情况是事先决定整个文件的长度，然后读取整个文件:

import java.io.*;

public class readfile {

public static void main(String args[]) {

if (args.length != 1) {

System.err.println("missing filename");

System.exit(1);

}

try {

int len = (int) (new File(args[0]).length());

FileInputStream fis = new FileInputStream(args[0]);

byte buf[] = new byte[len];

fis.read(buf);

fis.close();

int cnt = 0;

for (int i = 0; i < len; i++) {

if (buf[i] == '\n')

cnt++;

}

System.out.println(cnt);

} catch (IOException e) {

System.err.println(e);

}

}

}这个方法很方便，在这里文件被当作一个字节数组。但是有一个明显得问题是有可能没有读取一个巨大的文件的足够的内存。

缓冲的另一个方面是向窗口终端的文本输出。缺省情况下， System.out ( 一个PrintStream) 是行缓冲的，这意味着在遇到一个新行符后输出缓冲区被提交。对于交互来说这是很重要的，在那种情况下你可能喜欢在实际的输出前显示一个输入提示。

方法 5: 关闭行缓冲

行缓冲可以被禁止，像下面的例子那样:

import java.io.*;

public class bufout {

public static void main(String args[]) {

FileOutputStream fdout = new FileOutputStream(FileDescriptor.out);

BufferedOutputStream bos = new BufferedOutputStream(fdout, 1024);

PrintStream ps = new PrintStream(bos, false);

System.setOut(ps);

final int N = 100000;

for (int i = 1; i <= N; i++)

System.out.println(i);

ps.close();

}

}

这个程序输出整数1到100000缺省输出，比在缺省的行缓冲情况下快了三倍。

缓冲也是下面将要展示的例子的重要部分，在那里，缓冲区被用于加速文件随机访问。