List接口的實現類

1.簡述

　　List是用的較多的集合類型，List是一個接口，具體使用List集合類型時，需要使用時實現類。List接口的每個實現類也都實現了不同的數據結構，各自具有不同的特征。

　　特點：

• 有序的，允許重復元素。順序可以是自然排序或按對象加入到集合的順序排序。因為List，所以它的對象可以被索引。ListIterator接口提供了迭代列表中元素的方法。抽象的List可以被隨機的、通過數組、通過鏈接表或通過雙向鏈接表進行訪問。

　　List接口中有以下幾個常用實現類：

• ArrayList：基於數組。每次增刪都會創建新的數組，但數組有索引。ArrayList有查詢快、增刪慢的特點。
• LinkedList：基於鏈表(雙向)實現。每個元素存儲本身內存地址的同時，還會存儲下一個元素的地址。所以LinkedList有查詢慢、增刪快的特點。
• Vector：基於數組，Vector和ArrayList用法上幾乎相同，但Vector比較古老，一般不用。Vector是線程同步的，效率低。
  

2.ArrayList

　　ArrayList簡述：

• ArrayList是一個數組隊列，相當於動態數組。線程不安全。
• ArrayList繼承了AbstractList，實現了List。它是一個數組隊列，提供了相關的添加、刪除、修改、遍歷等功能。
• ArrayList實現了RandmoAccess接口，即提供了隨機訪問功能。RandmoAccess是java中用來被List實現，為List提供快速訪問功能的。在ArrayList中，我們即可以通過元素的序號快速獲取元素對象，這就是快速隨機訪問。
• ArrayList實現了Cloneable接口，即覆蓋了函數clone()，能被克隆。
• ArrayList實現java.io.Serializable接口，這意味着ArrayList支持序列化，能通過序列化去傳輸。

　　定義一個ArrayList的方式有如下幾種：

//默認創建一個ArrayList集合
List<String> list = new ArrayList<>();
//創建一個初始化長度為50的ArrayList集合
List<String> initlist = new ArrayList<>(50);
//將其他類型的集合轉為ArrayList
List<String> setList = new ArrayList<>(new HashSet());

　　ArrayList有很多常用方法，add、addAll、set、get、remove、size、isEmpty等，關於其他方法可以查看API。

　　ArrayList的遍歷方式有如下幾種：

public class Test {
    public static void main(String[] args) throws Exception {
        ArrayList<String> list = new ArrayList<String>();
        list.add("A");
        list.add("B");
        list.add("C");
        list.add("D");
        list.add("E");
        list.add("F");
        //通過迭代器遍歷
        Iterator<String> iterator = list.iterator();
        while(iterator.hasNext()) {
            System.out.print(iterator.next());
        }
        System.out.println("\n--------------------------");
        //for循環遍歷
        for (String val : list) {
            System.out.print(val);
        }
        System.out.println("\n--------------------------");
        //隨機訪問，通過list.get(i)獲得索引值去遍歷。
        for(int i=0;i<list.size();i++) {
            System.out.print(list.get(i));
        }
    }
}

　　ArrayList的去除重復數據的方式有如下幾種：

public class Test {
    public static void main(String[] args) throws Exception {
        ArrayList<String> list = new ArrayList<String>();
        list.add("A");
        list.add("B");
        list.add("C");
        list.add("D");
        list.add("E");
        list.add("B");
        System.out.println(Arrays.toString(removeDuplicate1(list).toArray()));
        System.out.println(Arrays.toString(removeDuplicate2(list).toArray()));
        System.out.println(Arrays.toString(removeDuplicate3(list).toArray()));
    }
    
    //1.循環list中所有的元素然后刪除，有序
    public static ArrayList removeDuplicate1(ArrayList list){
        for(int i =0;i<list.size()-1;i++){
            for(int j=list.size()-1;j>i;j--){
                if(list.get(i).equals(list.get(j)))
                    list.remove(j);
            }
        }
        
        return list;        
    }
    
    //2.利用hashSet剔除重復元素，無序
    public static ArrayList removeDuplicate2(ArrayList list){
        HashSet set = new HashSet(list);
        //使用LinkedHashSet可以保證輸入的順序
        //LinkedHashSet<String> set2 = new LinkedHashSet<String>(list); 
        list.clear();        
        list.addAll(set);
        return list;        
    }
    
    //3.利用list的contains方法去重，無序
    public static ArrayList removeDuplicate3(ArrayList list){
        ArrayList tempList = new ArrayList(list.size());
        for(int i=0;i<list.size();i++){
            if(!tempList.contains(list.get(i)))
                tempList.add(list.get(i));
        }
        return tempList;        
    }
}

