|
|
public static void print(Collection c){
for(Iterator x=c.iterator();x.hasNext();)
System.out.println();
}
public static void main(String[] args){
Collection c=newCollection();
c.add("ten");
c.add("eleven");
print(c);
Object[] array=c.toArray();
String[] str=(String[])c.toArray(new String[1]);
System.out.println("Collection.max(c)="+Collection.max(c));
System.out.println("Collection.min(c)="+Collection.min(c));
c.addAll(newCollection());
print(c);
c.remove("3");
print(c);
c.remove("3");
print(c);
c.removeAll(newCollection());
print(c);
c.addAll(newCollection());
print(c);
System.out.println("c.contains(\"4\")="+ c.contains("4"));
System.out.println("c.containsAll(newCollection())="+ c.containsAll(newCollection()));
Collection c2=newCollection(5,3);
c.retainAll(c2);
print(c);
c.removeAll(c2);
System.out.println("c.isEmpty()="+ c.isEmpty());
c=newCollection();
print(c);
c.clear();
System.out.println("after c.clear():");
print(c);
}
}
上述程序中用重载的fill()方法和Collection()方法来构造Collection对象，main()方法中演示Collection的各种操作，首先建立一个集合存放0-9的数字，然后又将ten和eleven作为字符串添加进去，然后我们有分别试用了它的其他一些常用方法，这些操作比较简单，执行结果如下：
0|1|2|3|4|5|6|7|8|9|ten|eleven|
Collection.max(c)=ten
Collection.min(c)=0
0|1|2|3|4|5|6|7|8|9|ten|eleven|0|1|2|3|4|5|6|7|8|9|
0|1|2|4|5|6|7|8|9|ten|eleven|0|1|2|3|4|5|6|7|8|9|
0|1|2|4|5|6|7|8|9|ten|eleven|0|1|2|4|5|6|7|8|9|
ten|eleven|
ten|eleven|0|1|2|3|4|5|6|7|8|9|
c.contains(“4”)=true
c.containsAll(newCollection())=true
5|6|7|
c.isEmpty()=true
0|1|2|3|4|5|6|7|8|9|
after c.clear():
9.3.2 List
List的明显特征是它的元素有一个确定的顺序，它比Collection多了一些指定位置增删改的方法。它能产生ListIterator的对象。实现它的类有ArrayList。ArrayList内存中是顺序存储的，而LinkedList内存中是以链表的形式存储，所以ArrayList比较适用于经常遍历访问，ArrayList比较适用于经常在中间进行增删改操作。ArrayList是被用来代替Vector的一个通用的可变数组类，因而，Java1.2以后的编程应多使用ArrayList。
9.3.3 Set
Set与Collection有完全相同的对外接口，实际上就是一个Collection，但添加到Set的每个元素都必须是独一无二的，Set不会添加重复的元素，添加到Set里的对象必须定义equals()方法，以提供算法来判断欲添加进来的对象是否与已经存在的某对象相等，从而建立对象的唯一性。一个Set不能保证自己可按任何特定的顺序维持自己的元素。
实现Set的类有HashSet和TreeSet，HashSet是以hash桶来存放元素，能实现快速查找，TreeSet是一种有顺序的集合，一般以字典升序排列，或以创建Set时指定的Comparator来排序，内存中以二叉树型结构存储。由于TreeSet实现了SortedSet，所以有几个特殊的方法，例如：
● public Object first()——获取第一个即排在最地位的一个
● public Object last()——获取排在toElement之前的元素组成的SortedSet
例9.7 set中元素的唯一性
Setx.java的源文件如下：
import java.util.*;
public class Setx{
public static void tsetVisual(Set a){
Collectionx.fill(a);
Collectionx.fill(a);
Collectionx.fill(a);
Collectionx.print(a);
a.addAll(a);
a.add("one"):
a.add("one"):
a.add("one"):
Collectionx.print(a);
System.out.println("a.contains(\"one\"):"+a.contains("one"));
}
public static void main(String[] args){
testVisual(new HashSet());
testVisual(new TreeSet());
}
}
以上的程序非常简单，它的目的就是看一下Set元素的唯一性。但这个程序用到了上一个程序定义的类，所以运行前必须先运行上一个程序。程序的运行结果如下：
9|8|7|6|5|4|3|2|1|0|
one|9|8|7|6|5|4|3|2|1|0|
a.contain(“one”):true
0|1|2|3|4|5|6|7|8|9|
0|1|2|3|4|5|6|7|8|9|one|
a.contains(“one”):true
9.3.4 Map
Map这种接口用来维持很多“键-值”对，以便通过一个键查找相应的值。
HashMap基于一个散列表实现。针对“键-值”对的插入和检索，这种形式具有较好的执行性能。
TreeMap在一个二叉树的基础上实现。查看键或者“键-值”对时，它们会按固定的顺序排列。TreeMap最大的好处就是我们得到的是以排列好序的结果。TreeMap是含有subMap()方法的唯一一种Map，利用它可以返回树的一部分。
WeakHashMap是一种特殊的HashMap,对于那些弱键，垃圾收集器会自动删除，因而，对应的“键-值”对可能会丢失。
下面是Map的用法。
例9.8 Map的用法
Mapx.java的源文件如下：
import java.util.*;
public class Mapx{
public final static String[][] testData1={
{"Happy","Cheerful disposition"},
{"Sleepy"," refers dark,quiet places"},
{"Grumpy","Needs to work on attitude"},
{"Doc","Fantasizes about advanced degree"},
{"Dopey","'A' for effort"},
{"Sneezy","Struggles with allergies"},
{"Bashful","Needs self-esteem workshop"},
};
public final static String[][] testData2={
{"Belligerent","Disruptive influence"},
{"Lazy","Motivational problems"},
{"Comatose","Excellent behavior"}
};
public static Map fill(Map m,Object[][] o){
for (int i=0;i<o.length;i++)
m.put(o[0],o[1]);
return m;
}
public static void printkeys(Map m){
System.out.print("Size="+m.size()+",");
System.out.print("Keys: ");
Collectionx.print(m.keySet());
}
public static void printValues(Map m){
System.out.print("Values:");
Collectionx.print(m.values());
}
public static void print(Map m){
Collection entrySet=m.entrySet();
Iterator it =entrySet.iterator();
while(it.hasNext()){
Map.Entry e=(Map.Entry)it.next();
System.out.println("Key="+e.getKey()+",Value='+e.getValue());
}
}
public static void test(Map m){
fill(m,testData1);
fill(m,testData1);
printKeys(m);
printValues(m);
print(m);
String key=testData1[4][0];
String value=testData1[4][1];
System.out.println("m.containsKey(\""+ key = "\"):"+m.containsKey(key));
System.out.println("m.get(\""+ key +"\"):"+ m.get(key));
System.out.println("m.containsValue(\""+value+"\"):"+m.containsValue(value));
Map m2=fill(new TreeMap(),testData2);
m.putAll(m2);
printkeys(m);
m.remove(testData2[0][0]);
printKeys(m);
m.clear();
System.out.println("m.isEmpty():"+ m.isEmpty());
fill(m,testData1);
m.keySet().removeAll(m.keySet());
System.out.println("m.isEmpty():"+m.isEmpty());
}
public static void main(String args[]){
System.out.println("Testing HashMap");
test(new HashMap());
System.out.println("Testing TreeMap");
test(new TreeMap());
System.out.println("Testing WeakHashMap");
test(new WeakHashMap());
}
}
这段程序的作用是，使用两个二位字符串组创建两个Map对象，然后分别调用其中的几种常用方法，由于执行结果较长，我们只打印出一部分，下面是test方法中调用print(m)的执行结果：
key=Dopey,Value=’A’ for effort
key=Doc,Value=Fantasizes about advanced degree
key=Happy,Value=Cheerful dispostion
key=Sneezy,Value=Struggles with allergies
key=Grumpy,Value=Needs to work on attitude
key=Sleepy,Value=Prefers dark,quiet,quiet places
key=Bashful,Value=Needs self-esteem workshop
可见,虽然testData1被放入了两次，但Map对象中并没有重复的数据，当程序调用：
Map m2=fill(new TreeMap(),testData2);
M.putAll(m2);
我们又可以看到这样的结果：
Size=10,Keys：Dopey|Bashful|Belligerent|Sleepy|Lazy|Happy|Comatose|Grumpy|Sneezy|Doc|
可见testData2中的数据也放进来了。
9.3.5 Utilities
Java1.2添加了自己的一套实用工具，可见来对数组或列表进行排列和搜索。这些工具都属于两个新类的“静态”方法。这两个类分别用于排序和搜索数组的Arrays以及用于排序和搜索列表的Collection。
1. Arrays
Arrays类为所有基本数据类型的数组提供了一个重载的sort()和binarySearch(),它们也可用于String和Object。下面这个例子显示出如何排序和搜索一个字节数组以及一个String数组。
例9.9 数组工具的使用
Arrayx.java的源文件如下：
import java.util.*;
public class Arrayx{
static Random r =new Random(0;
static String ssource="ABCDEFGHIJKLMNOPQRSTUVWXYZ"+"abcdefghijklmnopqrstuvwxyz";
static char[] src=ssource.toCharArray();
public static String randString(int length){
char[] buf=new char[length];
int rnd;
for(int i=0;i<length;i++){
rnd==Math.abs(r.nextInt())%src.length;
buf=src[rnd];
}
return new String(buf);
}
public static String[] randStrings(int length,int size){
String[] s=new String[size];
for(int i=0;i<size;i++)
s=randString(length);
return s;
}
public static void print(byet[] b){
for(int i=0;i<b.length;i++)
System.out.print(b+ " ");
System.out.pringln();
}
public static void print(String[] s){
for(int i=0;i<s.length;i++)
System.out.print(s+ " ");
}
public static void main(String[] args){
byte[] b=new byte[15];
r.nextByte(b);
print(b);
Arrays.sort(b);
print(b);
int loc=Arrays.binarySearch(b,b[10]);
System.out.println("Location of"+ b[10]+"="+ loc;
String[] s=randStrings(4,10);
print(s);
Array.sort(s);
print(s);
loc=Arrays.binarySearch(s,s[4]);
System.out.println("Location of"+ s[4]+"="+ loc);
}
}
程序的一种执行结果为：
-7 ?105 ?110 ?95 ?108 ?37 ?106 ?68 ?104 115 ?94 ?41 ?37 ?116 14
-110 ?108 ?106 ?105 ?104 ?95 ?94 ?68 ?41 ?37 ?7 14 115 116
Location of ?37=9
sqGS voWV hFki vrXB qMbM bZEv Ffcr cISb xhbc RfLW
Ffcr RfLW bZEv cISb hFki qMbM sqGS voWV vrXB xhbc
Lccation of hFki=4
大家知道，进行比较必须有一个比较器，即一个比较的方法。从上面的结果可以看出，对于字符，如果用默认的比较器，会区分大小写。我们希望不区分大小写，就必须自己定义比较器。
如果要对对象进行排序，也需要定义比较器。下面就是一个比较对象的例子。
例9.10 比较对象来排序
CompClass.java的源文件如下：
import java.util.*;
public class CompClass implements Comparable{
private int i;
public CompClass(int ii) {i=ii;}
public int compareTo(Object o){
int argi=((CompClass)o).i;
if(i==argi) return 0;
if(i<argi) return -1;
return 1;
}
public static void print(Object[] a){
for(int i=0;i<a.length;i++)
System.out.print(a+ " ");
System.out.println();
}
public String toString(){return i+ "";}
public static void main(String[] args){
CompClass[] a=new CompClass[20];
for(int i=0;i<a.length;i++)
a=new CompClass((int)(Math.random() *100));
print(a);
Arrays.sort(a);
print(a);
int loc=Arrays.binarySearch(a,a[3]);
System.out.println("Location of"+ a[3]+ "="+(loc+1))
}
}
程序的结果如下：
48 65 62 55 92 56 67 27 86 41 95 60 96 63 89 38 68 40 58 49
27 38 40 41 48 49 55 56 58 60 62 63 65 67 68 85 89 92 95 96
Location of 41=4
2. Collections
Collections类可用与数组相同的形式排列和搜索一个列表。用于排列和搜索列表的静态方法包含在类Collections中，但他们拥有与Arrays中差不多的方法名。
sort(List)用于对一个实现了Comparable的对象列表进行排序。
binarySearch(List,Object)用于查找列表中的某个对象。
sort(List,Comparator)利用一个“比较器”对一个列表进行排序。
binarySearch（List,Object,Comparator）则用于查找那个列表中的一个对象。
例9.11 排序工具示范
ListSort.java的源文件如下：
import java.util.*;
public class ListSort{
public static void main(String[] args){
final int SZ=20;
List a=new ArrayList();
for(int i=0;i<SZ;i++)
a.add(new CompClass((int)(Math.random() *100)));
Collectionx.print(a);
Collections.sort(a);
Collectionx.print(a);
Object find=a.get(SZ/2);
int loc=Collections.binarySearch(a,find);
System.out.println("Location of"+ find+ "="+ loc);
List b=new ArrayList();
for(int i=0;i<SZ;i++)
b.add(Arrayx.randString(4));
Collectionx.print(b);
AlphaComp ac=new AlphaComp();
Collections.sort(b,ac);
Collectionx.print(b);
find=b.get(SZ/2);
loc=Collectoins.binarySearch(b,find,ac);
System.out.println("Location of"+ find+ "="+ loc);
}
}
从程序可以看出，Collections的方法和Arrays基本相同，不再多作解释。它的执行结果是：
40｜25｜88｜39｜87｜47｜25｜75｜83｜65｜43｜33｜76｜13｜88｜90｜97｜73｜0｜97｜
0｜13｜25｜25｜33｜39｜40｜43｜47｜65｜73｜75｜76｜83｜87｜88｜88｜90｜97｜97｜
Location of 73=10
pXom|UXLs|VgHu|wGuu|vbsC|OyGu|xGdF|laAM|laAM|zLFr|PJpn|IaDk
|XNTr|soZW|ukxa|OEsu|dRNy|ObgG|nTrm|pdfh|CjzT
CjzT|dRNy|IaDk|laAM|nTrm|ObgG|OEsu|OyGu|pdfh|
PJpn|pXom|soZW|ukxa|UXLx|vbsCVgHu|wGuu|xGdF|XNTr|zLFr
Location of pXom=10
|
|
发表于 2005-3-6 01:01:00