1.1.1.1.4 向量类Vector Java.util.Vector提供了向量(Vector)类以实现类似动态数组的功能。在Java语言中。正如在一开始就提到过,是没有指针概念的,但如果能正确灵活地使用指针又确实可以大大提高程序的质量,比如在C、C++中所谓“动态数组”一般都由指针来实现。为了弥补这点缺陷,Java提供了丰富的类库来方便编程者使用,Vector类便是其中之一。事实上,灵活使用数组也可完成向量类的功能,但向量类中提供的大量方法大大方便了用户的使用。- ?4 b( M8 w) M; I3 f: l& C0 |' o* H
创建了一个向量类的对象后,可以往其中随意地插入不同的类的对象,既不需顾及类型也不需预先选定向量的容量,并可方便地进行查找。对于预先不知或不愿预先定义数组大小,并需频繁进行查找、插入和删除工作的情况,可以考虑使用向量类。$ a# q" s4 `8 E" S9 \' @
向量类提供了三种构造方法:
2 u) l! [4 `# n. s5 E, | public vector()
! ^+ Y5 E! p$ k$ o7 C, { public vector(int initialcapacity,int capacityIncrement) X7 ~' h5 K. U, j' M5 f( y
public vector(int initialcapacity)
, G$ F7 @4 b, Y/ b9 L 使用第一种方法,系统会自动对向量对象进行管理。若使用后两种方法,则系统将根据参数initialcapacity设定向量对象的容量(即向量对象可存储数据的大小),当真正存放的数据个数超过容量时,系统会扩充向量对象的存储容量。参数capacityIncrement给定了每次扩充的扩充值。当capacityIncrement为0时,则每次扩充一倍。利用这个功能可以优化存储。
7 e( q/ K$ R \8 W 在Vector类中提供了各种方法方便用户使用:3 X' A1 V. y$ }! T/ |2 |
■插入功能! h1 A5 d f! G3 q0 ~
(1)public final synchronized void addElement(Object obj)
* p$ _7 W5 r& L; g- F 将obj插入向量的尾部。obj可以是任何类的对象。对同一个向量对象,可在其中插入不同类的对象。但插入的应是对象而不是数值,所以插入数值时要注意将数值转换成相应的对象。, M6 w: G* g. }$ d/ }
例 要插入一个整数1时,不要直接调用v1.addElement(1),正确的方法为:7 a% D( n2 u6 f3 M v# l
Vector v1=new Vector();
: e* R3 E' @2 @7 x% ] Integer integer1=new Integer(1);
1 U, q6 J$ d0 u v1.addElement(integer1);' h X, f9 |0 X) x
(2)public final synchronized void setElementAt(object obj,int index)3 K+ A$ a B0 V. Z
将index处的对象设成obj,原来的对象将被覆盖。) P2 u, A5 O/ E9 E/ s5 J
(3)public final synchronized void insertElementAt(Object obj,int index)8 E% A# t; g' u. m
在index指定的位置插入obj,原来对象以及此后的对象依次往后顺延。
# z' l3 `$ v2 u+ d ■删除功能* b6 f" k& A- h8 g
(1)public final synchronized void removeElement(Object obj)
- w' \. G& d% O1 e- F$ H 从向量中删除obj。若有多个存在,则从向量头开始试,删除找到的第一个与obj相同的向量成员。; a, d% b/ ?; D! q! Z3 A9 B4 h
(2)public final synchronized void removeAllElement()
4 m9 O h( v P5 y3 w0 j 删除向量中所有的对象。
1 T5 S4 Q. N/ b) t& R* G/ p (3)public final synchronized void removeElementlAt(int index)
; C9 g9 ]' Y* ?3 Q* y7 u: @ 删除index所指的地方的对象。$ U- r* D; r7 v7 z' U1 n" |. k
■查询搜索功能" r6 E7 D* \; D7 L% e
(1)public final int indexOf(Object obj)
" u9 v6 @6 c' K- h 从向量头开始搜索obj ,返回所遇到的第一个obj对应的下标,若不存在此obj,返回-1。
# C) H, [7 f2 y6 Q' r7 y (2)public final synchronized int indexOf(Object obj,int index)% O! m; p0 I7 \# M3 c0 W) C
从index所表示的下标处开始搜索obj。$ ^# V" t7 R( Z: k7 S# `
(3)public final int lastIndexOf(Object obj)/ j) W' V, v1 b- V) i' A
从向量尾部开始逆向搜索obj。
: d& C: K8 R" Z. m7 c (4)public final synchronized int lastIndexOf(Object obj,int index)8 U! b+ z0 {0 \+ d: Q$ x/ Z0 n
从index所表示的下标处由尾至头逆向搜索obj。
, ^! d" z8 Q2 M D3 i (5)public final synchronized Object firstElement()
4 [/ H4 B$ a( I! A$ H0 ] 获取向量对象中的首个obj。: ^$ v- ]9 a, b9 |
(6)public final synchronized Object lastelement()
; z n+ M0 d0 d# C 获取向量对象中的最后一个obj。
6 ?" Y6 j; y. }" v) z- S 了解了向量的最基本的方法后,我们来看一下例8.3VectorApp.java。& F& X9 m! d( ^8 f* j$ E' @2 J3 C
例1.3 VectorApp.java。
# h# V& m8 o; f2 z8 ]/ P import java.util.Vector;
3 \, Z8 I2 {0 G: |# o import java.lang.*;//这一句不应该要,但原文如此
9 p* c- i2 p9 H$ h import java.util.Enumeration;
4 p' I, X# Z) p% b$ W# z public class VectorApp{% b8 ]( h/ Y/ N, L# v* T+ n
public static void main(String[] args){5 @; g6 x7 d) _. r
Vector v1=new Vector();
3 t* N7 N" R& x% U5 { Integer integer1=new Integer(1);
0 c# p7 h% h/ F( r+ ^" Q, l v1.addElement("one");
) F5 R4 I8 ^6 Z: W6 }' @" k9 j //加入的为字符串对象
/ m3 W9 N/ ~# ]! m3 U v1.addElement(integer1);
- Q, U7 y7 L4 |" i! B v1.addElement(integer1);" p+ _- \2 a! I( i8 `
//加入的为Integer的对象
" o- [. j8 k2 S7 ^. k9 K7 l v1.addElement("two");
; A2 k5 P$ q* y p3 l' i" _0 }/ Q v1.addElement(new Integer(2));$ }8 |0 w, w* ]4 w6 E
v1.addElement(integer1);4 f/ L1 I2 |2 n6 x& H8 B7 R ^
v1.addElement(integer1);
& D3 p3 p" z6 `1 P1 D/ \1 w: z System.out.println("The vector v1 is:\n\t"+v1);: C z2 M$ D- R9 _5 b* n4 u U
//将v1转换成字符串并打印
! d: _4 n' b( n2 q v1.insertElementAt("three",2);$ z( a1 j% z1 F" n
v1.insertElementAt(new Float(3.9),3);3 v5 d& d6 l* L3 z" \
System.out.println("The vector v1(used method insertElementAt()) is:\n\t "+v1);
, I' z7 F6 _- G* M //往指定位置插入新的对象,指定位置后的对象依次往后顺延
2 |* V- o3 e6 o/ L+ l6 c' ]& C v1.setElementAt("four",2);
7 d5 S- _4 g( x4 B. t# l( z System.out.println("The vector v1(used method setElementAt()) is:\n\t "+v1);3 L( K: O9 W' G$ @2 I
//将指定位置的对象设置为新的对象
9 h, Y2 \+ {* P5 ~ v1.removeElement(integer1);" t7 p% a5 b2 Q/ D
//从向量对象v1中删除对象integer1由于存在多个integer1所以从头开始
( u0 G2 k1 E" _2 M! z, _, f& i //找,删除找到的第一个integer1) L( L& l( J# z$ Z3 }$ c5 j
Enumeration enum=v1.elements();6 V0 y: ^9 z" b; }
System.out.print("The vector v1(used method removeElement())is:");) X6 u1 F% n# }
while(enum.hasMoreElements())
, _4 R. h ^& ]' ^ System.out.print(enum.nextElement()+" ");
6 Q" Z8 h; X$ |% b System.out.println();
) E4 C3 F, z- o" D z* d //使用枚举类(Enumeration)的方法来获取向量对象的每个元素
1 e* B4 Q+ M% V System.out.println("The position of object 1(top-to-bottom):"
1 W& A; D, e! b7 B* @) ] + v1.indexOf(integer1));
3 n6 K8 z0 c0 R3 U9 P6 F7 {% G System.out.println("The position of object 1(tottom-to-top):"
8 a% y8 f% E+ C& i +v1.lastIndexOf(integer1));
, \7 H7 ]5 Y* v: t( n+ O //按不同的方向查找对象integer1所处的位置
+ d l1 i- j5 ~# C, H0 t v1.setSize(4);% ~+ m: c( M) ]0 Q. C
System.out.println("The new vector(resized the vector)is:"+v1);
& c$ u) O `6 X0 y. J3 k' U; N" S //重新设置v1的大小,多余的元素被行弃& Q" ] x9 R$ G9 f
}* M i0 g) g7 a, n' p) @
}% n, F' p: o6 n$ @, ]
运行结果:
+ W; X, m* V3 `/ K E:\java01>java VectorApp7 K' T1 }. d0 s
The vector v1 is:! }2 P" ]* F1 s# m8 y# S+ e
[one, 1, 1, two, 2, 1, 1]9 s8 \+ U3 K3 F" A; f
The vector v1(used method insertElementAt()) is:" B1 p, B) t- @/ ^
[one, 1, three, 3.9, 1, two, 2, 1, 1]/ F8 `' k9 u8 ~$ M8 b$ \% ^3 ~
The vector v1(used method setElementAt()) is:
A& S8 |0 O* n0 O( v% Q [one, 1, four, 3.9, 1, two, 2, 1, 1]
# _7 [# e9 d3 p/ E The vector v1(used method removeElement())is:one four 3.9 1 two 2 1 1
, [' V+ l2 o2 o0 I( @ The position of object 1(top-to-bottom):3( v. a, l' I2 f6 U) D0 w- @
The position of object 1(tottom-to-top):7
( ~" n0 [3 b- c The new vector(resized the vector)is:[one, four, 3.9, 1]0 v" i3 A4 ^! e L6 \$ q
E:\java01>4 Z8 v) ^0 Y/ Y2 \& p! g' y
从例1.3运行的结果中可以清楚地了解上面各种方法的作用,另外还有几点需解释。
; e) ^8 p# Z J9 ^% t8 z% `# ~ (1)类Vector定义了方法
7 W' x/ I. J0 q C1 T, z9 C I/ ? public final int size()
$ [$ S% }* H5 q 此方法用于获取向量元素的个数。它的返回值是向是中实际存在的元素个数,而非向量容量。可以调用方法capactly()来获取容量值。
4 f9 W' A0 I# e. `% N9 X0 j 方法:, Y3 r7 ^# r; L! d1 W4 x, L- o
public final synchronized void setsize(int newsize)
- d2 {/ K0 f& g6 Z 此方法用来定义向量大小。若向量对象现有成员个数已超过了newsize的值,则超过部分的多余元素会丢失。* c O6 h" g% R3 k8 t
(2)程序中定义了Enumeration类的一个对象- D: @3 J. Z# f+ m6 r5 D
Enumeration是java.util中的一个接口类,在Enumeration中封装了有关枚举数据集合的方法。 `/ O9 L4 f" V0 c2 _
在Enumeration中提供了方法hawMoreElement()来判断集合中是束还有其它元素和方法nextElement()来获取下一个元素。利用这两个方法可以依次获得集合中元素。/ M( d% Z: ]1 R/ S0 F& C$ V
Vector中提供方法:" V) B: `& G+ j( Q' f! T
public final synchronized Enumeration elements()+ ` o3 C* V( v$ N; K
此方法将向量对象对应到一个枚举类型。java.util包中的其它类中也大都有这类方法,以便于用户获取对应的枚举类型。 |