Java中的集合介绍

一、基本介绍

1、结构图

2、添加对象

向集合中添加的员工对象：Clerk

//建立一个员工类
public class Clerk {
    private String name;//姓名
    private int age;//年龄
    private float sal;//工资

    public Clerk(String name,int age,float sal)
    {
        this.name=name;
        this.age=age;
        this.sal=sal;
    }

    //及get、set
}   

二、List结构的集合

说明：有序，可重复

1、ArrayList类

ArrList实现类：ArrayListDemo

import java.util.ArrayList;
​
public class ArrayListDemo {
​
    public static void main(String[] args) {
        // 定义ArrayList对象
        ArrayList al = new ArrayList();
        // 显示大小
        System.out.println("al大小:" + al.size());
​
        test1(al);//向al中添加数据
        test2(al);//遍历al中的数据
        //test3(al);//删除al中的数据
​
    }
​
    private static void test3(ArrayList al) {
        // 如何从al中删除一个对象
        al.remove(1);
        System.out.println("===删除吴用===");
    }
​
    private static void test2(ArrayList al) {
        // 如何访问al中的对象(数据)
        // 访问第一个对象
        // Clerk temp=(Clerk)al.get(0);
​
        // System.out.println("第一个人的名字是："+temp.getName());
​
        // 遍历al所有的对象(数据)
        for (int i = 0; i < al.size(); i++) {
            Clerk temp = (Clerk) al.get(i);
            System.out.println("名字：" + temp.getName());
        }
    }
​
    private static void test1(ArrayList al) {//向al中添加数据
        // 向all中加入数据(类型是Object)
        // 创建一个职员
        Clerk clerk1 = new Clerk("宋江", 50, 1000);
        Clerk clerk2 = new Clerk("吴用", 45, 1200);
        Clerk clerk3 = new Clerk("林冲", 35, 1300);
        // 将clerk1加入到al中
        al.add(clerk1);
        al.add(clerk2);
        al.add(clerk3);
        // 可不可以放入同样的对象？
        al.add(clerk1);//可以
        // 显示大小
        System.out.println("al大小:" + al.size());//按顺序输出
    }
​
}

注意：ArrayList无同步性，线程不安全，可以重复添加，按顺序

2、LinkedList类

public class LinkedListDemo {
    static Clerk clerk1=new Clerk("sa01",33,1.2f);
    static Clerk clerk2=new Clerk("sa02",44,1.2f);
    static Clerk clerk3=new Clerk("sa03",66,1.2f);
​
    public static void main(String[] args) {

        // 定义LinkedList对象
        LinkedList ll=new LinkedList();
        // 显示大小
        System.out.println("ll大小:" + ll.size());
​
        test1(ll);//向ll中添加数据
        test2(ll);//删除ll中的数据
​
    }
    //删除ll中的数据
    private static void test2(LinkedList ll) {
        //remove表示将某一条数据进行删除
        ll.remove(clerk1);//将ll中的clerk1数据删除
        System.out.println("测试LinkedList集合类中的remove方法");
        for(int i=0;i<ll.size();i++){
            System.out.println(((Clerk)ll.get(i)).getName());
        }

        ll.removeAll(ll);//清除整个链表
        System.out.println("测试LinkedList集合类中的remmoveall方法");
        for(int i=0;i<ll.size();i++){
            System.out.println(((Clerk)ll.get(i)).getName());//表示的是clerk.get方法
        }
    }
    //向ll中添加数据
    private static void test1(LinkedList ll) {

        //addFirst表示把clerk1加载(链表)队列的最前面
        ll.addFirst(clerk1);//addFirst方法是可以插入在数组之前，添加后：01
        ll.addFirst(clerk2);//也可以理解为addFirst方法是后进先出的方法，02，01

        //addLast表示把clerk3加载(链表)队列的后面
        ll.addLast(clerk3);//02，01，03

        System.out.println("测试LinkedList集合类中的addFist及addLast方法");
        for(int i=0;i<ll.size();i++){//输出：02，01，03
            System.out.println(((Clerk)ll.get(i)).getName());
        }
    }
​
}

注意：采用链表形式，从队列前面出

3、Vector类

