java集合的区别,Java中Set、List、Map集合类（接口）的特点及区别是什么？

java集合的区别,Java中Set、List、Map集合类（接口）的特点及区别是什么？详细介绍

本文目录一览： JAVA中几种集合(List、Set和Map)的区别

Set对每个对象只接受一次，并使用自己内部的排序方法(通常，你只关心某个元素是否属于Set,而不关心它的顺序--否则应该使用List)。Map同样对每个元素保存一份，但这是基于"键"的，Map也有内置的排序，因而不关心元素添加的顺序。如果添加元素的顺序对你很重要，应该使用 LinkedHashSet或者LinkedHashMap.
总结:List有顺序有重复没有排序，set无重复有排序，map的key也和set一样。如果想跟List一样需要有插入元素的顺序，请使用LinkedHashSet或者LinkedHashMap。
　　List的功能方法
　　实际上有两种List: 一种是基本的ArrayList,其优点在于随机访问元素，另一种是更强大的LinkedList,它并不是为快速随机访问设计的，而是具有一套更通用的方法。
　　List : 次序是List最重要的特点：它保证维护元素特定的顺序。List为Collection添加了许多方法，使得能够向List中间插入与移除元素(这只推荐LinkedList使用。)一个List可以生成ListIterator,使用它可以从两个方向遍历List,也可以从List中间插入和移除元素。
　　ArrayList : 由数组实现的List。允许对元素进行快速随机访问，但是向List中间插入与移除元素的速度很慢。ListIterator只应该用来由后向前遍历ArrayList,而不是用来插入和移除元素。因为那比LinkedList开销要大很多。
　　LinkedList : 对顺序访问进行了优化，向List中间插入与删除的开销并不大。随机访问则相对较慢。(使用ArrayList代替。)还具有下列方法：addFirst(), addLast(), getFirst(), getLast(), removeFirst() 和 removeLast(), 这些方法 (没有在任何接口或基类中定义过)使得LinkedList可以当作堆栈、队列和双向队列使用。
　　Set的功能方法
　　Set : 存入Set的每个元素都必须是唯一的，因为Set不保存重复元素。加入Set的元素必须定义equals()方法以确保对象的唯一性。Set与Collection有完全一样的接口。Set接口不保证维护元素的次序。
　　HashSet : 为快速查找设计的Set。存入HashSet的对象必须定义hashCode()。
　　TreeSet : 保存次序的Set, 底层为树结构。使用它可以从Set中提取有序的序列。
　　LinkedHashSet : 具有HashSet的查询速度，且内部使用链表维护元素的顺序(插入的次序)。于是在使用迭代器遍历Set时，结果会按元素插入的次序显示。
　　Map的功能方法
　　方法put(Object key, Object value)添加一个“值”(想要得东西)和与“值”相关联的“键”(key)(使用它来查找)。方法get(Object key)返回与给定“键”相关联的“值”。可以用containsKey()和containsValue()测试Map中是否包含某个“键”或“值”。标准的Java类库中包含了几种不同的Map：HashMap, TreeMap, LinkedHashMap, WeakHashMap, IdentityHashMap。它们都有同样的基本接口Map，但是行为、效率、排序策略、保存对象的生命周期和判定“键”等价的策略等各不相同。
　　执行效率是Map的一个大问题。看看get()要做哪些事，就会明白为什么在ArrayList中搜索“键”是相当慢的。而这正是HashMap提高速度的地方。HashMap使用了特殊的值，称为“散列码”(hash code)，来取代对键的缓慢搜索。“散列码”是“相对唯一”用以代表对象的int值，它是通过将该对象的某些信息进行转换而生成的。所有Java对象都能产生散列码，因为hashCode()是定义在基类Object中的方法。
　　HashMap就是使用对象的hashCode()进行快速查询的。此方法能够显著提高性能。
　　Map : 维护“键值对”的关联性，使你可以通过“键”查找“值”
　　HashMap : Map基于散列表的实现。插入和查询“键值对”的开销是固定的。可以通过构造器设置容量capacity和负载因子load factor，以调整容器的性能。
　　LinkedHashMap : 类似于HashMap，但是迭代遍历它时，取得“键值对”的顺序是其插入次序，或者是最近最少使用(LRU)的次序。只比HashMap慢一点。而在迭代访问时发而更快，因为它使用链表维护内部次序。
　　TreeMap : 基于红黑树数据结构的实现。查看“键”或“键值对”时，它们会被排序(次序由Comparabel或Comparator决定)。TreeMap的特点在于，你得到的结果是经过排序的。TreeMap是唯一的带有subMap()方法的Map，它可以返回一个子树。
　　WeakHashMao : 弱键(weak key)Map，Map中使用的对象也被允许释放: 这是为解决特殊问题设计的。如果没有map之外的引用指向某个“键”，则此“键”可以被垃圾收集器回收。
　　IdentifyHashMap : 使用==代替equals()对“键”作比较的hash map。专为解决特殊问题而设计。

