深入了解 Dojo 的 Collections 工具包

xjk2131650

浏览: 57400 次
性别:
来自: 河北

最近访客更多访客>>

j405492

qq756514656

seetan2010

killer_028

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

dojo collections

Dojox 的 Collections 工具，一个模拟 Java 的某些实用数据结构的工具包，如：List（ArrayList）、Set、Dictionary、Queue、Stack、BinaryTree 等。这些工具对那些需要用到一些高级 Collections 功能的开发者非常有用。如果您是一位 Java 开发者，您一定对这些数据结构非常熟悉，基于这些工具进行 web 应用开发也将会游刃有余的多。这篇文章将主要来介绍 Dojox.collections 的特性以及一些使用上的技巧。

简介

Dojo 的 collections 工具包的存在主要是提供给开发人员一些比起基本的集合对象（collections）来说，功能更为丰富，使用起来也更加方便的集合对象，如 ArrayList、Dictionaries 等等。Dojo 的这些 collections 对象有点类似于 Java 的 collection 工具集（如“java.util.Collection”接口的那些派生类），并且同 Java 的类库一样，它们有比较完善的接口，性能上也做过优化。在 web 开发中使用这些对象会带给我们比较理想的效果。

Dojo 的 Collection 工具包基础

由于我们接下要介绍的主要是集合对象，所以我们需要先了解一下相关的迭代器和元素对象，这也就是 collection 的基础内容。

DictionaryEntry

所有关于 Dictionary 类集合的迭代元素均为 DictionaryEntry。参考如下代码：

清单 1. DictionaryEntry

				 
 var d=new dojox.collections.DictionaryEntry("foo","bar"); 
 t.assertEqual("bar", d.valueOf()); 
 t.assertEqual("bar", d.toString());

其中“t.assertEqual”是 Dojo 中用来判断两个值是否相等的，根据代码可以看出，“DictionaryEntry”有键（key）和值（value）组成，它有两个主要的方法：“valueOf”和“toString”，均可以取得它的值。

Iterator

Iterator 是一个迭代器，相信大家都不陌生了吧，很多编程语言里面都有同名的迭代器，虽然 JavaScript 并没有，不过 Dojo 模拟了一个。参考如下代码：

清单 2. Iterator

				 
 var itr=new dojox.collections.Iterator(["foo","bar","baz","zoo"]); 
 t.assertEqual("foo", itr.element);//test initialization 
 t.assertTrue(!itr.atEnd()); 
 t.assertEqual("foo", itr.get());//make sure the first get doesn't advance. 
 t.assertEqual("bar", itr.get()); 
 t.assertEqual("baz", itr.get()); 
 t.assertEqual("zoo", itr.get()); 
 t.assertTrue(itr.atEnd()); 
 t.assertEqual(null, itr.get());

其用法和其它语言的 Iterator 类似，“itr.element”适用于取得当前元素，即 Iterator 迭代指针当前指向的元素，注意：这种用“.element”取值的方式不会造成迭代指针的位移，指针指向的位置不变。但是，“get()”方法就不是了，每调用一次“get”方法，除了返回当前元素外，还会让指针后移一位，当指针移到末尾时，会有“itr.atEnd()”为真，此时的“itr.get()”则返回 null。

除此以外 Iterator 还支持“map”操作，其本质就是“dojo.map”，参考如下代码：

清单 3. Iterator 配合 map

				 
 var a=itr.map(function(elm){ 
 return elm+"-mapped"; 
 });

同“dojo.map”一样，这里的 Iterator 里面的每个节点的内容都加上了“-mapped”的尾椎。还有：“reset”方法可以让指针回到起始位置，进行新的迭代。

DictionaryIterator

想必大家根据名字就能看出来，这个是专门迭代 Dictionary 类集合的，参考如下代码：

清单 4. DictionaryIterator

				 
 var itr=new dojox.collections.DictionaryIterator({ 
 first:"foo", second:"bar", third:"baz", fourth:"zoo"
 }); 
 t.assertEqual("foo", itr.element);//test initialization 
 t.assertTrue(!itr.atEnd()); 
 t.assertEqual("foo", itr.get());//make sure the first get doesn't advance. 
 t.assertEqual("bar", itr.get()); 
 t.assertEqual("baz", itr.get()); 
 t.assertEqual("zoo", itr.get()); 
 t.assertTrue(itr.atEnd()); 
 t.assertEqual(null, itr.get());