public class VectorDemo {
​
    public static void main(String[] args) {
        //Vector的用法
        Vector vv=new Vector();

        text1(vv);//向vv中添加数据
        text2(vv);//遍历vv中的数据
​
    }
​
    private static void text2(Vector vv) {
        //遍历
        for(int i=0;i<vv.size();i++){
            Clerk clerk=(Clerk)vv.get(i);
            System.out.println(clerk.getName());
        }
    }
​
    private static void text1(Vector vv) {
        Clerk clerk1=new Clerk("1",23,1.2f);
        Clerk clerk2=new Clerk("2",55,1.2f);
        Clerk clerk3=new Clerk("3",34,1.2f);
        vv.add(clerk1);
        vv.add(clerk2);
        vv.add(clerk3);
        vv.add(clerk1);
    }
​
}

注意：线程安全具有同步性

4、Stack类

//Stack集合类(栈)的使用方法
public class StackDemo {
​
    public static void main(String[] args) {
        // TODO Auto-generated method stub
​
        // Stack的用法
        Stack stack = new Stack();
        Clerk clerk1 = new Clerk("s1", 21, 1.2f);
        Clerk clerk2 = new Clerk("s2", 23, 1.2f);
        stack.add(clerk1);
        stack.add(clerk2);
        stack.add(clerk2);
        for (int i = 0; i < stack.size(); i++) {
            System.out.println(((Clerk) stack.get(i)).getName());
        }
    }
}

三、Map结构的集合

1、HashMap类

public class HashMapDemo {
​
    public static void main(String[] args) {
        //创建HashMap对象
        HashMap hm=new HashMap();

        test1(hm);//向hm中添加数据
        test2(hm);//查找hm中的数据
​
    }
​
    private static void test2(HashMap hm) {
        //如果你要查找编号是s002
        if(hm.containsKey("s002")){//取键值containsKey
            System.out.println("有该员工");
            //如何取出，键<key>值
            Clerk clerk=(Clerk)hm.get("s002");
            System.out.println("名字"+clerk.getName());
        }else{
            System.out.println("没该员工");
        }

        //遍历HashMap中所有的key和value值
        //Iterator迭代
        Iterator it=hm.keySet().iterator();
        //hasNext返回一个boolean值
        while(it.hasNext()){
            //如果有下一个取出key值
            String key=it.next().toString();
            //通过key取出value
            Clerk clerk=(Clerk)hm.get(key);
            System.out.println("名字："+clerk.getName());
            System.out.println("工资："+clerk.getSal());
        }
    }
​
    private static void test1(HashMap hm) {
        Clerk clerk1=new Clerk("s001",21,3.4f);
        Clerk clerk2=new Clerk("s002",22,5.6f);
        Clerk clerk3=new Clerk("s003",23,1.2f);
        //将Clerk放入到hm中
        //hm.put(null,null);//可以放空值
        hm.put("s001", clerk1);
        hm.put("s002", clerk2);
        hm.put("s002", clerk3);//不允许key重复,所以Clerk3会覆盖Clerk2
    }
}

注意：因为使用哈希算法，所以取出所有值时并不是按顺序的

2、Hashtable类

public class HashtableDemo {
    public static void main(String []args){
        Hashtable ht=new Hashtable();//Hashtable与HsahMap在用法上一致

        test1(ht);//添加
        test2(ht);//遍历
    }
​
    private static void test2(Hashtable ht) {
        for(Iterator it=ht.keySet().iterator();it.hasNext();){
            String key=it.next().toString();
            Clerk clerk=(Clerk)ht.get(key);
            System.out.println("名字："+clerk.getName()+"\t工资："+clerk.getSal());
        }
    }
​
    private static void test1(Hashtable ht) {
        Clerk clerk4=new Clerk("s101",22,2.2f);
        Clerk clerk5=new Clerk("s102",32,1.2f);
        Clerk clerk6=new Clerk("s103",32,4.2f);
        ht.put("s101", clerk4);
        ht.put("s102", clerk5);
        ht.put("s103", clerk6);
    }
}

注意：Hashtable具有同步性，线程安全

3、HashMap和Hashtable的区别