Java中的Set,List,Map的区别

　　对JAVA的集合的理解是想对于数组
　　数组是大小固定的 并且同一个数组只能存放类型一样的数据（基本类型/引用类型）
　　JAVA集合可以存储和操作数目不固定的一组数据
　　所有的JAVA集合都位于 java util包中！
　　JAVA集合只能存放引用类型的的数据 不能存放基本数据类型

　　JAVA集合主要分为三种类型
　　Set(集)
　　List(列表)
　　Map(映射)
　　Collection 接口
　　Collection是最基本的集合接口 声明了适用于JAVA集合（只包括Set和List）的通用方法
　　Set 和List 都继承了Conllection Map没有
　　Collection接口的方法
　　boolean add(Object o) :向集合中加入一个对象的引用
　　void clear() :删除集合中所有的对象 即不再持有这些对象的引用
　　boolean isEmpty() :判断集合是否为空
　　boolean contains(Object o): 判断集合中是否持有特定对象的引用
　　Iterartor iterator() : 返回一个Iterator对象 可以用来遍历集合中的元素
　　boolean remove(Object o):从集合中删除一个对象的引用
　　int size() :返回集合中元素的数目
　　Object[] toArray() :返回一个数组 该数组中包括集合中的所有元素
　　关于 Iterator() 和toArray() 方法都用于集合的所有的元素 前者返回一个Iterator对象 后者返回一个
　　包含集合中所有元素的数组
　　Iterator接口声明了如下方法
　　hasNext(): 判断集合中元素是否遍历完毕 如果没有 就返回true
　　next() :返回下一个元素
　　remove():从集合中删除上一个有next()方法返回的元素
　　Set(集合)
　　Set是最简单的一种集合 集合中的对象不按特定的方式排序 并且没有重复对象
　　Set接口主要实现了两个实现类
　　HashSet : HashSet类按照哈希算法来存取集合中的对象 存取速度比较快
　　TreeSet : TreeSet类实现了SortedSet接口 能够对集合中的对象进行排序
　　Set 的用法
　　存放的是对象的引用 没有重复对象
　　Set set=new HashSet();
　　String s =new String( hello );
　　String s =s ;
　　String s =new String( world );
　　set add(s );
　　set add(s );
　　set add(s );
　　System out println(set size());//打印集合中对象的数目 为
　　Set 的 add()方法是如何判断对象是否已经存放在集合中？
　　boolean isExists=false;
　　Iterator iterator=erator();
　　while(it hasNext()) {
　　String oldStr=it next();
　　if(newStr equals(oldStr)){
　　isExists=true;
　　}
　　}
　　List(列表)
　　List的特征是其元素以线性方式存储 集合中可以存放重复对象
　　List接口主要实现类包括
　　ArrayList() : 代表长度可以改变得数组 可以对元素进行随机的访问 向ArrayList()中插入与
　　与删除元素的速度慢
　　LinkedList(): 在实现中采用链表数据结构 插入和删除速度快 访问速度慢
　　对于List的随机访问来说 就是只随机来检索位于特定位置的元素
　　List 的 get(int index) 方法放回集合中由参数index指定的索引位置的对象 下标从 开始
　　最基本的两种检索集合中的所有对象的方法
　　 : 用for循环和get()方法
　　for(int i= ; i
<list size();i++){
　　System out println(list get(i));

　　}

　　 : 使用 迭代器（Iterator）:

　　Iterator it=erator();

　　while(it hashNext){

　　System out println(it next);

　　}

　　Map(映射):

