Collection(List)

一、集合类

集合类的由来：
        对象用于封装特有数据，对象多了需要存储；如果对象的个数不确定，就使用集合容器进行存储。

集合特点：
        1. 用于存储对象的容器。
        2. 集合的长度是可变的。
        3. 集合中不可以存储基本数据类型值。
            集合容器因为内部的数据结构不同，有多种具体容器。不断的向上抽取，就形成了集合框架。

与数组的区别
         数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。
         数组中可以存储基本数据类型，集合只能存储对象。

集合框架的构成及分类

二、Collection接口

          |--List：元素是有序的，元素可以重复，因为该集合体系有索引。
` |--ArrayList：底层的数据结构使用的是数组结构。特点：查询速度很快，但是增删稍慢，线程不同步。
                     |--LinkeList：底层使用的链表数据结构。特点：增删湿度很快，查询稍慢。 
                     |--Vector：底层是数组数据结构。编程同步。被ArrayList替代了。

           |--set：元素是无序的，不可以重复。
                     |--HashSet：底层数据结构是哈希表。
                     |--TreeSet ：底层是二叉树结构，可以对set集合中的元素进行排序，线程不同步；

HashSet是如何保证元素唯一性的呢？
         如果元素的HashCode值不同，才会判断equals是否为true。
         如果元素的hashCode值相同，不会调用equals。
         注意，对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashCode和equals方法。

1、添加：

      boolean add(Object obj);
      boolean addAll(Collection coll);
2、删除：
      boolean remove(Object obj);
      boolean removeAll(Collection coll);
      void clear();
3、判断：
      boolean contains(Object obj);
      boolean containsAll(Collection coll);
      boolean isEmpty();判断集合中是否有元素。
4、获取：
      int size();
      Iterator iterator();

Iterator迭代器

       迭代器是取出集合中元素的一种方式，因为Collection中有iterator方法，所以每个子类集合对象都具备迭代器；

获取迭代器的方式： 

         Collection对象可以通过调用自身的iterator方法，返回一个迭代器，例： 
         Collection< Object o> al=new ArrayList< Object o>(); 
         Iterator it=al.iterator();

 

迭代器的常用方法：

      返回值类型

      方法

        功能描述

       boolean

  hasNext()

   如果仍有元素可以迭代返回true；

        E

  next()

   返回迭代器的下一个元素；

        void

  remove()

   从迭代器指向的集合中移除迭代器返回的最后一个元素；

示例：

import java.util.*;public class CollectionDemo{   public static void main(String[] args){  Collection coll = new ArrayList();show(coll);System.out.println( "---------------------------------" );  Collection c1 = new ArrayList();  Collection c2 = new ArrayList();show(c1,c2);  }   public static void show(Collection coll){  //1、添加元素，add  coll.add( "abc1");  coll.add( "abc2");  coll.add( "abc3");System.out.println( "coll:" + coll);  //2、删除元素，remove  coll.remove( "abc2");//会改变集合的长度System.out.println( "coll:" + coll);  //清空集合  //coll.clear();System.out.println(coll.contains( "abc1"));  }  public static void show(Collection c1,Collection c2){  //给c1添加元素  c1.add( "abc1");  c1.add( "abc2");  c1.add( "abc3");  c1.add( "abc4");  //给c2添加元素  c2.add( "abc2");  c2.add( "abc6");  c2.add( "abc7"); System.out.println( "c1:" + c1); System.out.println( "c2:" + c2);  //演示addAll  //将c2中的元素添加到c1中  c1.addAll(c2);  //演示removeAll  //从c1集合中删除与c2集合相同的元素  boolean b = c1.removeAll(c2);System.out.println( "removeAll:" + b);  //演示containsAll  boolean b1 = c1.containsAll(c2);System.out.println( "containsAll:" + b1);  //演示retainAll  //取交集，保留和指定的集合相同的元素  boolean b2 = c1.retainAll(c2);System.out.println( "c1、c2交集:" + c1);  }}

List：特有的常见方法。

           凡是可以操作角标的方法都是该体系特有的方法。

增
      add(index,element);
      addAll(index,Collection);
删
      remove(index);
改
      set(index,element);
查
      get(index);
      subList(from,to);
      listIterator();

List集合特有的迭代器。ListIterator是Iterator的子接口。

在迭代时，不可以通过集合对象的方法操作集合中的元素，因为会发生ConcurrentModificationException异常。

所以，在迭代时，只能用迭代器的方法操作元素，可是Iterator方法是有限的，只能对元素进行判断，取出，删除的操作，如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator。

该接口只能通过List集合的ListIterator方法获取。

什么是迭代器呢？

其实就是集合的取出元素的方式。

示例：

import java.util.ArrayList;import java.util.Iterator;import java.util.List;import java.util.ListIterator;public class ListDemo{public static void main(String[] args){List list = new ArrayList();show(list);}public static void show(List list){list.add( "abc1");list.add( "abc2");list.add( "abc3");list.add( "abc4"); Iterator it = list.iterator(); while(it.hasNext()){System.out.println( "next:" + it.next());} //list 特有的取出元素的方式之一for(int x = 0; x < list.size(); x++){ System.out.println( "get:" + list.get(x));}}}

ArrayList

概述：底层数据结构使用的是数组，查询速度快，增删慢；线程不安全。

            创建一个ArrayList集合对象： 
                    ArrayList al=new ArrayList(); 
                    al.add(“java01”);//向集合中添加元素； 
                    Iterator it=al.iterator();//返回一个迭代器；

                    ArrayList集合是Collection集合框架下的子类，即可使用其自身的特有方法也可使用父类接口中的共性方法；

                    ArrayList集合可使用特殊迭代器ListIterator，可在迭代的过程中对集合元素进行。

示例：

import java.util.*;class ListDemo {    public static void sop(Object obj){        System.out.println(obj);    }    public static void method(){            ArrayList al = new ArrayList();        al.add("java01");        al.add("java02");        al.add("java03");           sop("原集合是："+al);        //在指定位置添加元素。        al.add(1,"java09");        //通过角标获取元素。        sop("get(1):"+al.get(1));        sop(al);        //获取所有元素。        for(int x=0; x<al.size(); x++){            System.out.println("al("+x+")="+al.get(x));        }        Iterator it = al.iterator();        while(it.hasNext()){            sop("next:"+it.next());        }        //通过indexOf获取对象的位置。        sop("index="+al.indexOf("java02"));        List sub = al.subList(1,3);        sop("sub="+sub);    }    public static void main(String[] args) {        //演示列表迭代器。        ArrayList al = new ArrayList();        //添加元素        al.add("java01");        al.add("java02");        al.add("java03");        sop(al);                ListIterator li = al.listIterator();                //sop("hasPrevious():"+li.hasPrevious());        while(li.hasNext()){            Object obj = li.next();            if(obj.equals("java02"))                //li.add("java009");                li.set("java006");        }        while(li.hasPrevious()){            sop("pre::"+li.previous());        }        //sop("hasNext():"+li.hasNext());        //sop("hasPrevious():"+li.hasPrevious());        sop(al);    }}

Vector

概述：底层是数组数据结构，线程同步，被ArrayList替代了。因为效率低（JDK1.2版本）。

             枚举(Enumeration)是Vector特有的取出方式，类似于Collection的迭代器，其实和迭代器是一样的，被Iterator取代；

 示例：

import java.util.*;class VectorDemo {    public static void main(String[] args)     {        Vector v = new Vector();        v.add("java01");        v.add("java02");        v.add("java03");        v.add("java04");        Enumeration en = v.elements();        while(en.hasMoreElements())        {            System.out.println(en.nextElement());        }    }}

LinkedList

概述：底层是链表数据结构，增删快，查询慢；

特有方法：
              addFirst();
              addLast();
              getFirst();
              getLast();
              获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException

              remove()方法； 
              remove()；移除首位； 
              remove(int index);移除指定位置元素 
              remove(Object obj);//移除指定元素

              removeFirst();
              removeLast();
              获取元素，但是元素被删除。如果集合中没有元素，会出现NoSuchElementException

              在JDK1.6出现了替代方法。
              offerFirst();
              offerLast();

              peekFirst();
              peekLast();
              获取元素，但是元素被删除，如果集合中没有元素，会返回null
 
              pollFirst();
              pollLast();
              获取元素，但是元素被删除，如果集合中没有元素，会返回null。

示例：

class  LinkdeListDemo{public static void main(String[] args) {LinkedList link = new LinkedList();link.addFirst("java01");link.addFirst("java02");link.addFirst("java03");link.addFirst("java04");sop(link);sop(link.getFirst());sop(link.getLast());sop(link.removeFirst());sop(link);sop("size="+link.size());while(!link.isEmpty()){sop(link.removeLast());}}public static void sop(Object obj){System.out.println(obj);}}

附：如何选择使用ArrayList和LinkedList 

      当有增删较多的时候用LinkedList，当查询使用较多时用ArrayList，一般情况下使用ArrayList；

注：List集合判断元素是否相同，依据的是元素的equals方法；