• 历史原因：Hashtable是基于陈旧的Dictionary类的，HashMap是java 1.2引进的Map接口的一个实现。
• 同步性：Hashtable是线程同步的。这个类中的一些方法保证了Hashtable中的对象是线程安全的。而HashMap则是线程异步的，因此HashMap中的对象并不是线程安全的。因为同步的要求会影响执行的效率，所以如果你不需要线程安全的集合那么使用HashMap是一个很好的选择，这样可以避免由于同步带来的不必要的性能开销，从而提高效率。
• 值：HashMap可以让你将空值作为一个表的条目的key或value但是Hashtable是不能放入空值的(null)

四、Set结构的集合类

1、HashSet类

      HashSet是基于HashMap实现的，HashSet底层采用HashMap来保存所有元素。

public class HashSetDemo {
    public static void main(String []args){
        HashSet<Clerk> hs=new HashSet<Clerk>();

        test1(hs);//向hs中添加数据
​
        test2(hs);//遍历
    }
​
    private static void test2(HashSet<Clerk> hs) {
        //转换数组o[]，遍历并输出HashSet中的无素
        Object o[]=hs.toArray();
        for(int i=0;i<o.length;i++){
            System.out.println("姓名:"+((Clerk)o[i]).getName()+"\t年龄:"+((Clerk)o[i]).getAge()+"\t工资:"+((Clerk)o[i]).getSal());
        }
    }
​
    private static void test1(HashSet<Clerk> hs) {
        Clerk clerk1=new Clerk("s001",21,1.2f);
        Clerk clerk2=new Clerk("s002",22,1.6f);
        Clerk clerk3=new Clerk("s003",23,1.8f);
        Clerk clerk4=new Clerk("s001",24,1.2f);
        hs.add(clerk1);
        hs.add(clerk2);
        hs.add(clerk3);
        hs.add(clerk4);
        hs.add(clerk1);//重复的clerk1,HashSet会自动去除
        System.out.println("HashSet_size="+hs.size());
        System.out.println();
        ArrayList<Clerk> al=new ArrayList<Clerk>();
        Clerk clerk5=new Clerk("s004",33,1.0f);
        Clerk clerk6=new Clerk("s005",14,2.5f);
        al.add(clerk5);
        al.add(clerk6);
        //al.add(clerk1);
        hs.addAll(al);//将al中的值加到hs中，并去除重复的clerk1
        System.out.println("HashSet_ArrayList_size="+hs.size());
        System.out.println();
    }
}

2、TreeSet类

     TreeSet集合类是一个有序集合，它的元素按照升序排序，默认是自然顺序排列，也就是说TreeSet中的对象元素需要实现Comparable接口。TreeSet与HashSet类一样没有get()方法来获取列表中的元素，所以也只能通过迭代器方法来获取。 TreeSet是依靠TreeMap来实现的，TreeSet是一个有序集合，它的元素按照升序排列，默认是按照自然顺序排列，也就是说TreeSet中的对象元素需要实现Comparable接口

注意：由于TreeMap需要排序，所以需要一个Comparator为键值进行大小比较，当然也是用Comparator定位的Comparator可以在创建TreeMap时指定，这时排序时使用Comparator.compare。如果创建时没有指定Comparator那么就会使用key.compareTo()方法，这就要求key必须实现Comparable接口。TreeMap是使用Tree数据结构实现的，所以使用compare接口就可以完成定位了。其要操作的对象类如下：

//创建Strudent学生类并实现Comparable与Comparator接口
class Student implements Comparable,Comparator{
    private int num;//定义学号
    private String name;//定义名字
    public Student(int num,String name){
        this.num=num;
        this.name=name;
    }
    public int compareTo(Object o){
        Student st=(Student)o;
        int result;
        result=num>st.num?1:(num==st.num?0:-1);//判断学号是否相同并返回result的值
        //如果学号相等，就按姓名排列
    /*  if(result==0){
            return name.compareTo(st.name);
        }*/
        return result;
    }
    //实现Comparator接口并实现它的抽象方法
    public int compare(Object o1,Object o2){
        Student st1 =(Student)o1;
        Student st2 =(Student)o2;
        return st1.name.compareTo(st2.name);//比较姓名是否相同
    }
    //重写toString()方法，因为如果不重写，打印出来的是16进制代码
    public String toString(){
        return "num="+num+"; name="+name;
    }
    public static class StudentComparator implements Comparator{//定义一个静态StudentComparator类并实现Comparator接口
        public int compare(Object o1,Object o2){
            Student st1 =(Student)o1;
            Student st2 =(Student)o2;
            int result;
            result=st1.num>st2.num?1:(st1.num==st2.num?0:-1);//判断学号是否相同进行排序
            if(result==0){//如果学号相等 就进行名字排序
                result=st1.name.compareTo(st2.name);
            }
            return result;
        }
    }
}