　　Map 是一种把键对象和值对象映射的集合 它的每一个元素都包含一对键对象和值对象

　　Map没有继承于Collection接口

　　从Map集合中检索元素时 只要给出键对象 就会返回对应的值对象

　　Map 的常用方法

　　 添加 删除操作

　　Object put(Object key Object value): 向集合中加入元素

　　Object remove(Object key): 删除与KEY相关的元素

　　void putAll(Map t): 将来自特定映像的所有元素添加给该映像

　　void clear(): 从映像中删除所有映射

　　 查询操作

　　Object get(Object key): 获得与关键字key相关的值

　　Map集合中的键对象不允许重复 也就说 任意两个键对象通过equals()方法比较的结果都是false

　　但是可以将任意多个键独享映射到同一个值对象上

　　Conllections : 集合实用类

　　Conllections提供了供JAVA集合实用的静态方法

　　总结

　　JAVA集合的基本用法 都归纳了 上面这些是平常最常用的JAVA集合 具体的其他的 还要参考JDK帮助文档了 呵呵 关于 Map的应用 还有很多 具体就是这个 Conllections提供了很多 List /Map 实用的方法 对平常开发非常有用

　　对次会会不断修改！

　　boolean containsKey(Object key): 判断映像中是否存在关键字key

　　boolean containsValue(Object value): 判断映像中是否存在值value

　　int size(): 返回当前映像中映射的数量

　　boolean isEmpty() 判断映像中是否有任何映射

　　List按对象进入的顺序保存对象 不做排序或编辑操作 Set对每个对象只接受一次 并使用自己内部的排序方法(通常 你只关心某个元素是否属于Set 而不关心它的顺序 否则应该使用List) Map同样对每个元素保存一份 但这是基于 键 的 Map也有内置的排序 因而不关心元素添加的顺序 如果添加元素的顺序对你很重要 应该使用 LinkedHashSet或者LinkedHashMap

　　List的功能方法

　　实际上有两种List: 一种是基本的ArrayList 其优点在于随机访问元素 另一种是更强大的LinkedList 它并不是为快速随机访问设计的 而是具有一套更通用的方法

　　List : 次序是List最重要的特点 它保证维护元素特定的顺序 List为Collection添加了许多方法 使得能够向List中间插入与移除元素(这只推荐LinkedList使用 )一个List可以生成ListIterator 使用它可以从两个方向遍历List 也可以从List中间插入和移除元素

　　ArrayList : 由数组实现的List 允许对元素进行快速随机访问 但是向List中间插入与移除元素的速度很慢 ListIterator只应该用来由后向前遍历ArrayList 而不是用来插入和移除元素 因为那比LinkedList开销要大很多

　　LinkedList : 对顺序访问进行了优化 向List中间插入与删除的开销并不大 随机访问则相对较慢 (使用ArrayList代替 )还具有下列方法 addFirst() addLast() getFirst() getLast() removeFirst() 和 removeLast() 这些方法 (没有在任何接口或基类中定义过)使得LinkedList可以当作堆栈 队列和双向队列使用

　　Set的功能方法

　　Set具有与Collection完全一样的接口 因此没有任何额外的功能 不像前面有两个不同的List 实际上Set就是Collection 只是行为不同 (这是继承与多态思想的典型应用 表现不同的行为 )Set不保存重复的元素(至于如何判断元素相同则较为负责)

　　Set : 存入Set的每个元素都必须是唯一的 因为Set不保存重复元素 加入Set的元素必须定义equals()方法以确保对象的唯一性 Set与Collection有完全一样的接口 Set接口不保证维护元素的次序

　　HashSet : 为快速查找设计的Set 存入HashSet的对象必须定义hashCode()

　　TreeSet : 保存次序的Set 底层为树结构 使用它可以从Set中提取有序的序列

　　LinkedHashSet : 具有HashSet的查询速度 且内部使用链表维护元素的顺序(插入的次序) 于是在使用迭代器遍历Set时 结果会按元素插入的次序显示

　　Map的功能方法

　　方法put(Object key Object value)添加一个 值 (想要得东西)和与 值 相关联的 键 (key)(使用它来查找) 方法get(Object key)返回与给定 键 相关联的 值 可以用containsKey()和containsValue()测试Map中是否包含某个 键 或 值 标准的Java类库中包含了几种不同的Map HashMap TreeMap LinkedHashMap WeakHashMap IdentityHashMap 它们都有同样的基本接口Map 但是行为 效率 排序策略 保存对象的生命周期和判定 键 等价的策略等各不相同

