List

List接口的特點:

• 它是一個元素存取有序的集合。例如，存元素的順序是11、22、33。那麽集合中，元素的存儲就是按照11、22、33的順序完成的。
• 它是一個帶有索引的集合，通過索引就可以精確的操作集合中的元素（與數組的索引是一個道理）。
• 集合中可以有重復的元素，通過元素的equals方法，來比較是否為重復的元素。

List接口的常用子類有：

• ArrayList集合
• LinkedList集合

List接口的特有方法(帶索引的方法)
1、增加元素方法

• add(Object e)：向集合末尾處，添加指定的元素
• add(int index, Object e) 向集合指定索引處，添加指定的元素，原有元素依次後移

/*
* add(int index, E)
* 將元素插入到列表的指定索引上
* 帶有索引的操作,防止越界問題
* java.lang.IndexOutOfBoundsException
* ArrayIndexOutOfBoundsException
* StringIndexOutOfBoundsException
*/
public static void function(){
        List<String> list=new ArrayList<String>();
        list.add(
 
"abc1");
        list.add("abc2");
        list.add("abc3");
        list.add("abc4");
        System.out.println(list);

        list.add(1,"itcast");
        System.out.println(list);
}

2、刪除元素

• remove(Object e)：將指定元素對象，從集合中刪除，返回值為被刪除的元素
• remove(int index)：將指定索引處的元素，從集合中刪除，返回值為被刪除的元素

/*
* E remove(int index)
* 移除指定索引上的元素
* 返回被刪除之前的元素
*/
public static void function_1(){
        List<Double> list = new ArrayList<Double>();
        list.add(1.1);
        list.add(1.2);
        list.add(1.3);
        list.add(1.4);

        Double d = list.remove(0);
        System.out.println(d);
        System.out.println(list);
} 

3、替換元素方法

set(int index, Object e)：將指定索引處的元素，替換成指定的元素，返回值為替換前的元素

/*
* E set(int index, E)
* 修改指定索引上的元素
* 返回被修改之前的元素
*/
public static void function_2(){
        List<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);

        Integer i = list.set(0, 5);
        System.out.println(i);
        System.out.println(list);
}

查詢元素方法

get(int index)：獲取指定索引處的元素，並返回該元素

叠代器的並發修改異常

叠代器的並發修改異常 java.util.ConcurrentModificationException就是在遍歷的過程中,使用了集合方法修改了集合的長度,這是不允許的。

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

public class ListDemo1 {

public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("abc1");
        list.add("abc2");
        list.add("abc3");
        list.add("abc4");

//對集合使用叠代器進行獲取,獲取時候判斷集合中是否存在 "abc3"對象
//如果有,添加一個元素 "ABC3"
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String s = it.next();
//對獲取出的元素s,進行判斷,是不是有"abc3"
            if(s.equals("abc3")){
                list.add("ABC3");
            }
            System.out.println(s);
        }
    }
}

運行結果：

Exception in thread "main" abc1
abc2
abc3
java.util.ConcurrentModificationException
    at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901)
    at java.util.ArrayList$Itr.next(ArrayList.java:851)
    at ArrayListDemo.main(ArrayListDemo.java:17)

運行上述代碼發生了錯誤 java.util.ConcurrentModificationException這是什麽原因呢？在叠代過程中，使用了集合的方法對元素進行操作。導致叠代器並不知道集合中的變化，容易引發數據的不確定性。

並發修改異常解決辦法：在叠代時，不要使用集合的方法操作元素。或者通過ListIterator叠代器操作元素是可以的，ListIterator的出現，解決了使用Iterator叠代過程中可能會發生的錯誤情況。

數據的存儲結構

棧 結 構：後進先出/先進後出(手槍彈夾) FILO (first in last out)

隊列結構：先進先出/後進後出(銀行排隊) FIFO(first in first out)