那么TreeSet类的使用如下：

public class TreeSetDemo{
    public static void main(String[] args){
        //传递一个比较器来实现你自己的排序方式
        TreeSet tr =new TreeSet(new Student.StudentComparator());
        tr.add(new Student(301,"张三"));//将学生数据写入TreeSet集合类的tr中
        tr.add(new Student(201,"李二"));
        tr.add(new Student(101,"王五"));
        tr.add(new Student(101,"穷一"));
        Iterator it=tr.iterator();//迭代器，遍历
        while(it.hasNext()){//判断是否有下一个元素
            System.out.println(it.next());
        }
    }
}

五、三大集合结构的比较

1、总体    

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

2、具体

1.List的功能方法

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

• List：次序是List最重要的特点：它保证维护元素特定的顺序。List为Collection添加了许多方法，使得能够向List中间插入与移除元素(这只推荐LinkedList使用)一个List可以生成Listlterator，使用它可以从两个方向遍历List，也可以从List中间插入和移除元素。
• ArrayList：由数组实现的List。允许对元素进行快速随机访问，但是向List中间插入与移除元素的速率很慢。Listlterator只应该用来由后向前遍历ArrayList。而不是用来插入和移除元素。因为那比LinkedList开销要大很多。
• LinkedList：对顺序访问进行了优化，向List中间插入与删除的开销并不大。随机访问则相对较慢。(使用ArrayList代替)还具有下列方法：addFirst()，addLast()，getFirst()，getLast()，removeFirst()和removeLast()这些方法(没有在任何接口或基类中定义过)使得LinkedList可以当作堆栈、队列和双向队列使用。

2.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时，结果会按元素插入的次序显示。

3.Map的功能方法

     方法put(Object key,Object value)添加一个"值"(想要得东西)和与"值"相关的"键"(key)(使用它来查找)。方法get(Object key)返回与给定"键"相关联的"值"。可以用containsKey()和containsValue()测试Map中是否包含某个"键"或"值"。标准的java类库中包含了几种不同的Map：HashMap，TreeMap，LinkedHashMap，WeakHashMap，ldentityHashMap。它们都有同样的基本接口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，它可以返回一个子树。
• WeakHashMap:旨键(weak key)Map，Map中使用的对象也被允许释放：这是为解决特殊问题设计的。如果没有map之外的引用指向某个"键"，则此"键"可以被垃圾收集器回收。
• ldentifyHashMap：使用==代替equals()对"键"作比较的hash map。专为解决特殊问题而设计。

六、其他杂项

1、增删方法详解

     java.util包中包含了一系列重要的集合类，集合类的根接口Collection。Collection接口是所有集合类的根类型。它的一个主要的接口方法是：

boolean add(Object c)//添加数据

     add()方法将添加一个新元素。注意这个方法会返回一个boolean，但是返回值不是表示添加成功与否。Collection规定：如果一个集合拒绝添加这个元素，无论任何原因，都必须抛出异常。这个返回值表示的意义是add()方法执行后，集合的内容是否改变了(就是元素有无数量，位置等变化)，这是由具体类实现的。即：如果方法出错，总会抛出异常；返回值仅仅表示该方法执行后这个Collection的内容有无变化。类似还有：

boolean addall(Collection c);//添加所有数据
boolean remove(Object o);//删除数据
boolean removeall(Collection c);//删除所有数据
boolean remainall(Collection c);//保持所有数据

     Object[]toArray()方法很简单，把集合转换成数组返回。Object[]toArray(Object[] a)方法就有点复杂了，首先，返回的Object[]仍然是把集合的所有元素变成数组，但是类型和参数a的类型是相同的。如：