　　执行效率是Map的一个大问题 看看get()要做哪些事 就会明白为什么在ArrayList中搜索 键 是相当慢的 而这正是HashMap提高速度的地方 HashMap使用了特殊的值 称为 散列码 (hash code) 来取代对键的缓慢搜索 散列码 是 相对唯一 用以代表对象的int值 它是通过将该对象的某些信息进行转换而生成的 所有Java对象都能产生散列码 因为hashCode()是定义在基类Object中的方法

　　HashMap就是使用对象的hashCode()进行快速查询的 此方法能够显著提高性能

　　Map : 维护 键值对 的关联性 使你可以通过 键 查找 值

　　HashMap : Map基于散列表的实现 插入和查询 键值对 的开销是固定的 可以通过构造器设置容量capacity和负载因子load factor 以调整容器的性能

　　LinkedHashMap : 类似于HashMap 但是迭代遍历它时 取得 键值对 的顺序是其插入次序 或者是最近最少使用(LRU)的次序 只比HashMap慢一点 而在迭代访问时发而更快 因为它使用链表维护内部次序

　　TreeMap : 基于红黑树数据结构的实现 查看 键 或 键值对 时 它们会被排序(次序由Comparabel或Comparator决定) TreeMap的特点在于 你得到的结果是经过排序的 TreeMap是唯一的带有subMap()方法的Map 它可以返回一个子树

　　WeakHashMao : 弱键(weak key)Map Map中使用的对象也被允许释放: 这是为解决特殊问题设计的 如果没有map之外的引用指向某个 键 则此 键 可以被垃圾收集器回收

lishixinzhi/Article/program/Java/ky/201311/27866

Java五个最常用的集合类之间的区别和联系

