java中的集合及接口和类的区别

Java API中所用的集合类，都是实现了Collection接口，他的一个类继承结构如下：

  Collection<--List<--Vector

                  Collection<--List<--ArrayList
                  Collection<--List<--LinkedList
                  Collection<--Set<--HashSet
                  Collection<--Set<--HashSet<--LinkedHashSet
                  Collection<--Set<--SortedSet<--TreeSet

Collection和Map是两个毫无关系的接口，Collection是对象集合，Map是键值对集合；

Collection 和 Collections的区别?

Collection是集合类的上级接口，继承与他的接口主要有Set和List.

Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。

List、set和Map的区别?

List和map都是collection的接口

List:有顺序的，元素可以重复；

Set：无顺序的，元素不可重复（值不相同）；

Map：元素是键值对：key唯一不可重复，value可重复.

List:有顺序的，元素可以重复；

    遍历：for，迭代；

    排序：Comparable Comparator Collections.sort()
  ArrayList：

    底层用数组实现的List；
    特点：查询效率高，增删效率低 轻量级 线程不安全；
  LinkedList：

    底层用双向循环链表实现的List；
    特点：查询效率低，增删效率高；

  Vector:

    底层用数组实现List接口的另一个类；
    特点：重量级，占据更多的系统开销，线程安全；

 

ArrayList、LinkedList和Vector区别？

ArrayList:都可以实现List接口，类似于数组，用来保存数据，保存的数据是连续的，查询速度快；

LinkedList：以链表的形式保存数据，删除修改速度快 保存数据不连续

Vector:类似于ArrayList  区别  Vector的线程比ArrayList  安全高

Set：无顺序的，元素不可重复（值不相同）；

    遍历：迭代；
    排序：SortedSet
  HashSet：

    采用哈希算法来实现Set接口；
    唯一性保证：重复对象equals方法返回为true；
    重复对象hashCode方法返回相同的整数，不同对象hashCode尽量保证不同（提高效率）；

  SortedSet：

    对一个Set排序；
  TreeSet：

    在元素添加的同时，进行排序。也要给出排序规则；
    唯一性保证：根据排序规则，compareTo方法返回为0，就可以认定两个对象中有一个是重复对象。

 

Map：元素是键值对：key唯一不可重复，value可重复；

    遍历：先迭代遍历key的集合，再根据key得到value；

   HashMap: 轻量级，线程不安全，允许key或者value是null；

   SortedMap：元素自动对key排序

   Hashtable：重量级，线程安全，不允许key或者value是null；Properties：Hashtable的子类，key和value都是String

   TreeMap：集合是指一个对象可以容纳了多个对象（不是引用），这个集合对象主要用来管理维护一系列相似的对象。

 Hashtable和HashMap的区别?

两者都可以完成了Map接口；  HashMap: 元素成对，元素可为空

HashTable: 元素成对，线程安全，元素不可为空

Hashtable：元素成对，元素不可为空，线程安全。

HashMap：元素成对，元素可为空，因非安全，在只有一个线程访问的情况下，效率要高于Hashtable。

集合接口类层次:
位于package java.util.*;
Collection
↑
Set   List   Map
↑           ↑
SortedSet SortedMap

1) Set: 集合类中不允许有重复对象;
2) SortedSet: 和Set接口同，但元素按升序排列;
3) List: 元素加载和移出时按照顺序，可以保存重复对象。
4) Map: (key-value对)存储了唯一关键字辨识和对应的值。
5) SortedMap: 和Map类同，但对象按他们关键字的升序排列。

 

集合类层次:（注：JAVA1.5对JAVA1.4的最大改进就是增加了对范型的支持）

                                           Collection 
                                               ↑ 
                    |ˉˉˉˉˉˉˉˉˉˉˉˉˉ|ˉˉˉˉˉˉˉˉˉˉˉˉˉ| 
                  (List)                      (Set)                     (Map) 
             |ˉˉˉ|ˉˉˉ|                  |ˉˉˉ|                |ˉˉˉ|

 ArrayList   LinkedList  Vector           HashSet  TreeSet      TreeMap   Hashtable Hashmap 
                                                                                    

