分类：
2008-07-19 22:57:27
Set（集）：集合中的对象不按特定方式排序，并且没有重复对象。它的有些实现类能对集合中的对象。它
的有些实现类按特定的方式排序。Set接口主要有两个实现类HashSet和TreeSet。Hash类按照
哈希算法来存取集合中的对象，存取速度比较快。HashSet还有一个子类LinkedHashSet类，它
不仅实现了哈希算法，而且实现了链表数据结构。TreeSet类实现了SortedSet接口，具有排序
功能。
List(类表)：集合中的对象按索引位置排序，可以重复对象，也许按照对象在集合中的索引位置检索对象。
它的接口实现类有LinkedList和ArrayList。前者采用链表数据结构，后者代表大小可变的数组。
List接口还有一个实现类Vector，它的功能和ArrayList比较相似，两者的区别在育Vector类的
实现采用了同步机制，而ArrayList没有。List的两种排序方法：1，sort(List list):对List的对象
进行自然排序；sort(List list,Comparator comparator)：对List中的对象进行客户化排序。
Map(映射)：集合中的每一个元素包括一对键对象和值对象，集合中没有重复的键对象，只对象可以重复。
它的有些实现能对集合中的键对象进行排序。
Hibernate允许把以上三种Java集合都映射到数据库中，在映射文件中，与映射Java集合相关的元素包括
和
两种排序：自然排序和客户排序
总的说来，Java API中所用的集合类，都是实现了Collection接口，他的一个类继承结构如下：
Collection<--List<--Vector
Collection<--List<--ArrayList
Collection<--List<--LinkedList
Collection<--Set<--HashSet
Collection<--Set<--HashSet<--LinkedHashSet
Collection<--Set<--SortedSet<--TreeSet
Vector : 基于Array的List，其实就是封装了Array所不具备的一些功能方便我们使用，它不可能走入Array的限制。性能也就不可能超越Array。所以，在可能的情况下，我们要多运用Array。另外很重要的一点就是Vector“sychronized”的，这个也是Vector和ArrayList的唯一的区别。
ArrayList：同Vector一样是一个基于Array上的链表，但是不同的是ArrayList不是同步的。所以在性能上要比Vector优越一些，但是当运行到多线程环境中时，可需要自己在管理线程的同步问题。
LinkedList：LinkedList不同于前面两种List，它不是基于Array的，所以不受Array性能的限制。它每一个节点（Node）都包含两方面的内容：1.节点本身的数据（data）；2.下一个节点的信息（nextNode）。所以当对LinkedList做添加，删除动作的时候就不用像基于Array的List一样，必须进行大量的数据移动。只要更改nextNode的相关信息就可以实现了。这就是LinkedList的优势。
List总结：
1. 所有的List中只能容纳单个不同类型的对象组成的表，而不是Key－Value键值对。例如：[ tom,1,c ]；
2. 所有的List中可以有相同的元素，例如Vector中可以有 [ tom,koo,too,koo ]；
3. 所有的List中可以有null元素，例如[ tom,null,1 ]；
4. 基于Array的List（Vector，ArrayList）适合查询，而LinkedList（链表）适合添加，删除操作。
HashSet：虽然Set同List都实现了Collection接口，但是他们的实现方式却大不一样。List基本上都是以Array为基础。但是Set则是在HashMap的基础上来实现的，这个就是Set和List的根本区别。HashSet的存储方式是把HashMap中的Key作为Set的对应存储项。看看HashSet的add（Object obj）方法的实现就可以一目了然了。
public boolean add(Object obj)
{
return map.put(obj, PRESENT) == null;
}
这个也是为什么在Set中不能像在List中一样有重复的项的根本原因，因为HashMap的key是不能有重复的。
LinkedHashSet：HashSet的一个子类，一个链表。
TreeSet：SortedSet的子类，它不同于HashSet的根本就是TreeSet是有序的。它是通过SortedMap来实现的。
Set总结：
1. Set实现的基础是Map（HashMap）；
2. Set中的元素是不能重复的，如果使用add(Object obj)方法添加已经存在的对象，则会覆盖前面的对象；
Java集合类
集合中存放的是对象的引用,而非对象本身 ,出于表达上的便利,简称为"集合中的对象".
Set(集):集合中的对象不按特定方式排列,并且没有重复对象,它的有些实现类能对集合中的对象按特定方式排列.
set接口主要有两个实现类HashSet和TreeSet,HashSet类按照哈希算法来存取集合中的对象,存取速度比较快,HashSet类还有一个子类LinkedHashSet类,不仅
实现了哈希算法,而且实现了链表数据结构,TreeSet类实现了SortedSet接口,具有排序功能.
那么,当一个新的对象加入到Set集合中,Set的add()方法是如何判断这个对象是否已经存在于集合中的呢?
boolean isExists=false;
Iterator it=set.iterator();
while(it.hasNext())
{
Object oldObject=it.next();
if(newObject.equals(oldObject))
{
isExists=true;
break;
}
}
可见,Set采用对象的equals()方法比较两个对象是否相等,而不是采用"=="比较运算符,以下程序代码尽管两次调用了Set的add()方法,
实际上只加入了一个对象:
Set set=new HashSet();
String s1=new String("hello");
String s2=new String("hello");
set.add(s1);
set.add(s2);
虽然变量s1和s2实际上引用的是两个内存地址不同的字符串对象,但是由于s2.equals(s1)的比较结果为true,因此Set认为他们是相等的对象,当第二次调用
Set的add()方法时,add()方法不会把s2引用的字符串对象加入到集合中.
HashSet类
按照哈希算法来存取集合中的对象,具有很好的存取性能,当HashSet向集合中加入一个对象时,会调用对象的hashCode()方法获得哈希码,然后根据这个哈希码
进一步计算出对象在集合中的存放位置.
在Object类中定义了hashCode()和equals()方法,Object类的euqals()方法按照内存地址比较对象是否相等,因此如果object1.equals(object2)为true,表明object1
变量和object2变量十九上引用同一个对象.那么object1和object2的哈希码也应该相同.
***如果用户定义的类覆盖了Object类的equals()方法,但是没有覆盖Object类的hashCode()方法,就会导致当object1.equals(object2)为true时,而object1和object2的
哈希码不一定一样,这样使HashSet无法正常工作.
TreeSet类:
实现了SortedSet接口,能够对集合中的对象进行排序.
如：
Set set=new TreeSet();
set.add(new Integer(7));
set.add(new Integer(9));
set.add(new Integer(8));
Iterator it=set.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
输出结果为:6 7 8
当TreeSet向集合中加入一个对象时,会把它插入到有序的对象序列中,那么TreeSet是如何对对象进行排序的捏?TreeSet支持
两种排序方式:自然排序和客户化排序,默认情况下是自然排序.
在JDK中,有一部分类实现了Comparable接口,如Integer,Double和String等,Comparable接口有一个compareTo(Object o)方法,
它返回整数类型,对于表达式x.compareTo(y),如果返回值为0,表示x和y相等,如果返回值大于0,表示x大于y,如果小于0,表示x
客户化排序:
当表达式compare(x,y)的值大于0,表示x大于y,小于0,表示x小于y,等于0,表示x等于y,如果想让TreeSet进按照Customer对象的
name属性进行降序排列,可以先创建实现Comparator接口的类CustomerComparator,如:
import java.util.*;
public class CustomerComparator implements Comparator
{
public int compare(Object o1,Object o2)
{
Customer c1=(Custoemr)o1;
Customer c2=(Customer)o2;
if(c1.getName().compareTo(c2.getName())>0) return -1;
if(c1.getName().compareTo(c2.getName())<0) return 1;
return 0;
}
}
接下来在构造TreeSet的实例时,调用它的TreeSet(Comparator comparator)构造方法
Set set=new TreeSet(new CustomerComparator());
Customer c1=new Customer("TOM",15);
Customer c2=new Customer("JACK",20);
Customer c3=new Customer("MIKE",38);
set.add(c1);set.add(c2);set.add(c3);
Iterator it=set.iterator();
while(it.hasNext())
{Custoemr customer=(Customer)it.next();
System.out.println(customer.getName()+"" +customer.getAge();)
当TreeSet向集合中加入Customer对象时,会调用CustomerComparator类的compare()方法进行排序,以上Tree按照
Custoemr对象的name属性进行降序排列,最后输出为:
TOM 15 MIKE 38 JACK 16
List(列表):对象以线性方式存储,集合中的对象按索引位置排序,可以有重复对象,允许按照对象在集合中的索引位置检索对象.
实现类有LinkedList,ArrayList和Vector,LinkedList采用链表数据结构,而ArrayList代表大小可变的数组, Vector和
ArrayList比较相似,两者的区别在于Vecotr类的实现采用了同步机制,而ArrayList没有使用同步机制/
List按索引排列:
List list=new ArrayList();
list.add(new Integer(3));
list.add(new Integer(4));
list.add(new Integer(3));
list.add(new Integer(2));
List的get(int index)方法返回集合中由参数index指定的索引位置的对象,第一个加入到集合中的对象的索引位置为0,
for( int i=0,i
输出结果为:3 4 3 2.
List只能对集合中的对象按索引位置排序,如果希望对List中的对象按其他特定方式排序,可以借助Comparator接口和Collections类.
Collections类是Java集合API中的辅助类,它提供了操纵集合的各种静态方法,
其中sort()方法用于对List中的对象进行排序:
sort(List list):对List中的对象进行自然排序.
sort(List list,Comparator comparator):对List中的对象进行客户化排序,comparator参数指定排序方式.
对以下List进行自然排序:
List list=new ArrayList();
list.add(new Integer(3));
list.add(new Integer(4));
list.add(new Integer(3));
list.add(new Integer(2));
Collections.sort(list);
for(int i=0;i
System.out.println(list.get(i));
}
以上输出结果:2 3 3 4
Map(映射):集合中的每一个元素包含一对键对象和一对值对象,集合中没有重复的键对象,值对象可以重复,它的有写实现类能
对集合中的键对象进行排序.
Map map=new HashMap();
map.put("1","Mon");
map.put("1",Monday);
map.put("2","monday");
由于第一次和第二次加入到Map中的键对象都是1,所以第一次加入的值对象将被覆盖,而第二个和第三个的值对象虽然相同,但是
Map有两种比较常用的实现:HashMap和TreeMap.Hashmap按照哈希算法来存取键对象,有很好的存取能力,为了保证HashMap能正常工作,
和HashSet一样,要求当两个键对象通过equals()方法比较为true时,这两个键对象的hashCode()方法返回的哈希码也一样.
TreeMap实现了SortedMap接口,能对键对象进行排序,和TreeSet一样,TreeMap也支持自然排序和客户化排序两种方式,以下程序中的TreeMap
会对四个字符串类型的键对象"1","3","4","2"进行自然排序:
Map map=new TreeMap();
map.put("1","Monday");
map.put("3","Wendsday");
map.put("4","Thursday");
map.put("2",
"Tuesday");
//返回集合中所有键对象的集合
Set keys=map.keySet();
Iterator it=keys.iterator();
while(it.hasNext)
{String key=(String)it.next();
//根据键对象得到值对象
String value=(String)map.get(key);
System.out.println(key+"" +value);
}
以上输出结果为:1 Monday 2 Wendsday 3 Thursday 4 Tuesday
如果希望TreeMap进行客户化排序,可以调用它的另一个构造方法TreeMap(Comparator comparator),参数comparator指定具体的排序方式.