數組結構：查詢快，通過索引快速找到元素；增刪慢:每次增刪都需要開辟新的數組,將老數組中的元素拷貝到新數組中；開辟新數組耗費資源。

鏈表結構：查詢慢，每次都需要從鏈頭或者鏈尾找起；增刪快，只需要修改元素記錄的下個元素的地址值即可不需要移動大量元素

ArrayList集合的自身特點

底層采用的是數組結構

ArrayList al=new ArrayList();//創建了一個長度為0的Object類型數組
al.add("abc");//底層會創建一個長度為10的Object數組 Object[] obj=new Object[10]
//obj[0]="abc"
//如果添加的元素的超過10個,底層會開辟一個1.5*10的長度的新數組
//把原數組中的元素拷貝到新數組,再把最後一個元素添加到新數組中
//原數組:a b c d e f g h k l
//添加m:a b c d e f g h k l m null null null null

LinkedList集合的自身特點

底層采用鏈表結構,每次查詢都要從鏈頭或鏈尾找起,查詢相對數組較慢，但是刪除直接修改元素記錄的地址值即可,不要大量移動元素
LinkedList的索引決定是從鏈頭開始找還是從鏈尾開始找，如果該元素小於元素長度一半,從鏈頭開始找起,如果大於元素長度的一半,則從鏈尾找起

LinkedList特有方法:獲取,添加,刪除

/*
* LinkedList 鏈表集合的特有功能
* 自身特點: 鏈表底層實現,查詢慢,增刪快
* 
* 子類的特有功能,不能多態調用
*/
public class LinkedListDemo {
    public static void main(String[] args) {
        function_3();
    }
    /*
    * E removeFirst() 移除並返回鏈表的開頭
    * E removeLast() 移除並返回鏈表的結尾
    */
    public static void function_3(){
        LinkedList<String> link = new LinkedList<String>();
        link.add("1");
        link.add("2");
        link.add("3");
        link.add("4");

        String first = link.removeFirst();
        String last = link.removeLast();
        System.out.println(first);
        System.out.println(last);

        System.out.println(link);
    }

    /*
    * E getFirst() 獲取鏈表的開頭
    * E getLast() 獲取鏈表的結尾
    */
    public static void function_2(){
        LinkedList<String> link = new LinkedList<String>();
        link.add("1");
        link.add("2");
        link.add("3");
        link.add("4");

        if(!link.isEmpty()){
            String first = link.getFirst();
            String last = link.getLast();
            System.out.println(first);
            System.out.println(last);
        }
    }

    public static void function_1(){
        LinkedList<String> link = new LinkedList<String>();
        link.addLast("a");
        link.addLast("b");
        link.addLast("c");
        link.addLast("d");

        link.addFirst("1");
        link.addFirst("2");
        link.addFirst("3");
        System.out.println(link);
    }

    /*
    * addFirst(E) 添加到鏈表的開頭
    * addLast(E) 添加到鏈表的結尾
    */
    public static void function(){
        LinkedList<String> link = new LinkedList<String>();

        link.addLast("heima");

        link.add("abc");
        link.add("bcd");

        link.addFirst("itcast");
        System.out.println(link);
    }
}

Vector

Vector集合數據存儲的結構是數組結構，為JDK中最早提供的集合,它是線程同步的。

Vector中提供了一個獨特的取出方式，就是枚舉Enumeration，它其實就是早期的叠代器。

此接口Enumeration的功能與 Iterator 接口的功能是類似的。
Vector集合已被ArrayList替代。枚舉Enumeration已被叠代器Iterator替代。

^Set

Set接口的特點

它是個不包含重復元素的集合。
Set集合取出元素的方式可以采用：叠代器、增強for。
Set集合有多個子類，這裏我們介紹其中的HashSet、LinkedHashSet這兩個集合。

