j2me中vector的使用

Vector是java.util包的类，功能是实现了一个动态增长的数组，并为每个包含的元素分配一下整数索引号，这样就可以根据索引号删除、插入一个元素，也可以修改、获得一个元素的值。既然是动态数组，也可以在应用中来调整、裁减数组的长度。Vector的方法都是同步的(Synchronized), 是线程安全的(thread-safe)。
1. 存储管理
    Vector是动态数组，因此随着对象元素的添加，当长度(容量)不足时，会自动增长，增长的增量和Vector对象的初始化构造有关。Vector有三个不同的构造函数，如下所示。
(1)指定初始容量和非0容量增量的构造函数
函数原型：public Vector(int initialCapacity, int capacityIncrement);
    使用此构造函数，在创建实例时即指定初始的容量以及容量增量(如果capacityIncrement为0，则会抛出IllegalArgumentException异常)。如Vector v1 = new Vector(8,3); v1的初始容量为8，增量为3；这样当容量不足时，自动将容量增长capacityIncrement。
测试代码：

1.   Vector v1 = new Vector(8,3);
2.   Integer no;
3.   for(int i =0; i < 15; i++)
4.   {
5.    no = new Integer(i);
6.    v1.addElement(no);
7.   }
8.   System.out.println("Vector v1 = new Vector(8， 3)");
9.   System.out.println("Added fifteen object continuous");
10.   System.out.println("capacity of v1:" + v1.capacity());
11.   System.out.println("size of v1:" + v1.size());
12.   System.out.println("-------------------------");

    上例中，v1在添加15个元素后最终的容量为8+3+3+3=17。
(2)仅指定初始容量的构造函数
函数原型：public Vector(int initialCapacity);
    此构造函数在内部调用capacityIncrement为0的Vector(int initialCapacity, int capacityIncrement)构造函数。在容量不足时，容量自动成倍增加。如Vecotr v2=new Vector(8); v2的初始容量为8。
测试代码：

1.   Vector v2 = new Vector(8);
2.   for(int i =0; i < 15; i++)
3.   {
4.    no = new Integer(i);
5.    v2.addElement(no);
6.   } 
7.   System.out.println("Vector v2 = new Vector(8)");
8.   System.out.println("Added fifteen object continuous");
9.   System.out.println("capacity of v2:" + v2.capacity());
10.   System.out.println("size of v2:" + v2.size());
11.   System.out.println("-------------------------");

    上例中，v2在添加15个元素后最终的容量为8*2=16。如果添加的元素的数目超过16，如17，则最终的容量为8*2*2=32。因此，可以看出，在这种情况下，如果不能很好的设置初始容量，可能会造成较大的空间浪费。
(3)不带参数的构造函数
函数原型：public Vector();
    此构造函数在内部调用initialCapacity为10的Vector(int initialCapacity)构造函数。在容量不足时，容量也是自动成倍增加。
测试代码：

1.   Vector v3 = new Vector();
2.   for(int i =0; i < 15; i++)
3.   {
4.    no = new Integer(i);
5.    v3.addElement(no);
6.   }   
7.   System.out.println("Vector v3 = new Vector()");
8.   System.out.println("Added fifteen object continuous");
9.   System.out.println("capacity of v3:" + v3.capacity());
10.   System.out.println("size of v3:" + v3.size());
11.   System.out.println("-------------------------");

    上例中，v2在添加15个元素后最终的容量为10*2=20。如果添加的元素数目超过20，则容量变为10*2*2=40，以此类推。可以看出，这种情况下，可能造成的空间浪费比(2)还可能严重。
(4)容量动态增长的内部实现
    当容量不够用时，就重新初始化一个容量较大新数组，然后使用System.arraycopy()函数将原有的数组copy到新的数组当中。System.arraycopy()是一个由系统平台来实现的函数，这样的系统调用性能比较高。(在重新设置容量以及裁减容量时也是通过System.arraycopy()来实现的)

