List和Set及Map用法(2)

本节的目标主要是测试和使用集合框架

1.测试一遍每个类的使用方法
2.测试比较器Comparator和Comparable的使用
3.比较框架中每个类的区别


首先新建一个Boss类

public class Boss {
private int age;
private String name;

public Boss(int age, String name) {
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}

public String toString(){
return "[name:"+name+",age:"+age+"]";
}

/*public int hashCode(){
return name.hashCode();
}*/
public boolean equals(Object o){
Boss b=(Boss)o;
return age==b.age && name.equals(b.name);

}
}

再新建一个Teacher类


public class Teacher implements Comparable {

private int age;
private String name;

public Teacher(int age, String name) {
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}

@Override
public int compareTo(Object obj) {
// TODO Auto-generated method stub
if(obj==null){
return 0;
}
Teacher t=(Teacher)obj;
return age>t.age?1:age==t.age?name.compareTo(t.name):-1;

}



public String toString(){
return "[name:"+name+",age:"+age+"]";
}

}

测试类开始



public class TestUtils {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub

/**
* 测试Iterator接口的遍历
* 测试Enumeration接口的遍历
* 测试Collection接口的方法
*/
Vector<String> l=new Vector<String>();
l.addElement("four");
l.add("one");
l.add("two");
l.add("three");
l.setElementAt("hello", 2);
l.insertElementAt("java", 2);
l.removeElement("hello");
System.out.println("使用Iterator遍历Vector");
printIterator(l);
System.out.println("使用Enumeration遍历Vector");
printEnumeration(l);

List<String> list=new ArrayList<String>();
list.add("jack");
list.add("tom");
ArrayList<String> s=new ArrayList<String>();
s.ensureCapacity(100);//设置容量


System.out.println("使用Iterator遍历list");
printIterator(list);
list.add(1, "hello");
System.out.println("使用Iterator再次遍历list");
printIterator(list);
List<String> ll=new ArrayList<String>();
ll.add("jhon");
ll.add("apple");
list.addAll(ll);
System.out.println("使用Iterator再次遍历list");
printIterator(list);
//list.addAll(index, c);省略
list.remove(1);
System.out.println("list.remove(1),使用Iterator再次遍历list");
boolean b=list.contains("jack");
System.out.println("测试list中是否包含jack="+b);
//list.containsAll(List);省略是否包含某个list集合
System.out.println("用toArray()方法转换成Object数组遍历");
//String[] arr=(String[])list.toArray();//不能直接这样转换,会出错，因为不能保证object数组中的每一个元素能转换成String
//反过来可以String []a=new String[]{"1","2"}; Object[] obj=a;
Object[] arr=list.toArray();
for(Object a:arr){
System.out.println(a.toString());
}
System.out.println("用toArray(数组)方法转换成String数组遍历");
String[] arr1=new String[list.size()];
list.toArray(arr1);
for(String a:arr1){
System.out.println(a);
}
//创建ArrayList类型的数组
ArrayList<String> a1=new ArrayList<String>();
ArrayList<String> a2=new ArrayList<String>();
ArrayList []am=new ArrayList[]{a1,a2};
List []ab=am;

/**
* 测试Collections类：专门操作实现Collection接口的类
*
*
*/

//测试addAll方法
Collections.addAll(list, "newadd");
Collections.addAll(list, "aaaa","ddd","cccc");
System.out.println("使用Collections的addAll()方法添加，Iterator再次遍历list");
printIterator(list);

//测试copy方法
System.out.println("使用Collections的copy()方法copy一份到目标list1，Iterator再次遍历list1");
//这样会出错List<String> list1=new ArrayList<String>(list.size());
List<String> list1=new ArrayList<String>(Arrays.asList(new String[list.size()]));
Collections.copy(list1,list);//相当于深拷贝，而List desc=new ArrayList(List c)属于浅拷贝
printIterator(list1);

//测试fill方法
Collections.fill(list1, "replace");
System.out.println("使用Collections的fill()方法替换所有元素，Iterator再次遍历list1");
printIterator(list1);

//测试replaceAll方法
Collections.replaceAll(list, "aaaa","ddd");
System.out.println("测试replaceAll方法，使用Iterator再次遍历list");
printIterator(list);

//测试sort方法
Collections.sort(list);
System.out.println("测试sort方法，使用Iterator再次遍历list");
printIterator(list);
//Collections.sort(list,Comparator<T>);略按照自定义顺序来排序

//测试binarySearch方法的下标
//Collections.binarySearch(list, "ddd")
System.out.println("测试binarySearch方法，下标位置为第："+Collections.binarySearch(list, "jack"));
//Collections.binarySearch(list, "jack"，comp)//按比较器产生

//测试indexOfSubList方法返回list在大的list中的index
List<String> llist=new ArrayList<String>();
llist.add("ddd");
llist.add("jack");
//llist.add("mm");如果加上就找不到，因为他要包含所有的列表元素
System.out.println("测试indexOfSubList方法，下标位置为第："+Collections.indexOfSubList(list, llist));     
System.out.println("测试max方法，最大值为："+Collections.max(list));
//Collections.max(coll, comp)省略：按比较器产生
System.out.println("测试min方法，最小值为："+Collections.min(list));
//Collections.min(coll, comp)省略：按比较器产生

/**
* 测试Arrays与数组：它是专门用来操作数组的类
*
*/

int []intarr=new int[]{4,2,5,1,3};
int []intarr1=new int[]{4,2,5,1,3};
//测试copyOf方法
System.out.println("测试copyOf方法");
int newarr[]=Arrays.copyOf(intarr,intarr.length+1);//待复制的数组源，要复制的长度
printForeach(newarr);

//测试fill方法
System.out.println("测试fill方法");
Arrays.fill(newarr, 1);
printForeach(newarr);

//测试Arrays.equals比较2个数组是否相等
System.out.println("测试Arrays.equals方法");
System.out.println("测试结果是："+Arrays.equals(intarr, intarr1));

//测试binarySearch方法
System.out.println("测试Arrays.binarySearch方法");
System.out.println("测试结果是："+Arrays.binarySearch(intarr, 5));

//测试sort方法
System.out.println("测试Arrays.sort方法");
Arrays.sort(intarr);
printForeach(intarr);//默认是升序的1，2，3，4，5
//Arrays.sort(intarr,1,5);
//printForeach(intarr);//默认是升序的:结果是4,1,2,3,5,

/**
* Dictionary<K, V>是抽象类，是hashtable的父类,hashtable是property的父类
* put(key,value)，get(key),remove(key),int size(),isEmpty(),Enumeration keys(),Enumeration elements(),
*/
Dictionary<Integer, String> h=new Hashtable<Integer, String>();
System.out.println("Dictionary是否为空："+h.isEmpty());
h.put(new Integer(1), "one");
h.put(new Integer(3), "three");
h.put(new Integer(2), "two");
h.put(new Integer(4), "four");
System.out.println("Dictionary是否为空："+h.isEmpty());
System.out.println("打印Dictionary中的字典值");
printEnumeration(h);

System.out.println("Dictionary中的key为2的值是："+h.get(new Integer(2)));

System.out.println("Dictionary中的元素个数是："+h.size());

System.out.println("Dictionary中移除一个元素是："+h.remove(new Integer(3)));
System.out.println("打印Dictionary中移除后的的字典值");
printEnumeration(h);

System.out.println("打印Dictionary中的key值");
printEnumerationkey(h);

/**
*
* Queue<E>队列 FIFO
*
* 操作失败会抛出异常
* add(e)添加,返回boolean、remove()获取并移除此队列的头、element()获取此队列的头
* 操作失败会返回false或null
* offer(e)添加,返回boolean、poll()获取并移除此队列的头、peek()获取此队列的头
*
*/

Queue<String> q=new PriorityQueue<String>();
System.out.println("空队列用poll()移除，会返回null");
System.out.println(q.poll());
System.out.println("空队列用remove()移除，会抛出异常");
//q.remove();



q.add("aaa");//插入：返回true或false
q.add("bbb");
q.add("kkk");
System.out.println("打印PriorityQueue中的值:"+q.element());//返回第一个元素
System.out.println(q.remove());//移除第一个

System.out.println("打印PriorityQueue中的移除第一个值后的值");
printIterator(q);
q.remove("kkk");
System.out.println("打印PriorityQueue中的移除指定的值");
printIterator(q);
q.offer("ccc");
System.out.println("接着打印PriorityQueue中的值");
printIterator(q);

/**
* 测试
*/
LinkedList<String> linkList=new LinkedList<String>();
linkList.add("one");
linkList.addFirst("first");
linkList.addLast("last");

linkList.offerFirst("ofirst");
linkList.offerLast("olast");
System.out.println("所有元素");
printIterator(linkList);

System.out.println("第一个"+linkList.getFirst());
System.out.println("最后一个"+linkList.getLast());

System.out.println("第一个"+linkList.peekFirst());
System.out.println("最后一个"+linkList.peekLast());

System.out.println("移除第一个"+linkList.removeFirst());
System.out.println("移除最后一个"+linkList.removeLast());

System.out.println("移除第一个"+linkList.pollFirst());
System.out.println("移除最后一个"+linkList.pollLast());

System.out.println("剩下的所有元素");
printIterator(linkList);


/**
* 测试stack：先进后出 LIFO
*
*/
Stack<String> stack=new Stack<String>();
System.out.println("压入："+stack.push("hello"));
System.out.println("压入："+stack.push("java"));
System.out.println("取出(不移除)："+stack.peek());
System.out.println("查出该元素在栈中的位置："+stack.search("hello"));//越在下面的数下标越大，计数从1开始
System.out.println("取出(并移除)："+stack.pop());
System.out.println("取出(并移除)："+stack.pop());
if(!stack.empty()){
System.out.println("取出："+stack.pop());//不能再取了
}

/**
* 测试HashSet,不允许重复，要使数据一致，必须实现hashcode和equals方法
*/
Set<String> set=new HashSet<String>();//参数必须是对象
set.add("aaa");
set.add("bbb");
set.add("aaa");//重复的对象添加不进去
System.out.println("打印HashSet");
printIterator(set);

/**
* 测试TreeSet
* 添加到SortedSet实现类的元素必须实现Comparable接口,否则您必须给它的构造函数提供一个Comparator接口的实现。TreeSet类是它的唯一一份实现。
         * 因为集必须包含唯一的项，如果添加元素时比较两个元素导致了0返回值（通过Comparable的compareTo()方法或Comparator的compare()方法），
         * 那么新元素就没有添加进去。如果两个元素相等，那还好。
         * 但如果它们不相等的话，您接下来就应该修改比较方法，让比较方法和 equals() 的效果一致。”
*/
System.out.println("使用Comparable的compareTo排序");
TreeSet<Teacher> ts=new TreeSet<Teacher>();
ts.add(new Teacher(22,"jack"));
ts.add(new Teacher(22,"jack"));//由此可见TreeSet也是需要重写equals和hashCode
ts.add(new Teacher(25,"tom"));
ts.add(new Teacher(24,"apple"));
ts.add(new Teacher(21,"lili"));
printTeacherIterator(ts);
System.out.println("使用Comparator接口的compare排序");
TreeSet<Boss> bs=new TreeSet<Boss>(new ComparatorSort());
bs.add(new Boss(22,"AAA"));
bs.add(new Boss(22,"ABB"));
bs.add(new Boss(25,"CCC"));
bs.add(new Boss(24,"DDD"));
bs.add(new Boss(21,"EEE"));
printBossIterator(bs);

/**
* 测试TreeMap
*/
TreeMap<Teacher,Integer> tmm=new TreeMap<Teacher,Integer>();
tmm.put(new Teacher(25,"MMM"),new Integer(1));
tmm.put(new Teacher(24,"MMG"),new Integer(2));
tmm.put(new Teacher(26,"LLL"),new Integer(3));

Iterator<Teacher> tts=tmm.keySet().iterator();
while(tts.hasNext()){
Teacher tk=tts.next();
System.out.println(tk+":"+tmm.get(tk));
}
//打印结果是:
//[name:MMG,age:24]:2
//[name:MMM,age:25]:1
//[name:LLL,age:26]:3
//非散列的Set和Map，例如TreeSet,TreeMap等，它们只需equals方法就可以唯一确定对象的身份。这样说，想必已经很清楚了吧。
System.out.println("TreeMap测试按照什么确定唯一性");
TreeMap<Boss,Integer> tm=new TreeMap<Boss,Integer>(new ComparatorSort());
tm.put(new Boss(20,"QQQ"),new Integer(1));
tm.put(new Boss(24,"MMM"),new Integer(4));
tm.put(new Boss(22,"ZZZ"),new Integer(3));
tm.put(new Boss(22,"ZZZ"),new Integer(3));
Iterator<Boss> tss=tm.keySet().iterator();
while(tss.hasNext()){
Boss key=tss.next();
System.out.println(key+":"+tm.get(key));
}
//打印结果是:
//1:[name:MMM,age:20]
//3:[name:LLL,age:22]
//4:[name:MMG,age:24]

/**
* 测试HashMap
*（1）HashMap对key进行散列；
         *（2）keySet(), values(),  entrySet()；通过键（key)计算出存储位置，把值放到这个位置上。
*
*/
HashMap<String, Student> hs=new HashMap<String, Student>();
hs.put("A", new Student(22,"jack"));
hs.put("B", new Student(21,"alice"));
hs.put("C", new Student(25,"jhon"));
hs.put("D", new Student(20,"tom"));
hs.put("M", new Student(20,"tom"));
Iterator<String> hst=hs.keySet().iterator();
while(hst.hasNext()){
String key=hst.next();
System.out.println(key+":"+hs.get(key));
}

HashMap<Boss,String> hsss=new HashMap<Boss,String>();
hsss.put(new Boss(22,"jjjack"),"M");
hsss.put(new Boss(21,"aaalice"),"D");
hsss.put(new Boss(25,"jjjhon"),"A");
hsss.put(new Boss(20,"tttom"),"H");
hsss.put(new Boss(20,"tttom"),"B");//如果不重写equals方法和hashcode就不能做到key值唯一
Iterator<Boss> hsts=hsss.keySet().iterator();
while(hsts.hasNext()){
Boss key=hsts.next();
System.out.println(key+":"+hsss.get(key));
}
//获取值
Iterator<String> hsts1=hsss.values().iterator();
while(hsts1.hasNext()){
System.out.println(hsts1.next());
}
//获取键值
Iterator<Entry<Boss,String>> hsts2=hsss.entrySet().iterator();
while(hsts2.hasNext()){
Map.Entry<Boss,String> key=hsts2.next();
System.out.println(key.getKey()+":"+key.getValue());
}

}