这里似乎和 Iterator 类似，事实上，DictionaryIterator 的迭代主要是基于“值”的迭代，所以这里的使用方式和返回值几乎相同，而且 DictionaryIterator 也支持“map”操作。

接下来我们来看看 Dojo 所支持的各种集合对象。

ArrayList

做过 Java 开发的软件工程师对这个对象应该再熟悉不过了。我们来看看它的一些示例代码：

清单 5. ArrayList 基本操作

				 
 var al=new dojox.collections.ArrayList(["foo","bar","test","bull"]); 
 t.assertEqual(4, al.count); 
 al.add("carp"); 
 t.assertEqual("foo,bar,test,bull,carp", al.toString()); 
 al.addRange(["oof","rab"]); 
 t.assertEqual("foo,bar,test,bull,carp,oof,rab", al.toString());

“count”代表元素数量，“add”用于添加元素，“addRange”可以添加一系列元素（其传入值为数组），它的“toString”方法相当于 JavaScript 的“join(",")”。大家是不是有一种似曾相识的感觉？不错，这些方法和返回结果与我们之前用过的 Java 的 Util 工具包里面的 ArrayList 类非常相似。所以，如果您基于 Dojo 的 ArrayList 做开发，可能您根本用不着了解 JavaScript 的相关语法和接口。

当然，不止这些接口，Dojo 的 ArrayList 还支持很多其它常用接口，如 clone、clear、indexOf 甚至 contains，相信大家在 Java 里面也用过，这里就不赘述了。

接下来我们来看看 Dojo 的 ArrayList 的一些高级的操作方法：

清单 6. ArrayList 高级操作

				 
 var al=new dojox.collections.ArrayList(["foo","bar","test","bull"]); 
 t.assertEqual("test", al.item(2)); 

 var al=new dojox.collections.ArrayList(["foo","bar","test","bull"]); 
 al.insert(2, "baz"); 
 t.assertEqual(2, al.indexOf("baz")); 

 var al=new dojox.collections.ArrayList(["foo","bar","test","bull"]); 
 al.remove("bar"); 
 t.assertEqual("foo,test,bull", al.toString()); 

 var al=new dojox.collections.ArrayList(["foo","bar","test","bull"]); 
 al.removeAt(3); 
 t.assertEqual("foo,bar,test", al.toString());

“item”方法用于取值，它使得对于像 ArrayList 这样的集合同样可以通过“数组”的方式来取值，“item(2)”表示取第 2 个元素。同样，插入，删除等等操作也是支持的：“insert(2, "baz")”表示在第 2 位插入“baz”。删除可以通过两种方式：“remove”和“removeAt”，一个通过元素值定位，一个通过下标定位。

还有“reverse”和“sort”方法，一个用于集合的反转，一个用于排序，推荐大家关注一下。

最后，我们来看看它的迭代器用法：

清单 7. ArrayList 的迭代器

				 
 var al=new dojox.collections.ArrayList(["foo","bar","test","bull"]); 
 var itr=al.getIterator(); 
 while(!itr.atEnd()){ 
 itr.get(); 
 } 
 t.assertEqual("bull", itr.element);

和很多其它语言一样，通过“getIterator”拿到迭代器进行迭代，清单 7 中的代码是不是非常熟悉，我们好像写过太多类似的代码了。

BinaryTree

BinaryTree 也是一个线性结构，它的优势在于它的检索。它的基本操作（包括增删查改）与 ArrayList 基本无异，这里我们主要介绍一下它的检索操作：

清单 8. BinaryTree 检索

				 
 var bt=new dojox.collections.BinaryTree("foo"); 
 bt.add("bar"); 
 bt.add("baz"); 
 bt.add("buck"); 
 bt.add("shot"); 
 bt.add("apple"); 
 t.assertEqual("buck", bt.search("buck").value);