1.     private void ensureCapacityHelper(int minCapacity)
2.     {
3.         int oldCapacity = elementData.length;
4.         Object oldData[] = elementData;
5.         int newCapacity = capacityIncrement <=0 ? oldCapacity * 2 : oldCapacity + capacityIncrement;
6.         if(newCapacity < minCapacity)
7.             newCapacity = minCapacity;
8.         elementData = new Object[newCapacity];
9.         System.arraycopy(((Object) (oldData)), 0, ((Object) (elementData)),0, elementCount);
10.     }

(5)Vector的优缺点
    使用Vector，在保存大量数据时，可以采用较大的初始容量initialCapacity、较大的增量capacityIncrement，这样可以减少分配内存和数组拷贝的次数，但是这样带来的副作用是可能会造成较大的内存空间的浪费。
    因此在使用时要合理选择注意initialCapacity（初始容量）和capacityIncrement（增量）的设置，同时避免使用不带参数的构造函数。

2.Vector保存数据的形式
    它是通过Object[]来存储数据，因此不能容纳原始类型(primitive type，如int等)的数据。但是并不是真正将对象保存起来，而是保存对象的引用；因此尽管在容量动态增长时，会发生数组的复制，但是也仅仅是对象引用的复制，不会发生对象数据自身的复制。另外一方面，由于JAVA的垃圾回收策略，某个对象只有在没有指向该对象的引用时，垃圾回收器才会自动将其自动释放。因此Vector保存的是对象的引用，只要Vector不释放，那么那些被引用的对象也不会被释放，这在内存有限的设备中非常重要，因为如果有太多的对象不能被释放则可能会导致内存的溢出。
测试代码：

1.   Vector v4 = new Vector();
2.   ItemObject io = new ItemObject();
3.   for(int i =0; i < 60; i++)
4.   {
5.    io.n = i;
6.    v4.addElement(io);
7.   }
8.   io = null;
9.   for(Enumeration enumobj = v4.elements(); enumobj.hasMoreElements(); )
10.   {
11.    System.out.println(((ItemObject)enumobj.nextElement()).n);
12.   }
13.   System.out.println("------------------");

class ItemObject
{
public int n;
public ItemObject(int i)
{
  n = i;
}
public ItemObject()
{
  n = -1;
}
}

  结果Vector中保存的都是同一个ItemObject对象的引用(n=59)，可以将io.n = i; 修改为io = new ItemObject(i); 。另外，尽管在使用玩io对象后，在程序中显式的加以"释放"(io = null;)，但是由于其对象的引用还保存在v4中，因此并不会真正的释放。
3. 遍历Vector动态数组
    在遍历Vector数组时，尽管可以根据size方法获得元素的个数，然后根据索引来进行遍历，但是使用枚举类Enumeration来获得Vector数组的所有元素，然后根据nextElement()方法来进行遍历是一个很好的选择(如上例)。当然也可以根据索引来获取指定的元素。
4. 结束语
    Vector还实现了获得一个给定的对象数据在Vector中索引的方法indexOf方法；以及判定Vector中是否存在给定的对象数据的contains方法，还有根据给定的对象数据删除数组中给定给定数据的元素的方法removeElement方法(这两个方法在内部都先调用indexOf方法先获得给定对象数据的索引)。这几个个方法在内部都是通过对象的equals方法实现的，因此对于自定义对象应该覆盖equals方法。

参考资料:
1. Fantasy Soft. 此Vector非彼Vector. http://www.cnblogs.com/perhaps/archive/2004/08/05/30413.html
2. hunhun1981的专栏. j2me经验总结之Vector. http://blog.csdn.net/hunhun1981/archive/2007/09/26/1801153.aspx
3. 谁与争锋刀剑啸. Vector的用法. http://gophinight.blogchina.com/blog/279509.html
4. Sun Microsystems Inc. java.util.Vector. J2ME Wireless Toolkit 2.2文档