/*
* Set接口,特點不重復元素,沒索引
* 
* Set接口的實現類,HashSet (哈希表)
* 特點: 無序集合,存儲和取出的順序不同,沒有索引,不存儲重復元素
* 代碼的編寫上,和ArrayList完全一致
*/
public class HashSetDemo {
    public static void main(String[] args) {
        Set<String> set = new HashSet<String>();
        set.add("cn");
        set.add("heima");
        set.add("java");
        set.add("java");
        set.add("itcast");

        Iterator<String> it = set.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
        System.out.println("==============");

        for(String s : set){
            System.out.println(s);
        }
    }
}

哈希表的數據結構

加載因子:表中填入的記錄數/哈希表的長度

例如:加載因子是0.75 代表：數組中的16個位置,其中存入16*0.75=12個元素

如果在存入第十三個(>12)元素,導致存儲鏈子過長,會降低哈希表的性能,那麽此時會擴充哈希表(在哈希),底層會開辟一個長度為原長度2倍的數組,把老元素拷貝到新數組中,再把新元素添加數組中
當存入元素數量>哈希表長度*加載因子,就要擴容,因此加載因子決定擴容時機

字符串對象的哈希值

/*
 *  對象的哈希值,普通的十進制整數
 *  父類Object,方法 public int hashCode() 計算結果int整數
 */
public class HashDemo {
    public static void main(String[] args) {
        String s1 = new String("abc");
        String s2 = new String("abc");
        System.out.println(s1.hashCode());//96354
        System.out.println(s2.hashCode());//96354

        System.out.println("重地".hashCode());//1179395
        System.out.println("通話".hashCode());//1179395
    }
}

//String類重寫hashCode()方法
//字符串都會存儲在底層的value數組中{‘a‘,‘b‘,‘c‘}
public int hashCode() {
    int h = hash;
    if (h == 0 && value.length > 0) {
        char val[] = value;

        for (int i = 0; i < value.length; i++) {
            h = 31 * h + val[i];
        }
        hash = h;
    }
    return h;
}

哈希表的存儲過程

public static void main(String[] args) {
    HashSet<String> set = new HashSet<String>();
    set.add(new String("abc"));
    set.add(new String("abc"));
    set.add(new String("bbc"));
    set.add(new String("bbc"));
    System.out.println(set);
}

存取原理，每存入一個新的元素都要走以下三步:

1.首先調用本類的hashCode()方法算出哈希值

2.在容器中找是否與新元素哈希值相同的老元素,如果沒有直接存入；如果有轉到第三步

3.新元素會與該索引位置下的老元素利用equals方法一一對比，一旦新元素.equals(老元素)返回true,停止對比,說明重復,不再存入，如果與該索引位置下的老元素都通過equals方法對比返回false,說明沒有重復,存入。hashCode()返回一個是十進制的值,這個值叫做哈希值,不同的類都會重寫Object類的hashCode()方法,底層有不同的生成哈希值的算法,下面介紹如何通過hashCode()方法和equals()方法保證存入HashSet的值唯一的。

哈希表的存儲自定義對象

/*
* HashSet集合的自身特點:
* 底層數據結構,哈希表
* 存儲,取出都比較快
* 線程不安全,運行速度快
*/
public class HashSetDemo1 {
    public static void main(String[] args) {

//將Person對象中的姓名,年齡,相同數據,看作同一個對象
//判斷對象是否重復,依賴對象自己的方法 hashCode,equals
        HashSet<Person> setPerson = new HashSet<Person>();
        setPerson.add(new Person("a",11));
        setPerson.add(new Person("b",10));
        setPerson.add(new Person("b",10));
        setPerson.add(new Person("c",25));
        setPerson.add(new Person("d",19));
        setPerson.add(new Person("e",17));//每個對象的地址值都不同,調用Obejct類的hashCode方法返回不同哈希值,直接存入
        System.out.println(setPerson);
    }
}

public class Person {
    private String name;
    private int age;