String[] o=(String)c.toArray(new String[0]);//得到的o实际类型是String[]数组

     其次，如果参数a的大小装不下集合的所有元素，返回的将是一个新的数组。如果参数a的大小能装下集合的所有元素，则返回的还是a，但a的内容用集合的元素来填充。尤其要注意的是，如果a的大小比集合元素的个数还多，a后面的部分全部被置为null(空)。

 2、迭代器的使用

     Iterator模式 是用于遍历集合类的标准访问方法。它可以把访问逻辑从不同类型的集合类中抽象出来，从而避免向客户端暴露集合的内部结构。例如，如果没有使用Iterator，遍历一个数组的方法是使用索引：

for(int i=0;i<array.size();i++)
{..get(i)...}

而访问一个链表(LinkedList)又必须使用while循环：

while((e=e.next())!=null)
{...e.data()...}

     以上两种方法客户端都必须事先知道集合的内部结构，访问代码和集合本身是紧耦合，无法将访问逻辑从集合类和客户端代码中分离出来，每一种集合对应一种遍历方法，客户端代码无法复用。更恐怖的是，如果以后需要把ArrayList更换为LinkedList，则原来的客户端代码必须全部重写。 为解决以上问题，Iterator模式总是用同一种逻辑来遍历集合：

for(Iterator it=c.iterater();it.hasNext();){ ...}

    奥秘在于客户端自身不维护遍历集合的"指针"，所有的内部状态（如当前元素位置，是否有下一个元素）都由Iterator来维护，而这个Iterator由集合类通过工厂方法生成，因此，它知道如何遍历整个集合。客户端从不直接和集合类打交道，它总是控制Iterator，向它发送"向前"，"向后"，"取当前元素"的命令，就可以间接遍历整个集合。首先看看java.util.Iterator接口的定义：

public interface Iterator {
　 boolean hasNext();
　 Object next();
　 void remove();
}

     依赖前两个方法就能完成遍历，典型的代码如下：

for(Iterator it=c.iterator();it.hasNext();){
　 Object o=it.next();
　 // 对o的操作...
}

     每一种集合类返回的Iterator具体类型可能不同，Array可能返回ArrayIterator，Set可能返回SetIterator，Tree 可能返回TreeIterator，但是它们都实现了Iterator接口，因此，客户端不关心到底是哪种Iterator，它只需要获得这个 Iterator接口即可，这就是面向对象的威力。

    要确保遍历过程顺利完成，必须保证遍历过程中不更改集合的内容（Iterator的remove()方法除外），因此，确保遍历可靠的原则是只在一个线程中使用这个集合，或者在多线程中对遍历代码进行同步。

Iterator示例:

    Collection c=new ArrayList();
    c.add("abc");
    c.add("xyz");
    for(Iterator it:c){
        String s=(String)it.next();
        System.out.println(s);
    }

    如果你把第一行代码的ArrayList换成LinkedList或Vector，剩下的代码不用改动一行就能编译，而且功能不变，这就是针对抽象编程的原则：对具体类的依赖性最小。

3、队列（Queue）的介绍

    Queue接口与List、Set同一级别，都是继承了Collection接口。LinkedList实现了Queue接口。Queue接口窄化了对LinkedList的方法的访问权限（即在方法中的参数类型如果是Queue时，就完全只能访问Queue接口所定义的方法了，而不能直接访问 LinkedList的非Queue的方法），以使得只有恰当的方法才可以使用。BlockingQueue继承了Queue接口。

    队列是一种数据结构。它有两个基本操作：在队列尾部加人一个元素，和从队列头部移除一个元素。就是说，队列以一种先进先出的方式管理数据，如果你试图向一个已经满了的阻塞队列中添加一个元素或者是从一个空的阻塞队列中移除一个元索，将导致线程阻塞。

    在多线程进行合作时，阻塞队列是很有用的工具。工作者线程可以定期地把中间结果存到阻塞队列中而其他工作者线线程把中间结果取出并在将来修改它们。队列会自动平衡负载。如果第一个线程集运行得比第二个慢，则第二个线程集在等待结果时就会阻塞。如果第一个线程集运行得快，那么它将等待第二个线程集赶上来。

    阻塞队列的操作可以根据它们的响应方式分为以下三类：add、remove和element操作在你试图为一个已满的队列增加元素或从空队列取得元素时 抛出异常。当然，在多线程程序中，队列在任何时间都可能变成满的或空的，所以你可能想使用offer、poll、peek方法。这些方法在无法完成任务时 只是给出一个出错示而不会抛出异常。