　　ArrayList的去除重復對象數據的方式如下：

public class Test {
    public static void main(String[] args) throws Exception {
        List<Person> list = new ArrayList<Person>();
        list.add(new Person("張三", "1"));
        list.add(new Person("張三", "2"));
        list.add(new Person("張三", "1"));
        list.add(new Person("張三", "4"));
        list.add(new Person("李四", "1"));
        list.add(new Person("李四", "2"));
        list.add(new Person("張三", "3"));
        list.add(new Person("李四", "1"));
        System.out.println(Arrays.toString(removeDuplicate1(list).toArray()));
        System.out.println(Arrays.toString(removeDuplicate2(list).toArray()));
    }
    
    //1.循環list中所有的元素然后刪除
    public static List<?> removeDuplicate1(List<?> list){
        for (int i = 0; i < list.size() - 1; i++) {
            for (int j = i + 1; j < list.size(); j++) {
                if (list.get(i).equals(list.get(j))) {
                    list.remove(j);
                }
            }
        }
        return list;        
    }
    
    //3.利用list的contains方法去重
    public static List<Person> removeDuplicate2(List<Person> list){
        List<Person> temp = new ArrayList<Person>();
        Iterator<Person> iterator = list.iterator();
        while (iterator.hasNext()) {
            Person person = iterator.next();
            if (!temp.contains(person)) {
                temp.add(person);
            }
        }
        return temp;        
    }
}
class Person {
    private String name;
    private String id;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public Person(String name, String id) {
        super();
        this.name = name;
        this.id = id;
    }

    /**當調用contains的時候它的底層會自動調用equals()，然后我們重寫equals方法，由此來做判斷，解決元素重復問題。
     */
    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (!(obj instanceof Person)) {
            throw new ClassCastException();// 類型錯誤
        }
        Person person = (Person) obj;
        return this.getId().equals(person.getId()) && this.getName().equals(person.getName());
    }

    @Override
    public String toString() {
        return "Person [name=" + name + ", id=" + id + "]";
    }

}

3.LinkedList

　　LinkedList簡述：

• LinkedList是一個雙向列表，線程不安全。
• LinkedList是一個繼承於AbstractSequentialList的雙向循環鏈表。它也可以被當作堆棧、隊列或雙端隊列進行操作。
• LinkedList實現List接口，能對它進行隊列操作。
• LinkedList實現Deque接口，即能將LinkedList當作雙端隊列使用。
• LinkedList實現了Cloneable接口，即覆蓋了函數clone()，能被克隆。
• LinkedList實現java.io.Serializable接口，這意味着LinkedList支持序列化，能通過序列化去傳輸。

　　定義一個LinkedList的方式有如下幾種：

//默認創建一個LinkedList集合
LinkedList<String> list = new LinkedList<>();
//將其他類型的集合轉為LinkedList
LinkedList<String> setList = new LinkedList<>(new HashSet());

　　LinkedList有很多常用方法，add、addAll、set、get、remove、size、isEmpty等，關於其他方法可以查看API。

　　LinkedList的遍歷、去除重復數據方式和ArrayList一樣，就不在陳述了。

4.Vector

 　　Vector簡述：

• Vector是矢量隊列，線程安全的。
• Vector繼承了AbstractList，實現了List。所以，它是一個隊列，支持相關的添加、刪除、修改、遍歷等功能。
• Vector實現了RandmoAccess接口，即提供了隨機訪問功能。RandmoAccess是java中用來被List實現，為List提供快速訪問功能的。在Vector中，我們即可以通過元素的序號快速獲取元素對象。這就是快速隨機訪問。
• Vector實現了Cloneable接口，即覆蓋了函數clone()，能被克隆。

　　定義一個Vector的方式有如下幾種：

//默認創建一個Vector集合
Vector<String> vector = new Vector<>();
//創建一個初始化長度為50的Vector集合，當由於增加數據導致容量增加時，每次容量會增加一倍。
Vector<String> initVector = new Vector<>(50);
//創建一個初始化長度為50的Vector集合，當由於增加數據導致容量增加時，每次容量會增加30。
Vector<String> initVector2 = new Vector<>(50,30);
//將其他類型的集合轉為Vector
Vector<String> setVector = new Vector<>(new HashSet());

　　Vector有很多常用方法，add、addAll、addElement、set、get、remove、removeElement、size、isEmpty等，關於其他方法可以查看API。

　　Vector的遍歷、去除重復數據方式和ArrayList一樣，就不在陳述了。