在java中，set集合和list集合有什么相同点和不同点？？？

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);
}
}

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。专为解决特殊问题而设计。

在网上看到一点，可能对你有所帮助
Set(集合)：
　　Set是最简单的一种集合。集合中的对象不按特定的方式排序，并且没有重复对象。
　　Set介面主要实现了两个实现类：
　　HashSet : HashSet类按照哈希演算法来存取集合中的对象，存取速度比较快
　　TreeSet : TreeSet类实现了SortedSet介面，能够对集合中的对象进行排序。
　　Set 的用法：
　　存放的是对象的引用，没有重复对象
　　Set set=new HashSet();
　　String s1=new String("hello");
　　String s2=s1;
　　String s3=new String("world");
　　set.add(s1);
　　set.add(s2);
　　set.add(s3);
　　System.out.println(set.size());//列印集合中对象的数目 为 2。
　　Set 的 add()方法是如何判断对象是否已经存放在集合中？
　　boolean isExists=false;
　　Iterator iterator=set.iterator();
　　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指定的索引位置的对象，下标从「0」 开始。
最基本的两种检索集合中的所有对象的方法：　　1: 用for循环和get()方法：
　　for(int i=0; i<LIST.SIZE();I++){< P>
　　System.out.println(list.get(i));
　　}
　　2: 使用 迭代器（Iterator）:
　　Iterator it=list.iterator();
　　while(it.hashNext){
　　System.out.println(it.next);
　　}

个人觉得
叫set数集更好，每个成员元素都是唯一独特不同的，没有重复.....
list是数列，允许成员重复的，当成加强版厚重一点的[]数组用...
这是根本区别..

---

平昌县13464214083： 在java中,set集合和list集合有什么相同点和不同点??? - ？
钭胡紫舒： 在网上看到一点,可能对你有所帮助 Set(集合): Set是最简单的一种集合.集合中的对象不按特定的方式排序,并且没有重复对象. Set介面主要实现了两个实现类: HashSet : HashSet类按照哈希演算法来存取集合中的对象,存取速度...

平昌县13464214083： java中set和list的区别 - ？
钭胡紫舒： set是无序不可重复的集合,里面的数据都是唯一的, 不可以通过位置来操作值,要用迭代来遍历里面的数据 list是有序可重复的集合,和数组很相似, 可以通过索引位置来操作值

平昌县13464214083： java 中 collection 和set ,list - ？
钭胡紫舒： add方法是collection,但是set和list在实现collection接口时都有重写该方法,set和list的add方法不同就是最好的证明.api中有写到“如果 set 中尚未存在指定的元素,则添加此元素(可选操作).更确切地讲,如果此 set 没有包含满足 (e==null...

平昌县13464214083： java中 List 与Set 的区别 - ？
钭胡紫舒： 他们各自有自己的实现类,有无顺序的实现类,也有有顺序的实现类,删除数据.最大的不同就是List是可以重复的.而Set是不能重复的,插入.List适合经常追加数据,插入.但随即取数效率比较低.Set适合经常地随即储存,删除.但是在遍历时效率比较低List和Set都是接口

平昌县13464214083： Java中Set、List、Map集合类(接口)的特点及区别.分别有哪些常用实现类. - ？
钭胡紫舒： list与Set、Map区别及适用场景1、List,Set都是继承自Collection接口,Map则不是2、List特点:元素有放入顺序,元素可重复 ,Set特点:元素无放入顺序,元素不可重复,重复元素会覆盖掉,(注意:元素虽然无放入顺序,但是元素在set中的...

平昌县13464214083： java.util包中 Set 和 List 的区别 - ？
钭胡紫舒： Set(集合) Set是最简单的一种集合.集合中的对象不按特定的方式排序,并且没有重复对象. Set接口主要实现了两个实现类:1. HashSet: HashSet类按照哈希算法来存取集合中的对象,存取速度比较快 2. TreeSet :TreeSet类实现了...

平昌县13464214083： Java中Set 和List两个集合怎样互相转化 - ？
钭胡紫舒： Set和List都是接口,他们的取得都必须是实现了Collection接口和Iterable接口的类.只要是实现了这两个接口的类都就可以实现取得Set接口对象和List接口的目的.我只用过Set,觉得他们用的地方不一样,所以应该是不能转换的.真正要进行转换的话,就应当是用实现了Collection接口和Iterable接口的集合对象去取得这两个接口的对象吧.

平昌县13464214083： Java集合类List/Set/Map的区别和联系 - ？
钭胡紫舒： 常用的集合类有一下几种: List结构的集合类:ArrayList类,LinkedList类,Vector类,Stack类 Map结构的集合类:HashMap类,Hashtable类 Set结构的集合类:HashSet类,TreeSet类 Queue结构的集合:Queue接口 HashMap和Hashtable的区...

平昌县13464214083： java中list和set怎么区别? - ？
钭胡紫舒： List,Map是接口 ArrayList是List的一种实现形式,它是非线程安全的,同时里面的东西是按添加顺序排列,并不会自动给你排序,你添加的为:3,5,4 则 他不会给你排成345.它只按照添加的先后顺序排列. HashMap是Map的一种实现形式,同样也是非线程安全的,它是无序的了,你后加入的东西可能经过计算哈希值后排在前面,他主要是靠key和value的形式来进行索取.

平昌县13464214083： java中集合类List和Set集合中的一些方法的具体如何使用和具体分析: - ？
钭胡紫舒： 构造方法摘要 ArrayList()构造一个初始容量为 10 的空列表. ArrayList(Collection c)构造一个包含指定 collection 的元素的列表,这些元素是按照该 collection 的迭代器返回它们的顺序排列的. ArrayList(int initialCapacity)构造一个具有指定...