//用Iterator来遍历
public static void printIterator(Collection<String> list){
Iterator<String> it=list.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}

//用Iterator来遍历
public static void printTeacherIterator(Collection<Teacher> list){
Iterator<Teacher> it=list.iterator();
while(it.hasNext()){
Teacher t=(Teacher)it.next();
System.out.println(t.hashCode()+"   "+t);
}
}

//用Iterator来遍历
public static void printBossIterator(Collection<Boss> list){
Iterator<Boss> it=list.iterator();
while(it.hasNext()){
Boss t=(Boss)it.next();
System.out.println(t.hashCode()+"   "+t);
}
}

//用Enumeration来遍历
public static void printEnumeration(Vector<String> v){
Enumeration<String> e=v.elements();
while(e.hasMoreElements()){
System.out.println(e.nextElement());
}
}

//用Enumeration来遍历value
public static void printEnumeration(Dictionary<Integer, String> d){
Enumeration<String> e=d.elements();//枚举值
while(e.hasMoreElements()){
System.out.println(e.nextElement());
}
}

//用Enumeration来遍历打印key
public static void printEnumerationkey(Dictionary<Integer, String> d){
Enumeration<Integer> e=d.keys();
while(e.hasMoreElements()){
System.out.println(e.nextElement());
}
}

