java基礎----集合框架知識點總結（一）

                                   **第一個類   Collention類 **

一、概述。
1、該類是集合類的基本接口，它位於集合類的頂層。Collection接口的定義如下：

public interface Collection<E> extends Iterable<E>

2、此類使用了泛型技術，有利於集合的安全性。
3、此類是List接口和Set接口的父接口
二、方法摘要。
1）向集合中添加一個元素： boolean add(E e)
2) 清除集合中所有的元素： boolean clear()
3) 判斷是否存在所指定的元素： boolean contains(Object o)
4) 判斷集合是否爲空： boolean isEmpty()
5）刪除指定的元素： boolean remove(Object o)
6）返回集合中元素的個數： int size()
所有實現Collection接口的類都必須提供兩個標準的構造函數：
1）無參數的構造函數。
2）一個帶有Collection參數的有參構造函數。

                                   第二個類   List類
一、概述。
1、 List 接口是一個有序的集合，其元素以線性方式存儲，集合中允許存放相同的元素。用戶可以根據元素的整數索引（在列表中的位置）訪問元素，並搜索列表中的元素。
2、List接口的兩個實現類爲ArrayList和LinkedList。
3、其接口定義如下：

public interface List<E> extends Collection<E>

二、方法摘要。
1）、在集合的指定位置添加元素：void add(int index, E element)
2）、返回集合中指定位置的元素：E get(int index)
3）、移除指定位置的元素： E remove(int index)
4）、替換指定位置的元素： E set(int index, E element)
5）、爲ListIterator接口實例化，用戶遍歷集合中元素（特有方法）：ListIterator<E> listIterator()
6）、返回按適當順序在列表的元素上進行迭代的迭代器。Iterator iterator() `

示例：

package 泛型;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class ListIteratorTest {

    public static void main(String[] args){
        //List是個接口，可以通過ArrayList類實例化。
        List<String> list=new ArrayList<String>();
        //添加元素
        list.add("haha");
        list.add("xixi");
        list.add("lala");
        list.add("enen");
        sop(list);
        //獲取迭代器用於操作元素。
        ListIterator<String> it=list.listIterator();
        //取出集合中的元素
        while(it.hasNext()){
            String s=(String)it.next();
            sop(s);
            //修改元素
            if(s.equals("enen"))
                it.set("heihie");

        }
        it.add("yaya");//通過迭代器添加元素。
        sop(list);
    }

    private static void sop(Object obj) {
        // TODO Auto-generated method stub
        System.out.println(obj);
    }
}

                                   第三個類   ArrayList類和Vector類
一、概要。
1、此類是List接口的實現類。
2、此類的底層數據結構是數組。
3、此類的容量就是數組的大小。
4、此類實現數據的查詢速度塊，但是實現增、刪效率慢。
5、此類是不同步的。
二、構造方法摘要。
1、 ArrayList() 構造一個初始容量爲 10 的空列表。
2、`ArrayList(Collection

package 泛型;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

/*
 * Collection
 *      |--List：元素是有序的，元素可以重複，因爲該體系有索引
 *          |--ArrayList:底層的數據結構使用的是數組。特點：查詢數據很快，但是增，刪慢。線程不同步
 *          |--LinkedList：底層使用的是鏈表。特點：增刪的速度快，增刪的很慢
 *          |--Vector：底層使用的是數組數據結構。線程同步，速度非常慢，被ArrayList代替
 * List:特有的方法，凡是可以操作角標的地方都是該體系特有的方法
 * 
 * 增：
 *      add(index,element);
 *      addAll(index,Collection)
 * 刪：
 *      remove(index);
 * 
 * 改：
 *      set(index,element)
 * 
 * 查：   
 *      get(index)
 *      subList(from,to)
 *      ListIterator();
 * 
 * 
 * 
 */
public class ListDemo {

    public static void main(String[] args){
        ArrayList list=new ArrayList();

        //添加元素

        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");

        sop(list);

        //增加元素

        list.add(0,"0");
        sop(list);

        ArrayList al=new ArrayList();
        al.add("haha");
        al.add("xixi");
        al.add("wei");
        list.add(0,al);
        sop(list);
        list.addAll(0,al);
        sop(list);

        //刪除元素

        list.remove(0);
        sop(list);

        //修改元素

        list.set(2,"haha");
        sop(list);

        //查元素

        sop(list.get(0));

        //遍歷
        for(int i=0;i<list.size();i++){
            sop(list.get(i));
        }

        Iterator it=list.iterator();//獲取迭代器用於取出集合中的元素，只能進行判斷，刪除，取出的操作
        while(it.hasNext()){
            sop(it.next());
        }
        //list特有的迭代器功能齊全
        ListIterator li=list.listIterator();
        while(li.hasNext()){
            Object obj=li.next();
            if(obj.equals("1"))
                li.set("aiyouwei");
        }

        sop(list);
        //獲取元素的索引

        sop(list.indexOf("wei"));

        List l=list.subList(0, 5);
        sop(l);

        while(li.hasPrevious())//逆向遍歷列表
            sop(li.previous());

    }
    public static void sop(Object obj){
        System.out.println(obj);
    }

}

Vector類
示例：

package 泛型;
/*
 * 枚舉是Vector特有的取出方法
 * 其實枚舉和迭代是一樣的，因爲枚舉的名稱以及方法的名稱都過長，所以被迭代器取代了
 */
import java.util.Enumeration;
import java.util.ListIterator;
import java.util.Vector;

public class VectorDemo {

    public static void main(String[] args){
        Vector v=new Vector();
        v.add("1");
        v.add("2");
        v.add("3");
        v.add("4");

        Enumeration e=v.elements();

        while(e.hasMoreElements())
            System.out.println(e.nextElement());




        ListIterator li=v.listIterator();
        while(li.hasNext()){
            Object obj=li.next();
            if(obj.equals("1"))
                li.set("aiyouwei");
        }

    }
}

                                   第四個類   LinkedList類
一、概要。
1、此類是鏈表類，採用鏈表接口保存元素。
2、此類的優點在於刪除、插入元素效率較快。
3、此類是不同步的。
二、構造方法摘要。
1、 LinkedList() 構造一個空列表。
2、LinkedList(Collection<? extends E> c) 構造一個包含指定 collection 中的元素的列表
三、方法摘要。
1、void addFirst(E e) 將指定元素插入此列表的開頭。
2、void addLast(E e) 將指定元素添加到此列表的結尾。
3、E getFirst() 返回此列表的第一個元素。
4、E getLast() 返回此列表的最後一個元素。
在JDK1.6之後的新方法。
5、boolean offerFirst(E e) 在此列表的開頭插入指定的元素。
6、boolean offerLast(E e) 在此列表末尾插入指定的元素。
7、E peekFirst() 獲取但不移除此列表的第一個元素；如果此列表爲空，返回爲null 。
8、E peekLast() 獲取但不移除此列表的最後一個元素；如果此列表爲空,返回null。
9、E pollFirst() 獲取並移除此列表的第一個元素；如果此列表爲空，則返回 null。
10、E pollLast() 獲取並移除此列表的最後一個元素；如果此列表爲空，則返回 null。
示例一：

package 泛型;

import java.util.Iterator;
import java.util.LinkedList;

/*
 * LinkList特有的方法：
 * addFirst()
 * addLast()
 * 
 * getFirst()
 * getLast()
 *獲取元素但不刪除元素，如果集合中沒有元素，會拋出NoSuchElementException
 *
 *removeFirst()
 *removerLast()
 *獲取元素但是元素被刪除，如果集合中沒有元素，會出現NoSuchElementException
 *
 *在JDK1.6出現了替代方法
 *
 *offerFirst()
 *offerLast()
 *
 *peekFirst()
 *peekLast()
 *獲取元素但不是元素被刪除，如果集合中沒有元素，會返回null
 *
 *pollFirst()
 *pollLast()
 *獲取元素但是元素被刪除，如果集合中沒有元素，會出現NoSuchElementException
 * 
 */
public class LinkListDemo {

    public static void main(String[] args){
        LinkedList list=new LinkedList();

//      list.add("1");
//      list.add("2");
//      list.add("3");
//      list.add("4");
//      sop(list);

//      list.addFirst("1");
//      list.addFirst("2");
//      list.addFirst("3");
//      list.addFirst("4");
//      sop(list);

        list.addLast("1");
        list.addLast("2");
        list.addLast("3");
        list.addLast("4");
        sop(list);

        sop(list.getFirst());
        sop(list.getLast());

        Iterator it=list.iterator();

         while(it.hasNext())
             sop(it.next());
         sop(list.removeFirst());
         sop(list.removeLast());
         sop(list);
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

示例二：

package 泛型;

import java.util.LinkedList;

/*
 *使用linkedList模擬隊列或者堆棧數據結構
 *
 *隊列：先進先出
 *堆棧：先進後出
 */
class duiLie{
    private LinkedList link;
    duiLie(){
        link=new LinkedList();
    }
    public void myAdd(Object obj){
        link.addFirst(obj);
    }
    public Object getElement(){

        return link.removeLast();
    }
    public boolean isNull(){
        return link.isEmpty();
    }
}
public class LinkedListTest {

    public static void main(String[] args){
        duiLie link=new duiLie();
        link.myAdd("1");
        link.myAdd("2");
        link.myAdd("3");
        link.myAdd("4");

        while(!link.isNull())
            System.out.println(link.getElement());
    }
}

示例三：

“`
package 泛型;

import java.util.Iterator;
import java.util.LinkedList;

/*
* 去除linkedlist中相同的元素
*
*/
class newLink{
private LinkedList link=null;
public newLink(){
link=new LinkedList();
}
public LinkedList delete(LinkedList obj){
Iterator it=obj.iterator();
while(it.hasNext()){
if(link.contains(it.next())==false)
link.addLast(it.next());

    }
    return link;
}

}
public class LinkedListTest1 {

public static void main(String[] args){
    LinkedList link=new LinkedList();
    link.add("1");
    link.add("1");
    link.add("2");
    link.add("2");
    link.add("3");
    link.add("3");
    link.add("4");
    link.add("4");
    System.out.println(link);
    LinkedList L=new LinkedList();
    L=new newLink().delete(link);

    System.out.println(L);
}

}