Collection接口的方法：
    add(Object o)
    addAll(Collection c)
    contains(Object o)
    containsAll(Collection c)
    remove(Object o)
    removeAll(Collection c)
    clear()
    equals(Object o)
    isEmpty()
    iterator()
    size()
    toArray()
    toArray(Object[] o)

五个最常用的集合类之间的区别和联系:
    1．ArrayList: 元素单个，效率高，多用于查询
    2．Vector: 元素单个，线程安全，多用于查询
    3．LinkedList:元素单个，多用于插入和删除
    4．HashMap: 元素成对，元素可为空
    5．HashTable: 元素成对，线程安全，元素不可为空

 

ArrayList：
    底层是Object数组，所以ArrayList具有数组的查询速度快的优点以及增删速度慢的缺点。
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()，从而影响程序执行的效率。我们要保证相同对象的返回的hashCode一定相同，也要保证不相同的对象的hashCode尽可能不同（因为数组的边界性，hashCode还是可能相同的）。

例子：
public int hashCode(){
return name.hashcode()+age;
}
这个例子保证了相同姓名和年龄的记录返回的hashCode是相同的。

 

使用hashSet的优点：
    hashSet的底层是数组，其查询效率非常高。而且在增加和删除的时候由于运用的hashCode的比较来确定添加元素的位置，所以不存在元素的偏移，所以效率也非常高。因为hashSet查询和删除和增加元素的效率都非常高。但是hashSet增删高效率是通过花费大量的空间换来的：因为空间越大，取余数相同的情况就越小。HashSet这种算法会建立许多无用的空间。使用hashSet类时要注意，如果发生冲突，就会出现遍历整个数组的情况，这样就使得效率非常的低。

 

比较
Collections类（工具类―――全是static 方法）
    Public static int binarySearch(List list,Object key)
    Public static void Sort(List list,Comparator com)
    Public static void sort(List list)
方法一：
Comparator接口
    Int compare(Object a,Object b)
    Boolean equals(Object o)
例子：
import java.util.*;
public class Test {
    public static void main(String[] arg) {
        ArrayList al = new ArrayList();
        Person p1 = new Person("dudi");
        Person p2 = new Person("cony");
        Person p3 = new Person("aihao");
        al.add(p1);
        al.add(p2);
        al.add(p3);
        Collections.sort(al,p1);
        for(Iterator it = al.iterator();it.hasNext();){
            Person p = (Person)it.next();
            System.out.println(p.name);
        }
    }
}
class Person implements java.util.Comparator
{
      public String name;
      public Person(String name){
        this.name = name;
      }
      public int compare(Object a,Object b){
        if(a instanceof Person && b instanceof Person){
        Person pa = (Person)a;
        Person pb = (Person)b;
        return pa.name.compareTo(pb.name);
      }
    return 0;
    }
    public boolean equals(Object a){return true;}
}
方法二
Java.lang.Comparable
        Public int compareTo(Object o)

Class Person implements java.lang.Comparable{
        Public int compareTo(Object o){
            Comparable c1=(Comparable)this;
            Comparable c2=(Comparable)o;
            Return c1.name.compareTo(c2.name );
        }
}

Collection和Map是两个毫无关系的接口，Collection是对象集合，Map是键值对集合；
Collection有两个子接口List和Set，List可以通过下标(1,2..)来取得值，值可以重复；而Set只能通过游标来取值，并且值是不能重复的；
  ArrayList，Vector，LinkedList是List的实现类  
  ArrayList是线程不安全的，Vector是线程安全的，这两个类底层都是由数组实现的  
  LinkedList是线程不安全的，底层是由链表实现的  

  HashTable和HashMap是Map的实现类  
  HashTable是线程安全的，不能存储null值  
  HashMap不是线程安全的，可以存储null值 

 

    实现Collection接口的类,如果底层是用数组实现,那么添加新元素花费的时间会比较多,因为他要保证这个数组的容量足够大,所以在每添加一个新元素的时候都要自动扩大数组容量....

    如果实现Collection接口的类底层是用链表实现,那么他查找一个元素所花费的时间会比较长,因为他不能通过下标来查找,只能一个个的遍历....

    所以在add()操作比较多的时候用LinkedList性能比较好，在search()操作比较多的时候用ArrayList和Vector比较好。