//使用增强for循环
public static void printForeach(int []arr){
for(int a:arr){
System.out.print(a+",");
}
System.out.println();
}

}

测试结果如下：


使用Iterator遍历Vector
four
one
java
three
使用Enumeration遍历Vector
four
one
java
three
使用Iterator遍历list
jack
tom
使用Iterator再次遍历list
jack
hello
tom
使用Iterator再次遍历list
jack
hello
tom
jhon
apple
list.remove(1),使用Iterator再次遍历list
测试list中是否包含jack=true
用toArray()方法转换成Object数组遍历
jack
tom
jhon
apple
用toArray(数组)方法转换成String数组遍历
jack
tom
jhon
apple
使用Collections的addAll()方法添加，Iterator再次遍历list
jack
tom
jhon
apple
newadd
aaaa
ddd
cccc
使用Collections的copy()方法copy一份到目标list1，Iterator再次遍历list1
jack
tom
jhon
apple
newadd
aaaa
ddd
cccc
使用Collections的fill()方法替换所有元素，Iterator再次遍历list1
replace
replace
replace
replace
replace
replace
replace
replace
测试replaceAll方法，使用Iterator再次遍历list
jack
tom
jhon
apple
newadd
ddd
ddd
cccc
测试sort方法，使用Iterator再次遍历list
apple
cccc
ddd
ddd
jack
jhon
newadd
tom
测试binarySearch方法，下标位置为第：4
测试indexOfSubList方法，下标位置为第：3
测试max方法，最大值为：tom
测试min方法，最小值为：apple
测试copyOf方法
4,2,5,1,3,0,
测试fill方法
1,1,1,1,1,1,
测试Arrays.equals方法
测试结果是：true
测试Arrays.binarySearch方法
测试结果是：2
测试Arrays.sort方法
1,2,3,4,5,
Dictionary是否为空：true
Dictionary是否为空：false
打印Dictionary中的字典值
four
three
two
one
Dictionary中的key为2的值是：two
Dictionary中的元素个数是：4
Dictionary中移除一个元素是：three
打印Dictionary中移除后的的字典值
four
two
one
打印Dictionary中的key值
4
2
1
空队列用poll()移除，会返回null
null
空队列用remove()移除，会抛出异常
打印PriorityQueue中的值:aaa
aaa
打印PriorityQueue中的移除第一个值后的值
bbb
kkk
打印PriorityQueue中的移除指定的值
bbb
接着打印PriorityQueue中的值
bbb
ccc
所有元素
ofirst
first
one
last
olast
第一个ofirst
最后一个olast
第一个ofirst
最后一个olast
移除第一个ofirst
移除最后一个olast
移除第一个first
移除最后一个last
剩下的所有元素
one
压入：hello
压入：java
取出(不移除)：java
查出该元素在栈中的位置：2
取出(并移除)：java
取出(并移除)：hello
打印HashSet
aaa
bbb
使用Comparable的compareTo排序
21174459   [name:lili,age:21]
827574   [name:jack,age:22]
17510567   [name:apple,age:24]
27744459   [name:tom,age:25]
使用Comparator接口的compare排序
24355087   [name:EEE,age:21]
5442986   [name:AAA,age:22]
10891203   [name:ABB,age:22]
9023134   [name:DDD,age:24]
19336051   [name:CCC,age:25]
[name:MMG,age:24]:2
[name:MMM,age:25]:1
[name:LLL,age:26]:3
TreeMap测试按照什么确定唯一性
[name:QQQ,age:20]:1
[name:ZZZ,age:22]:3
[name:MMM,age:24]:4
D:20{tom}
A:22{jack}
B:21{alice}
C:25{jhon}
M:20{tom}
[name:jjjack,age:22]:M
[name:aaalice,age:21]:D
[name:tttom,age:20]:H
[name:jjjhon,age:25]:A
[name:tttom,age:20]:B