“bt.search("buck")”这里得到的不是值本身，而是一个节点对象，它有“left”，“right”和“value”等等属性，这里的“value”就是它的值。

BinaryTree 的接口很简单，但是里面的实现比较丰富。每一个外部的“add”操作都会促使它进行二叉树的构造，用于以后的查找。所以它的“search”（包括“contains”）方法的效率非常高，复杂度应该是 O(logn)，而 ArrayList（“contains”方法）的复杂度应为 O(n)。但是这样也有缺点：就是 BinaryTree 的 add、deleteData 等方法需要消耗更多的时间。可以说，BinaryTree 比较适合存储并检索大量数据。

我们来参考一下 BinaryTree 的 add 方法的源代码：

清单 9. BinaryTree 的 add 方法实现

				 
 this.add=function(data){
	var n=new node(data);
	var i;
	var current=root;
	var parent=null;

//定位待插入元素在二叉树中的插入位置
	while(current){
		i=current.compare(n);
		if(i==0){ return; }
		parent=current;
		if(i>0){ current=current.left; }
		else{ current=current.right; }
	}
	this.count++;

//插入待插入元素到相应位置
	if(!parent){
		root=n;
	}else{
		i=parent.compare(n);
		if(i>0){
			parent.left=n;
		}else{
			parent.right=n;
		}
	}
};

参照代码中的注释，可以看出 BinaryTree 的每一个外部的“add”操作是如何进行二叉树的构造的。

Queue & Stack

Queue 和 Stack 也都是线性结构，我们学数据结构时可能对 Queue 和 Stack 就已经了如指掌了。Queue 是先进先出，Stack 是先进后出，或者说后进先出。它们的基本操作也都类似 ArrayList 的那些接口，下面我们来简单说说它们的特殊接口：

清单 10. Queue 示例

				 
 var q=new dojox.collections.Queue(["foo","bar","test","bull"]); 
 q.enqueue("bull"); 
 t.assertEqual("bull", q.toArray().pop()); 

 var q=new dojox.collections.Queue(["foo","bar","test","bull"]); 
 t.assertEqual("foo", q.dequeue()); 
 t.assertEqual("bar,test,bull", q.toArray().join(","));

“enqueue”表示入栈，“dequeue”表示出栈，可见 Queue 是先进先出的。如果仅仅想取值，请用“peek”方法。

清单 11. Stack 示例

				 
 var s=new dojox.collections.Stack(["foo","bar","test","bull"]); 
 t.assertEqual("bull", s.pop()); 
 t.assertEqual("test", s.pop()); 

 var s=new dojox.collections.Stack(["foo","bar","test","bull"]); 
 s.push("bug"); 
 t.assertEqual("bug", s.peek());

“push”表示入栈，“pop”表示出栈，“s.peek()”出的值为“bug”表示 Stack 为后进先出的线性结构。如果仅仅想取值，也请用“peek”。

Set

相信我们对 Set 这个对象已经不陌生了，它的最大的特点就是元素的唯一性。同样，Dojo 中的 Set 也是如此，但是 Dojo 中的 Set 的主要用法不是构建 Set 对象，而是 Set 本身的一些方法：

清单 12. Set 的方法

				 
 var dxcs=dojox.collections.Set; 

 var a = ["apple","bear","candy","donut","epiphite","frank"]; 
 var b = ["bear","epiphite","google","happy","joy"]; 


 var union=dxcs.union(a,b); 
 t.assertEqual("apple,bear,candy,donut,epiphite,frank,google,happy,joy", 
                                             union.toArray().join(',')); 
                                             
 var itsn=dxcs.intersection(a,b); 
 t.assertEqual("bear,epiphite", itsn.toArray().join(",")); 
 t.assertEqual("bear", dxcs.intersection(["bear","apple"], ["bear"])); 


 var d=dxcs.difference(a,b); 
 t.assertEqual("apple,candy,donut,frank",d.toArray().join(',')); 


 t.assertFalse(dxcs.isSubSet(a,["bear","candy"])); 
 t.assertTrue(dxcs.isSubSet(["bear","candy"],a)); 


 t.assertTrue(dxcs.isSuperSet(a,["bear","candy"])); 
 t.assertFalse(dxcs.isSuperSet(["bear","candy"],a));