    /*
    * 沒有做重寫父類,每次運行結果都是不同整數
    * 如果子類重寫父類的方法,哈希值,自定義的
    * 存儲到HashSet集合的依據
    * 
    * 盡可能讓不同的屬性值產生不同的哈希值,這樣就不用再調用equals方法去比較屬性
    *
    */
    public int hashCode(){
        return name.hashCode()+age*55;
    }
    //方法equals重寫父類,保證和父類相同
//public boolean equals(Object obj){}
    public boolean equals(Object obj){
        if(this == obj)
            return true;
        if(obj == null)
            return false;
        if(obj instanceof Person){
            Person p = (Person)obj;
            return name.equals(p.name) && age==p.age;
        }
        return false;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Person(){}

    public String toString(){
        return name+".."+age;
    }
}

LinkedHashSet集合

LinkedHashSet 基於鏈表的哈希表實現，繼承自HashSet。

LinkedHashSet 自身特性：

• 具有順序,存儲和取出的順序相同的；
• 線程不安全的集合,運行速度塊

public class LinkedHashSetDemo {
    public static void main(String[] args) {
        LinkedHashSet<Integer> link = new LinkedHashSet<Integer>();
        link.add(123);
        link.add(44);
        link.add(33);
        link.add(33);
        link.add(66);
        link.add(11);
        System.out.println(link);
    }
}

ArrayList,HashSet判斷對象是否重復的原因

ArrayList的contains方法原理:底層依賴於equals方法，ArrayList的contains方法調用時，會使用傳入元素的equals方法依次與集合中的舊元素所比較，從而根據返回的布爾值判斷是否有重復元素。

此時，當ArrayList存放自定義類型時，由於自定義類型在未重寫equals方法前，判斷是否重復的依據是地址值，所以如果想根據內容判斷是否為重復元素，需要重寫元素的equals方法。HashSet的add()方法和contains方法()底層都依賴 hashCode()方法與equals方法()。

Set集合不能存放重復元素，其添加方法在添加時會判斷是否有重復元素，有重復不添加，沒重復則添加。

HashSet集合由於是無序的，其判斷唯一的依據是元素類型的hashCode與equals方法的返回結果。規則如下：

先判斷新元素與集合內已經有的舊元素的HashCode值，如果不同，說明是不同元素，添加到集合。如果相同，再判斷equals比較結果。返回true則相同元素；返回false則不同元素，添加到集合。

所以，使用HashSet存儲自定義類型，如果沒有重寫該類的hashCode與equals方法，則判斷重復時，使用的是地址值，如果想通過內容比較元素是否相同，需要重寫該元素類的hashcode與equals方法。

hashCode和equals的面試題

兩個對象 Person p1 p2，如果兩個對象的哈希值相同 p1.hashCode()==p2.hashCode()，兩個對象的equals一定返回true嗎？ 即p1.equals(p2) 一定是true嗎？

正確答案:不一定

如果兩個對象的equals方法返回true,p1.equals(p2)==true，兩個對象的哈希值一定相同嗎？

正確答案: 一定

Java對於eqauls方法和hashCode方法是這樣規定的：

• 1.如果兩個對象相同，那麽它們的hashCode值一定要相同；
• 2.如果兩個對象的hashCode相同，它們並不一定相同（這裏說的對象相同指的是用eqauls方法比較）。如不按要求去做了，會發現相同的對象可以出現在Set集合中，同時，增加新元素的效率會大大下降。
• 3.equals()相等的兩個對象，hashcode()一定相等；equals()不相等的兩個對象，卻並不能證明他們的hashcode()不相等。換句話說，equals()方法不相等的兩個對象，hashcode()有可能相等（我的理解是由於哈希碼在生成的時候產生沖突造成的）。反過來，hashcode()不等，一定能推出equals()也不等；hashcode()相等，equals()可能相等，也可能不等。

歸納總結

Java基礎學習筆記十六 集合框架（二）