1. ArrayList: 元素单个,效率高,多用于查询
2. Vector: 元素单个,线程安全,多用于查询
3. LinkedList:元素单个,多用于插入和删除
4. HashMap: 元素成对,元素可为空
5. HashTable: 元素成对,线程安全,元素不可为空
集合类型主要有3种：set(集）、bailist(列表）和map(映射)。
1、List（有序、可重复）
List里存放的对象是有序的，同时也是可以重复的，List关注的是索引，拥有一系列和索引相关的方法，查询速度快。因为往list集合里插入或删除数据时，会伴随着后面数据的移动，所有插入删除数据速度慢。
2、Set（无序、不能重复）
Set里存放的对象是无序，不能重复的，集合中的对象不按特定的方式排序，只是简单地把对象加入集合中。
3、Map（键值对、键唯一、值不唯一）
Map集合中存储的是键值对，键不能重复，值可以重复。根据键得到值，对map集合遍历时先得到键的set集合，对set集合进行遍历，得到相应的值。

Java五个最常用的集合类之间的区别和联系

常用的集合类有一下几种：
List结构的集合类：ArrayList类，LinkedList类，Vector类，Stack类
Map结构的集合类：HashMap类，Hashtable类
Set结构的集合类：HashSet类，TreeSet类
Queue结构的集合：Queue接口
HashMap和Hashtable的区别：
HashMap和Hashtable都是java的集合类，都可以用来存放java对象，这是他们的相同点
以下是他们的区别：
1.历史原因：
Hashtable是基于陈旧的Dictionary类的，HashMap是java 1.2引进的Map接口的一个现实。
2.同步性：
Hashtable是同步的，这个类中的一些方法保证了Hashtable中的对象是线程安全的，而HashMap则是异步的，因此HashMap中的对象并不是线程安全的，因为同步的要求会影响执行的效率，所以如果你不需要线程安全的结合那么使用HashMap是一个很好的选择，这样可以避免由于同步带来的不必要的性能开销，从而提高效率，我们一般所编写的程序都是异步的，但如果是服务器端的代码除外。
3.值：
HashMap可以让你将空值作为一个表的条目的key或value
Hashtable是不能放入空值（null）的
ArrayList和Vector的区别：
ArrayList与Vector都是java的集合类，都是用来存放java对象，这是他们的相同点，
区别：
1.同步性：
Vector是同步的，这个类的一些方法保证了Vector中的对象的线程安全的，而ArrayList则是异步的，因此ArrayList中的对象并不 是线程安全的，因为同步要求会影响执行的效率，所以你不需要线程安全的集合那么使用ArrayList是一个很好的选择，这样可以避免由于同步带来的不必 要的性能开销。
2.数据增长：
从内部实现的机制来讲，ArrayList和Vector都是使用数组（Array）来控制集合中的对象，当你向两种类型中增加元素的时候，如果元素的数目超过了内部数组目前的长度他们都需要扩展内部数组的长度，Vector缺省情况下自动增长原来一倍的数组长度，ArrayList是原来的50%，所以最后你获得的这个集合所占的空间总是比你实际需要的要大，所以如果你要在集合中保存大量的数据，那么使用Vector有一些优势，因为你可以通过设置集合的初始大小来避免不必要的资源开销。
总结：
1）如果要求线程安全，使用Vector，Hashtable
2）如果不要求线程安全，使用ArrayList，LinkedList，HashMap
3)如果要求键值对，则使用HashMap，Hashtable
4）如果数据量很大，又要求线程安全考虑Vector
1．ArrayList: 元素单个，效率高，多用于查询
2．Vector: 元素单个，线程安全，多用于查询
3．LinkedList:元素单个，多用于插入和删除
4．HashMap: 元素成对，元素可为空
5．HashTable: 元素成对，线程安全，元素不可为空
ArrayList
底层是Object数组，所以ArrayList具有数组的查询速度快的优点以及增删速度慢的缺点。
而在LinkedList的底层是一种双向循环链表。在此链表上每一个数据节点都由三部分组成：前指针（指向前面的节点的位置），数据，后指针（指向后面的节点的位置）。最后一个节点的后指针指向第一个节点的前指针，形成一个循环。
双向循环链表的查询效率低但是增删效率高。
ArrayList和LinkedList在用法上没有区别，但是在功能上还是有区别的。
LinkedList
经常用在增删操作较多而查询操作很少的情况下：队列和堆栈。
队列：先进先出的数据结构。
栈：后进先出的数据结构。
注意：使用栈的时候一定不能提供方法让不是最后一个元素的元素获得出栈的机会。
Vector
（与ArrayList相似，区别是Vector是重量级的组件，使用使消耗的资源比较多。）
结论：在考虑并发的情况下用Vector（保证线程的安全）。
在不考虑并发的情况下用ArrayList（不能保证线程的安全）。
面试经验（知识点）：
java.util.stack（stack即为堆栈）的父类为Vector。可是stack的父类是最不应该为Vector的。因为Vector的底层是数组，且Vector有get方法（意味着它可能访问到并不属于最后一个位置元素的其他元素，很不安全）。
对于堆栈和队列只能用push类和get类。
Stack类以后不要轻易使用。
实现栈一定要用LinkedList。
（在JAVA1.5中，collection有queue来实现队列。）
Set-HashSet实现类：
遍历一个Set的方法只有一个：迭代器（interator）。
HashSet中元素是无序的（这个无序指的是数据的添加顺序和后来的排列顺序不同），而且元素不可重复。
在Object中除了有finalize()，toString()，equals()，还有hashCode()。
HashSet底层用的也是数组。
当向数组中利用add(Object o)添加对象的时候，系统先找对象的hashCode：
int hc=o.hashCode(); 返回的hashCode为整数值。
Int I=hc%n;（n为数组的长度），取得余数后，利用余数向数组中相应的位置添加数据，以n为6为例，如果I=0则放在数组a[0]位置，如果I=1,则 放在数组a[1]位置。如果equals()返回的值为true，则说明数据重复。如果equals()返回的值为false，则再找其他的位置进行比 较。这样的机制就导致两个相同的对象有可能重复地添加到数组中，因为他们的hashCode不同。
如果我们能够使两个相同的对象具有相同hashcode，才能在equals()返回为真。
在实例中，定义student对象时覆盖它的hashcode。
因为String类是自动覆盖的，所以当比较String类的对象的时候，就不会出现有两个相同的string对象的情况。
现在，在大部分的JDK中，都已经要求覆盖了hashCode。
结论：如将自定义类用hashSet来添加对象，一定要覆盖hashcode()和equals()，覆盖的原则是保证当两个对象hashcode返回相同的整数，而且equals()返回值为True。
如果偷懒，没有设定equals()，就会造成返回hashCode虽然结果相同，但在程序执行的过程中会多次地调用equals()，从而影响程序执行的效率。

JAVA中的几个集合的区别在哪？

List是有序，数据可以重复set是无序（可以自己排序），数据不能重复.Map是键值成对的保存数据，键和Set一样不能重复无序，值就随便了，可以任意其实Set的底层实现用的就是Map。。的键（key）
list map set三个都是接口 　 Map 映射表， 一个key只能对应一个value(它的反命题，一个value只对应一个key不成立) 最常用的有: Map L--- HashMap (key可以null) L--- HashTable (key不能为null) 　 L---Properties （适合读取.properties格式的文件） L--- SortedMap(interface根据Key排序) L---TreeMap(用二叉树实现key排序) 　 List 和 Set 都是线性的，主要区别是List里面存放的内容可以重复，而Set同一对象只保留唯一的一个。因此，Map里面，提取Key集合的返回类型是Set,而提取Value集合的类型是Collection(List/Set)的父类型。 常用的有 List L---LinkedList（链表） L---ArrayList（动态数组，所有方法不同步） L---Vector（动态数组，所有方法同步） L---Stack（可以实现LIFO的栈）

Java中Set、List、Map集合类（接口）的特点及区别是什么？

SET无序，不可重复
List有序，可重复
Map是成对放的，一放一对。。分成KEY和VALUE
Set：检索元素效率低下，删除和插入效率高，插入和删除不会引起元素位置改变；
List：和数组类似，List可以动态增长，查找元素效率高，插入删除元素效率低，因为会引起其他元素位置改变；
Map：适合储存键值对的数据。
Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。
Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。

在java中集合List,Set,Map,Properties的区别？

List和set继承于Collection接口，Map不是。
List中的元素是无序的，可以重复。
Set是有序的，不能重复。
Map是已key和value的形式存储的，key不能重复，value可以重复。
最后一个没用过。
楼下说错了 List是有序的 Set应该是无序的 但是Treeset有序【特殊】 Hashset无序 谢谢 希望能帮到您
List接口是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。
Set接口:定义一个不包含重复元素的规则。添加时候是没有顺序的。
Map接口:将键映射到值。一个映射不能包含重复的键，每个键最多只能映射到一个值。
Properties类是HashTable（实现了Map接口）的子类。HashTable是同步的。

java中 List 与Set 有什么区别？

Java的集合类都位于java.util包中，Java集合中存放的是对象的引用，而非对象本身。
Java集合主要分为三种类型：
a.Set（集）：集合中的对象不按特定方式排序，并且没有重复对象。它的有些实现类能对集合中的对象按特定方式排序。
b.List（列表）：集合中的对象按索引位置排序，可以有重复对象，允许按照对象在集合中的索引位置检索对象。
c.Map（映射）：集合中的每一个元素包含一对键对象和值对象，集合中没有重复的键对象，值对象可以重复。它的有些实现类能对集合中的键对象进行排序。
Set、List和Map统称为Java集合。
1.Set(集)
Set集合中的对象不按特定方式排序，并且没有重复对象。Set接口主要有两个实现类HashSet和TreeSet。HashSet类按照哈希算法来存取集合中的对象，存取速度比较快。HashSet类还有一个子类LinkedHashSet类，它不仅实现了哈希算法，而且实现了链表数据结构。TreeSet类实现了SortedSet接口，具有排序功能。
Set的add()方法判断对象是否已经存在于集合中的判断流程：
boolean isExists = false;
Iterator it = set.iterator();
while(it.hasNext()){
Object object = it.next();
if(newObject.equals(oldObject)){
isExists = true;
break;
}
}
2.HashSet类
当HashSet向集合中加入一个对象时，会调用对象的hashCode()方法获得哈希码，然后根据这个哈希码进一步计算出对象在集合中的存放位置。
当Object1变量和object2变量实际上引用了同一个对象，那么object1和object2的哈希码肯定相同。
为了保证HashSet能正常工作，要求当两个对象用equals()方法比较的结果为相等时，它们的哈希码也相等。即：
customer1.hashCode() == customer2.hashCode();
如：对应于Customer类的以下重写后的equals()方法：
public boolean equals(Object o){
if(this==o) return true;
if(!o instanceof Customer) return false;
final Customer other = (Customer)o;
if(this.name.equals(other.getName())&&this.age==other.getAge())
return true;
else
return false;
}
为了保证HashSet正常工作，如果Customer类覆盖了equals()方法，也应该覆盖hashCode()方法，并且保证两个相等的Customer对象的哈希码也一样。
public int hashCode(){
int result;
result = (name==null?0:name.hashCode());
result = 29*result+(age==null?0:age.hashCode());
return result;
}
3.TreeSet类
TreeSet类实现了SortedSet接口，能够对集合中的对象进行排序。TreeSet支持两种排序方式：自然排序和客户化排序，在默认情况下TreeSet采用自然排序方式。
a.自然排序
在JDK中，有一部分类实现了Comparable接口，如Integer、Double和String等。Comparable接口有一个compareTo(Object o)方法，它返回整数类型。对于表达式x.compareTo(y)，如果返回值为0，表示x和y相等，如果返回值大于0，表示x大于y，如果返回值小于0，表示x小于y。
TreeSet调用对象的compareTo()方法比较集合中对象的大小，然后进行升序排列，这种排序方式称为自然排序。
以下列出了JDK中实现了Comparable接口的一些类的排序方式
类 排序
BigDecimal\BigInteger\Byte\Double\Float\Integer\Long\Short 按数字大小排序
Character 按字符的Unicode值的数字大小排序
String 按字符串中字符的Unicode值排序
使用自然排序时，只能向TreeSet集合中加入同类型的对象，并且这些对象的类必须实现了Comparable接口，否则会在第二次调用TreeSet的add()方法时，会抛出ClassCastException异常。
例如：
以下是Customer类的compareTo()方法的一种实现方式：
public int compareTo(Object o){
Customer other = (Customer)o;
//先按照name属性排序
if(this.name.compareTo(other.getName())>0) return 1;
if(this.name.compareTo(other.getName())<0) return -1;
//再按照age属性排序
if(this.age>other.getAge()) return 1;
if(this.age
<other.getage()) return -1;
return 0;

}

为了保证TreeSet能正确地排序，要求Customer类的compareTo()方法与equals()方法按相同的规则比较两个Customer对象是否相等。

因此在Customer类的equals()方法中应该采用相同的比较规则：

public boolean equals(Object o){

if(this==o) return true;

if(!(o instanceof Customer)) return false;

final Customer other = (Customer)o;

if(this.name.equals(other.getName())&&this.age==other.getAge()){

return true;

}else{

return false;

}

}

值得注意的是，对于TreeSet中已经存在的Customer对象，如果修改了它们的属性，TreeSet不会对集合进行重新排序。在实际域模型中，实体类的属性可以被更新，因此不适合通过TreeSet来排序。最适合于排序的是不可变类。

b.客户化排序

除了自然排序，TreeSet还支持客户化排序。java.util.Comparator接口用于指定具体的排序方式，它有个compare(Object object1,Object object2)方法，用于比较两个对象的大小。当表达式compare(x,y)的值大于0，表示x大于y；当compare(x,y)的值小于0，表示x小于y；当compare(x,y)的值等于0，表示x等于y。

例如：如果希望TreeSet仅按照Customer对象的name属性进行降序排列，可以创建一个实现Comparator接口的类CustomerComparator：

public class CustomerComparator implements Comparator{

public int compare(Object o1,Object o2){

Customer c1= (Customer)o1;

Customer c2 = (Customer)o2;

if(c1.getName().compareTo(c2.getName())>0) return -1;

if(c2.getName().compareTo(c2.getName())<0) return 1;

return 0;

}

}

接下来在构造TreeSet的实例时，调用它的TreeSet(Comparator comparator)构造方法：

Set set = new TreeSet(new CustomerComparator());

4.向Set中加入持久化类的对象

例如两个Session实例从数据库加载相同的Order对象，然后往HashSet集合里存放，在默认情况下，Order类的equals()方法比较两个Orer对象的内存地址是否相同，因此order1.equals(order2)==false，所以order1和order2游离对象都加入到HashSet集合中，但实际上order1和order2对应的是ORDERS表中的同一条记录。对于这一问题，有两种解决方案：

(1)在应用程序中，谨慎地把来自于不同Session缓存的游离对象加入到Set集合中，如：

Set orders = new HashSet();

orders.add(order1);

if(!order2.getOrderNumber().equals(order1.getOrderNumber()))

order.add(order2);

(2)在Order类中重新实现equals()和hashCode()方法，按照业务主键比较两个Order对象是否相等。

提示：为了保证HashSet正常工作，要求当一个对象加入到HashSet集合中后，它的哈希码不会发生变化。

5.List（列表）

List的主要特征是其对象以线性方式存储，集合中允许存放重复对象。List接口主要的实现类有LinkedList和ArrayList。LinkedList采用链表数据结构，而ArrayList代表大小可变的数组。List接口还有一个实现类Vector，它的功能和ArrayList比较相似，两者的区别在于Vector类的实现采用了同步机制，而ArrayList没有使用同步机制。

List只能对集合中的对象按索引位置排序，如果希望对List中的对象按其他特定方式排序，可以借助Comparator和Collections类。Collections类是集合API中的辅助类，它提供了操纵集合的各种静态方法，其中sort()方法用于对List中的对象进行排序：

a.sort(List list):对List中的对象进行自然排序。

b.sort(List list,Comparator comparator):对List中的对象进行客户化排序，comparator参数指定排序方式。

如Collections.sort(list);

6.Map(映射)

Map(映射)是一种把键对象和值对象进行映射的集合，它的每一个元素都包含一对键对象和值对象，而值对象仍可以是Map类型，依次类推，这样就形成了多级映射。

Map有两种比较常用的实现：HashMap和TreeMap。HashMap按照哈希算法来存取键对象，有很好的存取性能，为了保证HashMap能正常工作，和HashSet一样，要求当两个键对象通过equals()方法比较为true时，这两个对象的hashCode()方法返回的哈希码也一样。

TreeMap实现了SortedMap接口，能对键对象进行排序。和TreeSet一样，TreeMap也支持自然排序和客户化排序两种方式。

例：创建一个缓存类EntityCache，它能粗略地模仿Session的缓存功能，保证缓存中不会出现两个OID相同的Customer对象或两个OID相同的Order对象，这种惟一性是由键对象的惟一性来保证的。

Key.java:

package mypack;

public class Key{

private Class classType;

private Long id;

public Key(Class classType,Long id){

this.classType = classType;

this.id = id;

}

public Class getClassType(){

return this.classType;

}

public Long getId(){

return this.id;

}

public boolean equals(Object o){

if(this==o) return true;

if(!(o instanceof Key)) return false;

final Key other = (Key)o;

if(classType.equals(other.getClassType())&&id.equals(other.getId()))

return true;

return false;

}

public int hashCode(){

int result;

result = classType.hashCode();

result = 29 * result + id.hashCode();

return result;

}

}

EntityCache.java:

package mypack;

import java.util.*;

public class EntityCache {

private Map entitiesByKey;

public EntityCache() {

entitiesByKey=new HashMap();

}

public void put(BusinessObject entity){

Key key=new Key(entity.getClass(),entity.getId());

entitiesByKey.put(key,entity);

}

public Object get(Class classType,Long id){

Key key=new Key(classType,id);

return entitiesByKey.get(key);

}

public Collection getAllEntities(){

return entitiesByKey.values();

}

public boolean contains(Class classType,Long id){

Key key=new Key(classType,id);

return entitiesByKey.containsKey(key);

}

}

java常见的集合、接口、类的区别和联系

集合类似于数组，不过相对数组集合更有优势，不限定集合的长度，可以添加任意多的元素。同时，一个集合可以存入不同的元素，不过通常情况下集合会和数组一样指定单一的元素，方便操作。集合中限定元素成为泛型。
接口和类差不多，不过接口中的方法都属于抽象的方法（也就是只有方法名，参数，没有方法的主题）。接口需要类实现（类似与继承，implement），实现该接口的类必须重写接口中所有的方法（也就是把抽象的方法加上方法主题，便于运用）。
类就比较普通了，经常都会接触到，类通常用于封装多个方法，把有关联的方法集合在一起，便于调用（主函数也属于方法的一种，是写在类里面的）。