代码可能有点多，我们来一一结介绍：

注意 dxcs 是指代的 Dojo 的 Set 类 -- “dojox.collections.Set”。关注“a”和“b”两个集合。
“union”表示联合，但是 Set 的联合方法会去除重复元素。
“intersection”是做交叉，选出两个集合里面具有的元素，然后组成集合。
“difference”是取得集合“a”中存在但集合“b”中不存在的元素。
“isSubSet”和“isSuperSet”分别指“是否为子集”和“是否为超集”。

Dictionary

之前其实我们已经简单了解过了，它的实类似于“java.util.Dictionary”。它的基本操作也是与 ArrayList 类似，但不同的是它是 map 结构，有两个属性：“key”和“value”，不同于简单线性结构（如：ArrayList）。我们先来看看以下实例：

清单 13. Dictionary 的方法

				 
 var d=new dojox.collections.Dictionary(); 

 d.add("foo","bar"); 
 d.add("baz","fab"); 
 d.add("buck","shot"); 
 d.add("apple","orange"); 

 t.assertTrue(d.containsKey("buck")); 

 t.assertTrue(d.containsValue("shot")); 

 t.assertEqual("foo,baz,buck,apple", d.getKeyList().join(",")); 

 t.assertEqual("bar,fab,shot,orange", d.getValueList().join(",")); 

 d.remove("baz"); 
 t.assertEqual(3, d.count); 
 t.assertEqual(undefined, d.item("baz"));

可以看出，这里添加元素还是用“add”，但是不再是添加值，而是添加“ 键 - 值 ”对。它的“contains”方法也可分为“containsKey”和“containsValue”两种。同样，也有“getKeyList”和“getValueList”两种。当调用“remove”方法删除元素以后，Dictionary 的长度也会变化，并且删除的值变为“undefined”。

SortedList

SortedList 和 Dictionary 有很相似性，不同的是，该线性结构里的元素是排好序（基于键“key”排序）存储的。

清单 14. SortedList 的方法

				 
 var sl=new dojox.collections.SortedList(); 

 sl.add("foo","bar"); 
 sl.add("baz","fab"); 
 sl.add("buck","shot"); 
 sl.add("apple","orange"); 

 t.assertEqual("shot", sl.getByIndex(2)); 

 t.assertEqual("apple", sl.getKey(0)); 

 t.assertEqual(0, sl.indexOfKey("apple")); 

 t.assertEqual(3, sl.indexOfValue("bar")); 

 sl.setByIndex(0, "bar"); 
 t.assertEqual("bar", sl.getByIndex(0));

SortedList 的方法：“containsKey”，“containsValue”，“getKeyList”，“getValueList”和“remove”等等这里就不一一列举了。我们来看一下它特有的方法：

注意到，虽然它是按“foo”，“baz”，“buck”，“apple”的顺序添加，但是它的内部顺序为：“apple”，“baz”，“buck”，“foo”，所以 value 的顺序应为：“orange”，“fab”，“shot”，“bar”。基于这种机制，我们就能了解它的一些接口的返回值。
“getByIndex(2)”应该是返回第三个元素的 value，所以为“shot”。
“getKey(0)”自然是第一个元素的 key，所以为“apple”。
“indexOfKey("apple")”返回元素“apple”的 index，为 0；“indexOfValue”返回 value 元素“bar”的位置，为第四个元素，即 index 为 3。
“setByIndex”和“getByIndex”是根据位置设置值和取值。

可以看出，SortedList 的接口是很全面的，建议大家在项目中多使用。

结束语

这篇文章介绍了 Dojo 中关于 Collections 集合对象的一些特性，从 collection 工具包的基础出发，依次介绍了 ArrayList、BinaryTree、Queue、Stack、Set、Dictionary 以及 SortedList 等，介绍了它们的基本接口，高级接口和一些特殊接口。同时，也阐述了这些不同集合对象之间的相同点和不同点。本文主要是基于实际的代码示例来说明这些集合对象的用法，简明直观，推荐大家在日常开发中多参考。

分享到：