注意：poll和peek方法出错进返回null。因此，向队列中插入null值是不合法的。

其中队列的方法有：

add	增加一个元素	如果队列已满，则抛出一个IIIegaISlabEepeplian异常
remove	移除并返回队列头部的元素	如果队列为空，则抛出一个NoSuchElementException异常
element	返回队列头部的元素	如果队列为空，则抛出一个NoSuchElementException异常
offer	添加一个元素并返回true	如果队列已满，则返回false
poll	移除并返问队列头部的元素	如果队列为空，则返回null
peek	返回队列头部的元素	如果队列为空，则返回null
put	添加一个元素	如果队列满，则阻塞
take	移除并返回队列头部的元素	如果队列为空，则阻塞

注意：remove、element、offer 、poll、peek 其实是属于Queue接口。 这些方法的区别有：

• offer，add区别：一些队列有大小限制，因此如果想在一个满的队列中加入一个新项，多出的项就会被拒绝。这时新的 offer 方法就可以起作用了。它不是对调用 add() 方法抛出一个 unchecked 异常，而只是得到由 offer() 返回的 false。

• poll，remove区别：remove()和poll()方法都是从队列中删除第一个元素（head）。remove()的行为与Collection 接口的版本相似，但是新的 poll()方法在用空集合调用时不是抛出异常，只是返回null。因此新的方法更适合容易出现异常条件的情况。

• peek，element区别：element()和peek()用于在队列的头部查询元素。与 remove()方法类似，在队列为空时，element()抛出一个异常，而peek()返回null。

     五个队列所提供的各有不同：

•  ArrayBlockingQueue ：一个由数组支持的有界队列。基于数组的阻塞循环队列，先进先出原则对元素进行排序。
•  LinkedBlockingQueue：一个由链接节点支持的可选有界队列。基于链表的队列，先进先出排序元素。
•  PriorityBlockingQueue：一个由优先级堆支持的无界优先级队列。PriorityBlockingQueue是对PriorityQueue的再次包装，是基于堆数据结构的，而PriorityQueue是没有容量限制的，与ArrayList一样，所以在优先阻塞队列上put时是不会受阻的。但是由于资源被耗尽，所以试图执行添加操作可能会导致OutOfMemoryError），但是如果队列为空，那么取元素的操作take就会阻塞，所以它的检索操作take是受阻的。另外，往入该队列中的元素要具有比较能力。
•  DelayQueue：一个由优先级堆支持的、基于时间的调度队列。（基于PriorityQueue来实现的）是一个存放Delayed 元素的无界阻塞队列，只有在延迟期满时才能从中提取元素。该队列的头部是延迟期满后保存时间最长的 Delayed 元素。如果延迟都还没有期满，则队列没有头部，并且poll将返回null。当一个元素的 getDelay(TimeUnit.NANOSECONDS) 方法返回一个小于或等于零的值时，则出现期满，poll就以移除这个元素了。此队列不允许使用null元素。
• SynchronousQueue：一个利用 BlockingQueue接口的简单聚集（rendezvous）机制。SynchronousQueue 类是最简单的。它没有内部容量。它就像线程之间的手递手机制。在队列中加入一个元素的生产者会等待另一个线程的消费者。当这个消费者出现时，这个元素就直接在消费者和生产者之间传递，永远不会加入到阻塞队列中。

注意：Queue队列是不能直接实例化的。在java编程中，Queue的实现都是用LinkedList。如：

Queue qe=new LinkedList();

注意：此实现不是同步的。如果多个线程同时访问一个链接列表，而其中至少一个线程结构上修改了该列表，则它必须保质外部同步。(结构修改指添加或删除一个或多个元素的任何操作；仅设置元素的值不是结构修改。)这一般通过对自然封装该列表的对象进行同步操作来完成。