Java提供了数种持有对象的方式，包括语言内置的Array，还有就是utilities中提供的容器类(container classes)，又称群集类(collection classes)。集合在java中非常重要，在讨论之前，先来看几个面试中的经典问题。
1 Collection 和 Collections的区别。
2 List, Set, Map是否继承自Collection接口。
3 ArrayList和Vector的区别。
4 HashMap和Hashtable的区别。
篇尾有答案，我们开始正题。

集合Collection接口
--Collection 是任何对象组，元素各自独立，通常拥有相同的套用规则。Set、List由它派生。
基本操作：增加元素add(Object obj); addAll(Collection c);
删除元素：remove(Object obj); removeAll(Collection c);
求交集：retainAll(Collection c);

访问/遍历集合元素的好办法是使用Iterator接口(迭代器用于取代Enumeration)
Public interface Iterator{
Public Boolean hasNext(0;
Public Object next(0;
Public void remove(0;
}

集set
--没有重复项目的集合
有三种特定类型的集可用
HashSet-基于散列表的集，加进散列表的元素要实现hashCode()方法
LinkedHashSet-对集迭代时，按增加顺序返回元素
TreeSet-基于（平衡）树的数据结构

清单List
--位置性集合。加进清单的元素可以加在清单中特定位置或加到末尾
有两个特定版本
ArrayList(数组表)-类似于Vector，都用于缩放数组维护集合。区别：
一.同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的
二.数据增长:当需要增长时,Vector默认增长为原来一培，而ArrayList却是原来的一半
LinkedList(链表)-是双向链表，每个节点都有两个指针指向上一节点和下一节点。
用在FIFO，用addList()加入元素 removeFirst()删除元素
用在FILO,用addFirst()/removeLast()
ListIterator提供双向遍历next() previous()，可删除、替换、增加元素

映射表Map
--用于关键字/数值对，像个Dictionary
处理Map的三种集合
关键字集KeySet()
数值集value()
项目集enrySet()
四个具体版本
HashMap-散列表的通用映射表
LinkedHashMap-扩展HashMap，对返回集合迭代时，维护插入顺序
WeakHashMap-基于弱引用散列表的映射表，如果不保持映射表外的关键字的引用，则内存回收程序会回收它
TreeMap-基于平衡树的映射表

Collections类，用于同步集合，还能改变集合只读方式的类
e.g.:
Map mp=new HashMap()
mp=Collections.synchronizedMap(mp); //生成线程安全的映射表
mp=Collections.unmodifiableMap(mp); //生成只读映射表

Comparable 自然顺序的排序类 Comparator 面向树的集合排序类

容器分类学(Container taxonomy)
集合接口： Collection List Set;Map Iterator ListIterator。
抽象类： AbstractCollection AbstractList AbstractSet AbstractMap AbstractSequentiaList。

老版本中的集合类型
Vector类
Vector，就是向量。一种异构的混合体，可以动态增加容量。对它的操作简要如下
比如我们有一个Vector: Vector myVec=new Vector(a_Array.length)
取得vector的长度:myVec.size();
赋值：set(int position,Object obj) / setElementAt(Object obj, int position) –不支持动态增长
add(Object obj )/ addElement(Object obj) 在Vector末尾加入对象
e.g.：myVec.add(new a_Array[0]);
取出元素：get(int position) / getElement(int position)

Stack类
是Vector的子类。就是数据结构里讲滥了的堆栈（这个词可简称栈，不要混淆于heap-堆）。后进先出的存取方式。
Stack()构造空栈
Empty()叛空
Search()检查堆栈是否有元素
Peek()取得栈顶元素
Pop()弹栈
Push()入栈

Enumeration接口
Dictionary类
字典。关键字/数值方式存取数据，如果映射没有此关键字，取回null。

Hashtable类
是Dictionary结构的具体实现。

面试题答案
1、Collection 和 Collections的区别。
Collections是个java.util下的类，它包含有各种有关集合操作的静态方法。Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作
Collection是集合类的上级接口，即是java.util下的接口，它是各种集合结构的父接口。继承于它的接口主要有Set 和List。
2、List, Set, Map是否继承自Collection接口? List，Set是，Map不是
3、ArrayList和Vector的区别。
一.同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的
二.数据增长:当需要增长时,Vector默认增长为原来一培，而ArrayList却是原来的一半
4、HashMap和Hashtable的区别
一.历史原因:Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现
二.同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的
三.值：只有HashMap可以让你将空值作为一个表的条目的key或value

补充有关集合类的几个面试题目如下:
1、Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别
答：Set里的元素是不能重复的，那么用iterator()方法来区分重复与否。equals()是判读两个Set是否相等
equals()和==方法决定引用值是否指向同一对象equals()在类中被覆盖，为的是当两个分离的对象的内容和类型相配的话，返回真值

在Java类库中出现的第一个关联的集合类是Hashtable，它是JDK 1.0的一部分。Hashtable提供了一种易于使用的、线程安全的、关联的map功能，这当然也是方便的。然而，线程安全性是凭代价换来的——Hashtable的所有方法都是同步的。 此时，无竞争的同步会导致可观的性能代价。Hashtable的后继者HashMap是作为JDK1.2中的集合框架的一部分出现的，它通过提供一个不同步的基类和一个同步的包装器Collections.synchronizedMap，解决了线程安全性问题。 通过将基本的功能从线程安全性中分离开来，Collections.synchronizedMap允许需要同步的用户可以拥有同步，而不需要同步的用户则不必为同步付出代价。

Hashtable 和 synchronizedMap所采取的获得同步的简单方法（同步Hashtable中或者同步的Map包装器对象中的每个方法）有两个主要的不足。首先，这种方法对于可伸缩性是一种障碍，因为一次只能有一个线程可以访问hash表。 同时，这样仍不足以提供真正的线程安全性，许多公用的混合操作仍然需要额外的同步。虽然诸如get() 和 put()之类的简单操作可以在不需要额外同步的情况下安全地完成，但还是有一些公用的操作序列 ，例如迭代或者put-if-absent（空则放入），需要外部的同步，以避免数据争用。

有条件的线程安全性
同步的集合包装器 synchronizedMap 和 synchronizedList，有时也被称作有条件地线程安全——所有 单个的操作都是线程安全的，但是多个操作组成的操作序列却可能导致数据争用，因为在操作序列中控制流取决于前面操作的结果。 清单1中第一片段展示了公用的put-if-absent语句块——如果一个条目不在Map中，那么添加这个条目。不幸的是， 在containsKey()方法返回到put() 方法被调用这段时间内，可能会有另一个线程也插入一个带有相同键的值。如果您想确保只有一次插入，您需要用一个对Map m进行同步的同步块将这一对语句包装起来。

清单1中其他的例子与迭代有关。在第一个例子中，List.size() 的结果在循环的执行期间可能会变得无效，因为另一个线程可以从这个列表中删除条目。如果时机不得当，在刚好进入循环的最后一次迭代之后有一个条目被另一个线程删除 了，则List.get()将返回null，而doSomething() 则很可能会抛出一个NullPointerException异常。那么，采取什么措施才能避免这种情况呢？如果当您正在迭代一个List 时另一个线程也 可能正在访问这个 List，那么在进行迭代时您必须使用一个synchronized 块将这个List 包装起来， 在List 1 上同步，从而锁住整个List。这样做虽然解决了数据争用问题，但是在并发性方面付出了更多的代价，因为在迭代期间锁住整个List会阻塞其他线程，使它们在很长一段时间内不能访问这个列表。

集合框架引入了迭代器，用于遍历一个列表或者其他集合，从而优化了对一个集合中的元素进行迭代的过程。然而，在java.util 集合类中实现的迭代器极易崩溃，也就是说，如果在一个线程正在通过一个Iterator遍历集合时，另一个线程也来修改这个 集合，那么接下来的Iterator.hasNext() 或 Iterator.next()调用将抛出ConcurrentModificationException异常。就拿 刚才这个例子来讲，如果想要防止出现ConcurrentModificationException异常，那么当您正在进行迭代时，您必须 使用一个在 List l上同步的synchronized块将该 List 包装起来，从而锁住整个 List。（或者，您也可以调用List.toArray()，在 不同步的情况下对数组进行迭代，但是如果列表比较大的话这样做代价很高）。

												
    Map m = Collections.synchronizedMap(new HashMap());
    List l = Collections.synchronizedList(new ArrayList());

    // put-if-absent idiom -- contains a race condition
    // may require external synchronization
    if (!map.containsKey(key))
      map.put(key, value);

    // ad-hoc iteration -- contains race conditions
    // may require external synchronization
    for (int i=0; i<list.size(); i++) {
      doSomething(list.get(i));
    }

    // normal iteration -- can throw ConcurrentModificationException
    // may require external synchronization
    for (Iterator i=list.iterator(); i.hasNext(); ) {
      doSomething(i.next());
    }

										

信任的错觉
synchronizedList 和 synchronizedMap提供的有条件的线程安全性也带来了一个隐患——开发者会假设，因为这些集合都是同步的，所以它们都是线程安全的，这样一来他们对于正确地同步混合操作这件事就会疏忽。其结果是尽管表面上这些程序在负载较轻的时候能够正常工作，但是一旦负载较重，它们就会开始抛出NullPointerException 或 ConcurrentModificationException。

可伸缩性问题
可伸缩性指的是一个应用程序在工作负载和可用处理资源增加时其吞吐量的表现情况。一个可伸缩的程序能够通过使用更多的处理器、内存或者I/O带宽来相应地处理更大的工作负载。锁住某个共享的资源以获得独占式的访问这种做法会形成可伸缩性瓶颈——它使其他线程不能访问那个资源，即使有空闲的处理器可以调用那些线程也无济于事。为了取得可伸缩性，我们必须消除或者减少我们对独占式资源锁的依赖。

同步的集合包装器以及早期的Hashtable 和 Vector类带来的更大的问题是，它们在单个的锁 上进行同步。这意味着一次只有一个线程可以访问集合，如果有一个线程正在读一个Map，那么所有其他想要读或者写这个Map的线程就必须等待。最常见的Map操作，get() 和 put()，可能比表面上要进行更多的处理——当遍历一个hash表的bucket以期找到某一特定的key时，get()必须对大量的候选bucket调用Object.equals()。如果key类所使用的hashCode()函数不能将value均匀地分布在整个hash表范围内，或者存在大量的hash冲突，那么某些bucket链就会比其他的链长很多，而遍历一个长的hash链以及对该hash链上一定百分比的元素调用 equals()是一件很慢的事情。在上述条件下，调用 get() 和 put() 的代价高的问题不仅仅是指访问过程的缓慢，而且，当有线程正在遍历那个hash链时，所有其他线程都被锁在外面，不能访问这个Map。

（哈希表根据一个叫做hash的数字关键字（key）将对象存储在bucket中。hash value是从对象中的值计算得来的一个数字。每个不同的hash value都会创建一个新的bucket。要查找一个对象，您只需要计算这个对象的hash value并搜索相应的bucket就行了。通过快速地找到相应的bucket，就可以减少您需要搜索的对象数量了。译者注）

get()执行起来可能会占用大量的时间，而在某些情况下，前面已经作了讨论的有条件的线程安全性问题会让这个问题变得还要糟糕得多。清单1 中演示的争用条件常常使得对单个集合的锁在单个操作执行完毕之后还必须继续保持一段较长的时间。如果您要在整个迭代期间都保持对集合的锁，那么其他的线程就会在锁外停留很长的一段时间，等待解锁。

实例：一个简单的cache
Map在服务器应用中最常见的应用之一就是实现一个cache。服务器应用可能需要缓存文件内容、生成的页面、数据库查询的结果、与经过解析的XML文件相关的DOM树，以及许多其他类型的数据。cache的主要用途是重用前一次处理得出的结果 以减少服务时间和增加吞吐量。cache工作负载的一个典型的特征就是检索大大多于更新，因此（理想情况下）cache能够提供非常好的get()性能。不过，使用会 妨碍性能的cache还不如完全不用cache。

如果使用 synchronizedMap 来实现一个cache，那么您就在您的应用程序中引入了一个潜在的可伸缩性瓶颈。因为一次只有一个线程可以访问Map，这 些线程包括那些要从Map中取出一个值的线程以及那些要将一个新的(key, value)对插入到该map中的线程。

减小锁粒度
提高HashMap的并发性同时还提供线程安全性的一种方法是废除对整个表使用一个锁的方式，而采用对hash表的每个bucket都使用一个锁的方式（或者，更常见的是，使用一个锁池，每个锁负责保护几个bucket） 。这意味着多个线程可以同时地访问一个Map的不同部分，而不必争用单个的集合范围的锁。这种方法能够直接提高插入、检索以及移除操作的可伸缩性。不幸的是，这种并发性是以一定的代价换来的——这使得对整个 集合进行操作的一些方法（例如 size() 或 isEmpty()）的实现更加困难，因为这些方法要求一次获得许多的锁，并且还存在返回不正确的结果的风险。然而，对于某些情况，例如实现cache，这样做是一个很好的折衷——因为检索和插入操作比较频繁，而 size() 和 isEmpty()操作则少得多。

ConcurrentHashMap
util.concurrent 包中的ConcurrentHashMap类（也将出现在JDK 1.5中的java.util.concurrent包中）是对Map的线程安全的实现，比起synchronizedMap来，它提供了好得多的并发性。多个读操作几乎总可以并发地执行，同时进行的读和写操作通常也能并发地执行，而同时进行的写操作仍然可以不时地并发进行（相关的类也提供了类似的多个读线程的并发性，但是，只允许有一个活动的写线程）。ConcurrentHashMap被设计用来优化检索操作；实际上，成功的 get() 操作完成之后通常根本不会有锁着的资源。要在不使用锁的情况下取得线程安全性需要一定的技巧性，并且需要对Java内存模型（Java Memory Model）的细节有深入的理解。ConcurrentHashMap实现，加上util.concurrent包的其他部分，已经被研究正确性和线程安全性的并发专家所正视。在下个月的文章中，我们将看看ConcurrentHashMap的实现的细节。

ConcurrentHashMap 通过稍微地松弛它对调用者的承诺而获得了更高的并发性。检索操作将可以返回由最近完成的插入操作所插入的值，也可以返回在步调上是并发的插入操作所添加的值（但是决不会返回一个没有意义的结果）。由ConcurrentHashMap.iterator()返回的Iterators将每次最多返回一个元素，并且决不会抛出ConcurrentModificationException异常，但是可能会也可能不会反映在该迭代器被构建之后发生的插入操作或者移除操作。在对 集合进行迭代时，不需要表范围的锁就能提供线程安全性。在任何不依赖于锁整个表来防止更新的应用程序中，可以使用ConcurrentHashMap来替代synchronizedMap或Hashtable。

上述改进使得ConcurrentHashMap能够提供比Hashtable高得多的可伸缩性，而且，对于很多类型的公用案例（比如共享的cache）来说，还不用损失其效率。

好了多少？
表 1对Hashtable 和 ConcurrentHashMap的可伸缩性进行了粗略的比较。在每次运行过程中，n 个线程并发地执行一个死循环，在这个死循环中这些线程从一个Hashtable 或者 ConcurrentHashMap中检索随机的key value，发现在执行put()操作时有80%的检索失败率，在执行操作时有1%的检索成功率。测试所在的平台是一个双处理器的Xeon系统，操作系统是Linux。数据显示了10,000,000次迭代以毫秒计的运行时间，这个数据是在将对ConcurrentHashMap的操作标准化为一个线程的情况下进行统计的。您可以看到，当线程增加到多个时，ConcurrentHashMap的性能仍然保持上升趋势，而Hashtable的性能则随着争用锁的情况的出现而立即降了下来。

比起通常情况下的服务器应用，这次测试中线程的数量看上去有点少。然而，因为每个线程都在不停地对表进行操作，所以这与实际环境下使用这个表的更多数量的线程的争用情况基本等同。

表 1.Hashtable 与 ConcurrentHashMap在可伸缩性方面的比较

CopyOnWriteArrayList
在那些遍历操作大大地多于插入或移除操作的并发应用程序中，一般用CopyOnWriteArrayList类替代ArrayList。如果是用于存放一个侦听器（listener）列表，例如在AWT或Swing应用程序中，或者在常见的JavaBean中，那么这种情况很常见（相关的CopyOnWriteArraySet使用一个CopyOnWriteArrayList来实现Set接口） 。

如果您正在使用一个普通的ArrayList来存放一个侦听器列表，那么只要该列表是可变的，而且可能要被多个线程访问，您 就必须要么在对其进行迭代操作期间，要么在迭代前进行的克隆操作期间，锁定整个列表，这两种做法的开销都很大。当对列表执行会引起列表发生变化的操作时，CopyOnWriteArrayList并不是为列表创建一个全新的副本，它的迭代器肯定能够返回在迭代器被创建时列表的状态，而不会抛出ConcurrentModificationException。在对列表进行迭代之前不必克隆列表或者在迭代期间锁 定列表，因为迭代器所看到的列表的副本是不变的。换句话说，CopyOnWriteArrayList含有对一个不可变数组的一个可变的引用，因此，只要保留好那个引用，您就可以获得不可变的线程安全性的好处，而且不用锁 定列表。

结束语
同步的集合类Hashtable 和 Vector，以及同步的包装器类 Collections.synchronizedMap 和 Collections.synchronizedList，为Map 和 List提供了基本的有条件的线程安全的实现。然而，某些因素使得它们并不适用于具有高度并发性的应用程序中——它们的 集合范围的单锁特性对于可伸缩性来说是一个障碍，而且，很多时候还必须在一段较长的时间内锁定一个集合，以防止出现ConcurrentModificationExceptions异常。 ConcurrentHashMap 和 CopyOnWriteArrayList实现提供了更高的并发性，同时还保住了线程安全性，只不过在对其调用者的承诺上打了点折扣。ConcurrentHashMap 和 CopyOnWriteArrayList并不是在您使用HashMap 或 ArrayList的任何地方都一定有用，但是它们是设计用来优化某些特定的公用解决方案的。许多并发应用程序将从对它们的使用中获得好处。

相信大家都能看懂，这里就不解释了，关于使用我举个例子字符串转换成Int类型  如下

Javadoc给出Collections类最完整的描述：“这一个类包含可以操作或返回集合的专用静态类。”

使用copy方法可以将一个java.util.List复制到其他：

Collections.copy(newList, sourceList);

如果你需要使一个列表随机化，可以调用shuffle方法：

shuffle(list);

这一方法可以记录列表中的内容。如果你想返回随机列表的来源处，可以调用它的sibling方法：

shuffle(List list, Random random)

如果你需要建立一个不能更改的集合，可以使用unmodifiableCollection(Collection c)方法。这一方法包含sibling方法，sibling方法可以处理特定类型的Set, List, 和Map。对于Set和Map，你可以通过使用一些sorted方法来获得结果对象的排序。

List newList = Collections.unmodifiableList(myList);

如果你是在编写需要Enumeration对象操作方面的代码，可以充分利用enumeration方法：

Enumeration e = Collections.enumeration(collection);

当你想使用一个简单对象来代替多个对象的时候，请使用fill(List list, Object obj)方法。

其他的，当你需要具有相同对象的多个引用的列表时，可以使用nCopies(int n, Object o)方法。

当你需要在其他列表中查找一个列表的位置时，请使用indexOfSubList(List source, List target)或者lastIndexOfSubList(List source, List target)方法。如果目标列表存在于其他列表中，这一方法将返回包含列表起始位置的索引。如果在列表中无法找到目标列表，这两种方法都返回-1。

如果你需要使一个列表的排序相反化(反序)，则可以调用reverse方法，这一方法可以使列表现有元素的序号重新排序。

正如你所看到的，collections类包含很多方法。也许你很少使用到某些方法，但你可以会经常使用到其中的一些。

同样，也存在三种空的集合域。EMPTY_LIST, EMPTY_MAP, 和EMPTY_SET可以帮助你避免不必要的对象生成，特别是当返回数据的空集合的时候。例如：

public List getData(Criteria c) {
  ...
  
  if ( noData ) {
      return Collections.EMPTY_LIST;
  }
  
  // otherwise
  // gather and return data
  ... 
}

你可以建立一个没有元素的列表，但是当可以避免建立对象的时候最好不要建立对象。

　　在这之前，先介绍一下负载因子和容量的属性。大家都知道其实一个 HashMap 的实际容量就 因子*容量，其默认值是 16×0.75＝12； 这个很重要，对效率很一定影响！当存入HashMap的对象超过这个容量时，HashMap 就会重新构造存取表。这就是一个大问题，我后面慢慢介绍，反正，如果你已经知道你大概要存放多少个对象，最好设为该实际容量的能接受的数字。

　　两个关键的方法，put和get：

　　先有这样一个概念，HashMap是声明了 Map，Cloneable, Serializable 接口，和继承了 AbstractMap 类，里面的 Iterator 其实主要都是其内部类HashIterator 和其他几个 iterator 类实现，当然还有一个很重要的继承了Map.Entry 的 Entry 内部类，由于大家都有源代码，大家有兴趣可以看看这部分，我主要想说明的是 Entry 内部类。它包含了hash，value，key 和next 这四个属性，很重要。put的源码如下

　　public Object put(Object key, Object value) {
　　Object k = maskNull(key);

　　这个就是判断键值是否为空，并不很深奥，其实如果为空，它会返回一个static Object 作为键值，这就是为什么HashMap允许空键值的原因。

　　int hash = hash(k);
　　int i = indexFor(hash, table.length);

　　这连续的两步就是 HashMap 最牛的地方！研究完我都汗颜了，其中 hash 就是通过 key 这个Object的 hashcode 进行 hash，然后通过 indexFor 获得在Object table的索引值。

　　table？？？不要惊讶，其实HashMap也神不到哪里去，它就是用 table 来放的。最牛的就是用 hash 能正确的返回索引。其中的hash算法，我跟JDK的作者 Doug 联系过，他建议我看看《The art of programing vol3》可恨的是，我之前就一直在找，我都找不到，他这样一提，我就更加急了，可惜口袋空空啊！！！

　　不知道大家有没有留意 put 其实是一个有返回的方法，它会把相同键值的 put 覆盖掉并返回旧的值！如下方法彻底说明了 HashMap 的结构，其实就是一个表加上在相应位置的Entry的链表：

for (Entry e = table[i]; e != null; e = e.next) {
　if (e.hash == hash && eq(k, e.key)) {
　　Object oldvalue = e.value;
　　e.value = value; //把新的值赋予给对应键值。
　　e.recordAccess(this); //空方法，留待实现
　　return oldvalue; //返回相同键值的对应的旧的值。
　}
}
modCount++; //结构性更改的次数
addEntry(hash, k, value, i); //添加新元素，关键所在！
return null; //没有相同的键值返回
}

　　我们把关键的方法拿出来分析：

　　void addEntry(int hash, Object key, Object value, int bucketIndex) {
　　table[bucketIndex] = new Entry(hash, key, value, table[bucketIndex]); 

　　因为 hash 的算法有可能令不同的键值有相同的hash码并有相同的table索引，如：key＝“33”和key＝Object g的hash都是－8901334，那它经过indexfor之后的索引一定都为i，这样在new的时候这个Entry的next就会指向这个原本的table[i]，再有下一个也如此，形成一个链表，和put的循环对定e.next获得旧的值。到这里，HashMap的结构，大家也十分明白了吧？

　　if (size++ >= threshold) //这个threshold就是能实际容纳的量
　　resize(2 * table.length); //超出这个容量就会将Object table重构

　　所谓的重构也不神，就是建一个两倍大的table（我在别的论坛上看到有人说是两倍加1，把我骗了），然后再一个个indexfor进去！注意！！这就是效率！！如果你能让你的HashMap不需要重构那么多次，效率会大大提高！

　　说到这里也差不多了，get比put简单得多，大家，了解put，get也差不了多少了。对于collections我是认为，它是适合广泛的，当不完全适合特有的，如果大家的程序需要特殊的用途，自己写吧，其实很简单。（作者是这样跟我说的，他还建议我用LinkedHashMap,我看了源码以后发现，LinkHashMap其实就是继承HashMap的，然后override相应的方法，有兴趣的同人，自己looklook）建个 Object table，写相应的算法，就ok啦。

　　举个例子吧，像 Vector，list 啊什么的其实都很简单，最多就多了的同步的声明，其实如果要实现像Vector那种，插入，删除不多的，可以用一个Object table来实现，按索引存取，添加等。

　　如果插入，删除比较多的，可以建两个Object table，然后每个元素用含有next结构的，一个table存，如果要插入到i，但是i已经有元素，用next连起来，然后size＋＋，并在另一个table记录其位置。