总结一下：

优点
ArrayList：按照序号存储，便于快速查找
LinkedList：支持快速插入和删除
Vector：按照序号存储，数组大小可以动态增长，对大数据存储效率较高
Stack：先进后出的数组

HashSet：基于哈希表，由HashMap支持，加入的对象需要实现equals和hashCode方法
TreeSet:基于红黑树，由TreeMap支持，加入的对象实现Comparable接口的compareTo方法

如果不实现上面的接口，需要重新写一个比较器实现Comparator接口的compare方法，
可以被当作TreeSet构造函数的参数，同样起到比较器的作用。

HashMap：基于哈希表，加入的对象需要实现equals和hashCode方法

TreeMap:基于红黑树，加入的对象实现Comparable接口的compareTo方法

如果不实现上面的接口，需要重新写一个比较器实现Comparator接口的compare方法，
可以被当作TreeSet构造函数的参数，同样起到比较器的作用。

注意：TreeSet和TreeMap不需要实现equals和HashCode方法（个人看法）。

Hashtable也是基于继承自Directionary的键值对

LinkedHashMap（略）

WeekHashMap（略）

Property继承自Hashtable：前一个用于持久集，读写属性文件。

区别
Hashtable和HashMap的区别是：前一个是同步的，后一个不是同步的

Vection和ArrayList的区别是：前一个是同步的，后一个不是同步的

评论

1 楼 qq1002517 2011-04-12  

why no one say something here