Java 中Iterator 、Vector、ArrayList、List 使用深入剖析[转]
线性表，链表，哈希表是常用的数据结构，在进行Java开发时，JDK已经为我们提供了一系列相应的类来实现基本的数据结构。这些类均在java.util包中。本文试图通过简单的描述，向读者阐述各个类的作用以及如何正确使用这些类。 Collection├List│├LinkedList│├ArrayList│└Vector│　└Stack└SetMap├Hashtable├HashMap└WeakHashMapCollection接口　　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。
用Iterator模式实现遍历集合
Iterator模式是用于遍历集合类的标准访问方法。它可以把访问逻辑从不同类型的集合类中抽象出来，从而避免向客户端暴露集合的内部结构。
例如，如果没有使用Iterator，遍历一个数组的方法是使用索引：
&&&&& for(int i=0; i&array.size(); i++) { ... get(i) ... }
而访问一个链表（LinkedList）又必须使用while循环：
&&&&& while((e=e.next())!=null) { ... e.data() ... }
以上两种方法客户端都必须事先知道集合的内部结构，访问代码和集合本身是紧耦合，无法将访问逻辑从集合类和客户端代码中分离出来，每一种集合对应一种遍历方法，客户端代码无法复用。
更恐怖的是，如果以后需要把ArrayList更换为LinkedList，则原来的客户端代码必须全部重写。
为解决以上问题，Iterator模式总是用同一种逻辑来遍历集合：
&&&&& for(Iterator it = c.iterater(); it.hasNext(); ) { ... }
奥秘在于客户端自身不维护遍历集合的"指针"，所有的内部状态（如当前元素位置，是否有下一个元素）都由Iterator来维护，而这个Iterator由集合类通过工厂方法生成，因此，它知道如何遍历整个集合。
客户端从不直接和集合类打交道，它总是控制Iterator，向它发送"向前"，"向后"，"取当前元素"的命令，就可以间接遍历整个集合。
首先看看java.util.Iterator接口的定义：
&&&&& public interface Iterator {
&&&&&&&&& boolean hasNext();
&&&&&&&&& Object next();
&&&&&&&&& void remove();
依赖前两个方法就能完成遍历，典型的代码如下：
&&&&& for(Iterator it = c.iterator(); it.hasNext(); ) {
&&&&&&&&& Object o = it.next();
&&&&&&&&& // 对o的操作...
在JDK1.5中，还对上面的代码在语法上作了简化：
&&&&& // Type是具体的类型，如String。
&&&&& for(Type t : c) {
&&&&&&&&& // 对t的操作...
每一种集合类返回的Iterator具体类型可能不同，Array可能返回ArrayIterator，Set可能返回SetIterator，Tree可能返回TreeIterator，但是它们都实现了Iterator接口，因此，客户端不关心到底是哪种Iterator，它只需要获得这个Iterator接口即可，这就是面向对象的威力。
Iterator源码剖析
让我们来看看AbstracyList如何创建Iterator。首先AbstractList定义了一个内部类（inner class）：
&&&&& private class Itr implements Iterator {
&&&&&&&&& ...
而iterator()方法的定义是：
&&&&& public Iterator iterator() {
&&&&&&&&& return new Itr();
因此客户端不知道它通过Iterator it = a.iterator();所获得的Iterator的真正类型。
现在我们关心的是这个申明为private的Itr类是如何实现遍历AbstractList的：
&&&&& private class Itr implements Iterator {
&&&&&&&&& int cursor = 0;
&&&&&&&&& int lastRet = -1;
&&&&&&&&& int expectedModCount = modC
Itr类依靠3个int变量（还有一个隐含的AbstractList的引用）来实现遍历，cursor是下一次next()调用时元素的位置，第一次调用next()将返回索引为0的元素。lastRet记录上一次游标所在位置，因此它总是比cursor少1。
变量cursor和集合的元素个数决定hasNext()：
&&&&& public boolean hasNext() {
&&&&&&&&& return cursor != size();
方法next()返回的是索引为cursor的元素，然后修改cursor和lastRet的值：
&&&&& public Object next() {
&&&&&&&&& checkForComodification();
&&&&&&&&& try {
&&&&&&&&&&&&& Object next = get(cursor);
&&&&&&&&&&&&& lastRet = cursor++;
&&&&&&&&&&&&&
&&&&&&&&& } catch(IndexOutOfBoundsException e) {
&&&&&&&&&&&&& checkForComodification();
&&&&&&&&&&&&& throw new NoSuchElementException();
&&&&&&&&& }
expectedModCount表示期待的modCount值，用来判断在遍历过程中集合是否被修改过。AbstractList包含一个modCount变量，它的初始值是0，当集合每被修改一次时（调用add，remove等方法），modCount加1。因此，modCount如果不变，表示集合内容未被修改。
Itr初始化时用expectedModCount记录集合的modCount变量，此后在必要的地方它会检测modCount的值：
&&&&& final void checkForComodification() {
&&&&&&&&& if (modCount != expectedModCount)
&&&&&&&&&&&&& throw new ConcurrentModificationException();
如果modCount与一开始记录在expectedModeCount中的值不等，说明集合内容被修改过，此时会抛出ConcurrentModificationException。
这个ConcurrentModificationException是RuntimeException，不要在客户端捕获它。如果发生此异常，说明程序代码的编写有问题，应该仔细检查代码而不是在catch中忽略它。
但是调用Iterator自身的remove()方法删除当前元素是完全没有问题的，因为在这个方法中会自动同步expectedModCount和modCount的值：
&&&&& public void remove() {
&&&&&&&&& ...
&&&&&&&&& AbstractList.this.remove(lastRet);
&&&&&&&&& ...
&&&&&&&&& // 在调用了集合的remove()方法之后重新设置了expectedModCount：
&&&&&&&&& expectedModCount = modC
&&&&&&&&& ...
要确保遍历过程顺利完成，必须保证遍历过程中不更改集合的内容（Iterator的remove()方法除外），因此，确保遍历可靠的原则是只在一个线程中使用这个集合，或者在多线程中对遍历代码进行同步。
最后给个完整的示例：
&&&&& Collection c = new ArrayList();
&&&&& c.add("abc");
&&&&& c.add("xyz");
&&&&& for(Iterator it = c.iterator(); it.hasNext(); ) {
&&&&&&&&& String s = (String)it.next();
&&&&&&&&& System.out.println(s);
如果你把第一行代码的ArrayList换成LinkedList或Vector，剩下的代码不用改动一行就能编译，而且功能不变，这就是针对抽象编程的原则：对具体类的依赖性最小。
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)避免了同步、额外的方法调用和不必要的重新分配空间的操作。
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：17923次
排名：千里之外
原创：42篇
(2)(3)(1)(4)(11)(3)(7)(4)(1)(1)(6)相关文章推荐:
java在数组里取个随机数
如何用java从指定数组中取不重复的7个随机数，以下是我写的代码，但是是有重复的，哪位大侠赐教一下如何使用Random类的种子，帮我实现不重复的随机数。。。
import java.util.*;
public class Lottery {
public static void main(String[] args)
int[] data1 = {3,5,6,8,9,15,18,24,27,30,32};
StringBuffer
StringBuffer();
阅读（7338） 回复（10）
其他文章推荐
ITPUB官方微博:
在java中，我们可以通过两种方式来获取随机数(generating a random number)一种是大家熟悉的java.lang.Math.Random()静态方法,另一种是创建java.util.Random对象。下面是两种方法的使用过程:
一.java.lang.Math.random()
在使用这一静态方法的时候，我们不需要import任何包，因为java.lang.*包是默认载入的,下面举例说面使用方法:
public class RandomTest{
public static void main(String[] args){
int i=Ma...
阅读（99） 回复（2）
如果你做过很多java程序，你可能对java集合类很熟悉，例如Vector和ArrayList。你可以创建一个集合并向其中增加元素：
List lst = new ArrayList(); lst.add(new Integer(37));
在这个特殊的范例中，一个整型值37用于构造一个Integer封装类对象，然后那个对象被加入到列表。
这个简单的范例展示集合的一个基础－他们用于操纵一列对象，其中的每个对象是一个类或者接口类型。因此，一个ArrayList可以包含Object,String,Float以及R...
阅读（673） 回复（0）
为什么显示数组越界啊，请高手指点错在哪里，谢谢
import java.awt.*;
import javax.swing.*;
public class DoubleArray extends JApplet{
int grades[][] = {{77,68,86,73},{96,87,89,81},{70,90,86,81}};
JTextArea outputA
public void init(){
stu = grades.
exams = grades[0].
outputArea = new JTextArea();
Container c = getContentPane();
c.add(outpu...
阅读（863） 回复（1）
Thinking in java的一个中文版里看到这样一段话：
“假设你写了一个方法，它返回的不是一个而是一组东西。在C和C＋＋之类的语言里，这件事就有些难办了。因为你不能返回一个数组，你只能返回一个指向数组的指针，由于要处理“控制数组生命周期”之类的麻烦事，这么做很容易会出错，最好导致内存泄漏。而java返回的就是一个数组。”
java返回的不也是一个对象，在这里就是数组的Reference吗？
阅读（3226） 回复（2）
java的数组在定义时必须指定数组的维数及维的上标，能不能象vb一样先dim a() as integer，用的时候再redim？并且能象vb一样用reDim Preserve增加其末维上标大小？
阅读（2112） 回复（8）
import java.sql.*;
public class SevenJdbc {
static final String url = "jdbc:oracle:thin:@192.168.3.211:1521:chi";
static final String userID = "scott";
static final String passwd = "oracle";
Connection conn =
ResultSet rs =
public static void main(String[] args) {
new SevenJdb
阅读（150） 回复（0）
阅读（121） 回复（0）
怎样获取一个文件有多少行数据呢？如果是在linux下，可以简单的通过wc -l 文件名来获取。那如果我想在程序中获取文件有多少行要怎么处理呢？
linux、windows
如果我们需要对比通过java程序获取一个文件一共有多少行数据，我
阅读（361） 回复（0）
程序开发过程中,需要从键盘获取输入值是常有的事,但java它偏偏就没有像c语言给我们提供的scanf(),C++给我们提供的cin()获取键盘输入值的现成函数!java没有提供这样的函数也不代表遇到这种情况我们就束手无策下面欧柏泰克老师跟大家一起来熟悉下java中获取键盘输入值的三种方法吧:以下将列出几种方法:方法一:从控制台接收一个字符
阅读（91） 回复（0）
java调用oracle存储过程的自定义类型(可变数组)。 10:06
在使用存储过程中，我们有时需要传递可变数组，存在两种情况，存储过程有输入或输出参数为自定义可变数组的。在java代码中，如何正确调用oracle存储过程的自定义可变数组类型，在这里做一下示例说明.
java调用oracle存储过程的自定义类型:
plsql定义字符
阅读（540） 回复（0）
盛拓传媒：
北京皓辰网域网络信息技术有限公司. 版权所有
北京市公安局海淀分局网监中心备案编号：
广播电视节目制作经营许可证：编号（京）字第1149号
ITPUB推荐文章解答你所有技术难题找学校，搜学校，学校口碑早知道！
您可以免费发布教育培训信息，找学校，找课程，找老师，学校建站，发布新闻动态，招生培训等。
推荐学校：
LOADING...
您当前的位置： >>
>> Java教程 >> applet 的参数化 -- 对数组进行初始化2f58de76a4d5b547
applet 的参数化 -- 对数组进行初始化
更新日期：　来源：网友投搞　作者：佚名　分享927次
核心提示：新闻资讯频道所转载文章、数据等内容纯属作者个人观点，仅供学习参考使用。本文《applet 的参数化 -- 对数组进行初始化》来源于网络并非原创内容，请读者以官方内容为准，如果您发现本资料有侵犯您的知识产权，请立即联系我们，我们将第一时间内删除该资料，以保障您的知识产权。
　　将列表数据提供给 applet　　看过关于 applet 参数化的上一篇技巧的读者可能已经注重到：我们的方法没有对一类重要的对象进行初始化。在本文中，我们将研究假如利用类反射机制对一维数组和二位数组进行初始化。我知道只有实现对更高维数组的处理才能使狂热的科学家满足，但我将把那项工作作为练习留给您。　　　　在我的上一篇技巧中，只能处理基本类型的数组和字符串数组。考虑到任何对象最终都能由基本数据类型和字符串构建而来，所以这将不会构成多大的限制。当然，很轻易将我们的技术加以扩展，之后就能直接对其他类型的数据进行初始化。　　　　数组是用来存储列表数据的理想数据结构。我们的技术使得向 applet 传递列表参数变得很简单。 通常利用动态生成 Html 文档的程序（如 servlet 或 CGI 脚本）将列表数据传递给 applet。作为示例，我们设想一个比赛记分板 applet。HTML 生成器将会将当前的记分板数据库输出到 PARAM 标记中，接着相应的数组将被完全初始化 -- 这要归功于我们的参数提取方法。　　　　列表数据项的语法　　我们要实现的就是一个从 PARAM 标记中提取一维或是二维数组的方法。一维数组的语法是：　　　　PARAM NAME="myArray" VALUE="element1 element2 ... elementN"　　　　各元素之间的定界符是空格。　　　　二位数组的语法是：　　　　PARAM NAME="myMatrix" VALUE="element11 element12 element13 　　element21 element22 element23 　　element31 element32 element33"　　　　各行之间的定界符是
符号。这里，myMatrix 是一个 (3 x 3) 数组。　　　　注重：Java 支持不规则数组。 不规则数组就是各行的长度不同的数组。例如，HTML 作者可能会按以下方式输入帕斯卡三角形：　　　　PARAM NAME="pascalTriangle" VALUE=" 1 　　1 1 　　1 2 1 　　1 3 3 1 　　1 4 6 4 1 　　1 5 10 10 5 1 　　1 6 15 20 15 6 1"　　　　初始化完成之后，pascalTriangle 域的内容将是：　　　　pascalTriangle[0] = {1}　　pascalTriangle[1] = {1, 1}　　pascalTriangle[2] = {1, 2, 1}　　pascalTriangle[3] = {1, 3, 3, 1}　　pascalTriangle[4] = {1, 4, 6, 4, 1}　　pascalTriangle[5] = {1, 5, 10, 10, 5, 1}　　pascalTriangle[5] = {1, 6, 15, 20, 15, 6, 1}　　　　通常，程序员应该只声明 pascalTriangle，而不进行内存分配。我们的提取方法负责分配内存。但让我们假定已为第四行分配了内存，如下所示：　　　　pascalTriangle[3] = new int[2];　　　　我们的方法将只提取前两个元素。这样，第四行的初始化结果将是：　　　　pascalTriangle[3] = {1, 3}　　　　数组知识回顾　　正如您在以上代码清单中看到的那样，我们的方法实现有点“深奥”。因此，在研究源代码之前回顾有关数组的几点知识是个不错的主意。　　　　我们都对 Java 的类型层次结构比较熟悉：Java 有一组预定义的基本数据类型（int、float...），还有 Object 的子类的一个继续树，Object 类是所有类的最终超类。但 Java 中还存在一个不很出名的平行层次结构，我称其为数组层次结构。您无论何时在类型层次结构中定义了一个新类型 Foo，您实际上也同时定义了一个自动结合到数组层次结构中的新类型 Foo[]。数组层次结构中的每个类（基本数据类型的数组除外）都是 Object[] 的子类。轻易引起混淆的是：Object[] 和基本数据类型的数组都是 Object 的子类。图 1 表明了这一点。　　
　　图 1：两个平行的层次结构　　令人感到希奇的是，Java 根本就没有多维数组，只有一维数组。多维数组实际上是“一维数组的数组的数组的数组...”。因此，我们可以创建不规则数组。事实上，我们甚至可以不对某些行进行初始化，而将它们保留为空值。　　　　数组提取方法的实现　　现在我们可以查看源代码了。正如您所见，其中加了大量注释。通常，包含如此多的注释不是个好习惯，但在这里，我们要将已经抽象的 Java 数组包装在由类反射机制提供的元数据抽象层中。结果，多数程序语句都不能表明其自身的含义，所以在这种情况下对几乎每个代码行作注释是无可非议的。　　　　无论何时对一维或是二维数组进行初始化，最终我们都需要用 HTML 作者输入的行对一维数组进行初始化。我们设计了一个方法来完成这一操作：　　　　/**　　* 用符号处理器 (tokenizer) 的内容填充一维数组。　　* 符号被转换为数组的内容类型。　　*　　* @param array 要填充的数组。　　* @param elementTokens 包含要填入数组的符号的符号处理器。　　*/　　private static void fillOneDimensionalArray(Object array,　　StringTokenizer elementTokens)　　throws IllegalAccessException {　　　　if (array != null && elementTokens != null && array.getClass().isArray()) { // 双重检验。　　// 数组应该容纳哪种类型的元素？　　Class componentType = array.getClass().getComponentType();　　　　int numElements = elementTokens.countTokens();　　　　// 为数组元素赋值。　　//　　// 请注重，我们确保索引不会超出范围。可能未给数组分配组足够的空间，　　// 以致无法容纳分析后的全部元素。　　for (int j = 0; j & Array.getLength(array) && j & numE j++) {　　// 将符号转换为数组所容纳的类型。　　// 然后将其添加到数组中。　　if (componentType.equals(boolean.class))　　Array.setBoolean(array, j, Boolean.valueOf(elementTokens.nextToken().trim()).booleanValue());　　　　else if (componentType.equals(byte.class))　　Array.setByte(array, j, Byte.valueOf(elementTokens.nextToken().trim()).byteValue());　　　　else if (componentType.equals(char.class))　　Array.setChar(array, j, elementTokens.nextToken().charAt(0));　　　　else if (componentType.equals(double.class))　　Array.setDouble(array, j, Double.valueOf(elementTokens.nextToken().trim()).doubleValue());　　　　else if (componentType.equals(float.class))　　Array.setFloat(array, j, Float.valueOf(elementTokens.nextToken().trim()).floatValue());　　　　else if (componentType.equals(int.class))　　Array.setInt(array, j, Integer.valueOf(elementTokens.nextToken().trim()).intValue());　　　　else if (componentType.equals(long.class))　　Array.setLong(array, j, Long.valueOf(elementTokens.nextToken().trim()).longValue());　　　　else if (componentType.equals(short.class))　　Array.setShort(array, j, Short.valueOf(elementTokens.nextToken().trim()).shortValue());　　　　else if (componentType.equals(String.class))　　Array.set(array, j, elementTokens.nextToken());　　}　　}　　}　　　　我们使用 Class.getComponentType() 方法获取给定数组对象所容纳的元素类型。一旦我们获得这些信息，我们就知道应将行元素转换为何种类型。这是在一个循环语句中完成的。　　　　您可能已猜到了，Array.setByte(Object obj, int i, byte datum) 用字节变量 datum 为 obj 数组的第 i 个元素赋值。这相当于 ((byte[])obj)[i] = datum。　　　　下面开始分析实现的核心部分。我对 Util.initializeApplet(Applet, String) 方法（在“Java 技巧 57”中实现）进行了扩展，在其中添加了一个条件语句，这个条件语句高速缓存数组域并对它们进行初始化。　　　　import java.applet.*;　　import java.lang.reflect.*;　　import java.util.*;　　　　public abstract class Util {　　　　/**　　* 对 applet 的名称以给定筛选前缀开头的非 final 公共域进行初始化。　　* 初始值将从 HTML PARAM 标记中读取。　　* *　　* @param applet 要初始化的 applet。　　* @param filterPrefix 只对那些以此前缀开头的域进行初始化。　　*　　* 假如前缀为空值，将对所有非 final 公共域进行初始化。　　*/　　public static void initializeApplet(Applet applet, String filterPrefix) {　　　　Class metaclass = applet.getClass();　　Field[] fields = metaclass.getFields();　　String param =　　　　for (int i = 0; i & fields. i++) {　　try {　　param = applet.getParameter(fields[i].getName());　　　　if (param == null 　　Modifier.isFinal(fields[i].getModifiers()) 　　((filterPrefix != null) &&　　!fields[i].getName().startsWith(filterPrefix))　　)　　　　　　Class fieldType = fields[i].getType();　　　　if (fieldType.equals(boolean.class)) {　　fields[i].setBoolean(applet, Boolean.valueOf(param).booleanValue());　　}　　else if (fieldType.equals(byte.class)) {　　fields[i].setByte(applet, Byte.valueOf(param).byteValue());　　}　　　　/***************
阅读上一篇：
阅读下一篇：}