Java集合框架

Java集合框架

1.集合框架體系

2.ArrayList集合

2.1特點

• 有序可重複。
• ArrayList底層是基於數組實現的。
• 查改快，增刪慢。
• 線程不安全。可以通過封裝實現線程同步。

List list = Collections.synchronizedList(new ArrayList(...)); 

2.2構造方法

ArrayList() jdk1.6初始容量爲10，jdk1.8初始容量爲0； 
ArrayList(Collection<? extends E> c) 構造一個包含指定 collection 的元素的列表，這些元素是按照該 collection 的迭代器返回它們的順序排列的。 
ArrayList(int initialCapacity) 構造一個具有指定初始容量的空列表。 

2.3普通方法

 boolean add(E e) 將指定的元素添加到此列表的尾部。 
 void add(int index, E element) 將指定的元素插入此列表中的指定位置。 
 boolean addAll(Collection<? extends E> c) 按照指定 collection 的迭代器所返回的元素順序，將該 collection 中的所有元素添加到此列表的尾部。 
 boolean addAll(int index, Collection<? extends E> c) 從指定的位置開始，將指定 collection 中的所有元素插入到此列表中。 
 void clear()  移除此列表中的所有元素。 
 Object clone() 返回此 ArrayList 實例的淺表副本。 
 boolean contains(Object o) 如果此列表中包含指定的元素，則返回 true。 
 void ensureCapacity(int minCapacity) 如有必要，增加此 ArrayList 實例的容量，以確保它至少能夠容納最小容量參數所指定的元素數。 
 E get(int index) 返回此列表中指定位置上的元素。 
 int indexOf(Object o) 返回此列表中首次出現的指定元素的索引，或如果此列表不包含元素，則返回 -1。 
 boolean isEmpty() 如果此列表中沒有元素，則返回 true 
 int lastIndexOf(Object o) 返回此列表中最後一次出現的指定元素的索引，或如果此列表不包含索引，則返回 -1。 
 E remove(int index) 移除此列表中指定位置上的元素。 
 boolean remove(Object o) 移除此列表中首次出現的指定元素（如果存在）。 
protected  void removeRange(int fromIndex, int toIndex) 移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之間的所有元素。 
 E set(int index, E element) 用指定的元素替代此列表中指定位置上的元素。 
 int size() 返回此列表中的元素數。 
 Object[] toArray() 按適當順序（從第一個到最後一個元素）返回包含此列表中所有元素的數組。 
<T> T[] toArray(T[] a) 按適當順序（從第一個到最後一個元素）返回包含此列表中所有元素的數組；返回數組的運行時類型是指定數組的運行時類型。 
 void trimToSize() 將此 ArrayList 實例的容量調整爲列表的當前大小。 

3.LinkedList集合

3.1特點

• 有序可重複。
• 底層基於雙向循環鏈表實現，每增加一個元素都會創建一個新的節點。
• 增刪快，查詢慢。
• 線程不安全。可以通過封裝實現線程同步。

List list = Collections.synchronizedList(new LinkedList(...));

3.2構造方法

LinkedList() 構造一個空列表。 
LinkedList(Collection<? extends E> c) 構造一個包含指定 collection 中的元素的列表，這些元素按其 collection 的迭代器返回的順序排列。 

3.3普通方法

 boolean addAll(int index, Collection<? extends E> c) 將指定 collection 中的所有元素從指定位置開始插入此列表。 
 void addFirst(E e) 將指定元素插入此列表的開頭。 
 void addLast(E e) 將指定元素添加到此列表的結尾。 
 boolean contains(Object o) 如果此列表包含指定元素，則返回 true。 
 Iterator<E> descendingIterator() 返回以逆向順序在此雙端隊列的元素上進行迭代的迭代器。 
 E element() 獲取但不移除此列表的頭（第一個元素）。 
 E get(int index) 返回此列表中指定位置處的元素。 
 E getFirst() 返回此列表的第一個元素。 
 E getLast() 返回此列表的最後一個元素。 
 boolean offer(E e) 將指定元素添加到此列表的末尾（最後一個元素）。 
 boolean offerFirst(E e) 在此列表的開頭插入指定的元素。 
 boolean offerLast(E e) 在此列表末尾插入指定的元素。 
 E peek() 獲取但不移除此列表的頭（第一個元素）。 
 E peekFirst() 獲取但不移除此列表的第一個元素；如果此列表爲空，則返回 null。 
 E peekLast() 獲取但不移除此列表的最後一個元素；如果此列表爲空，則返回 null。 
 E poll() 獲取並移除此列表的頭（第一個元素） 
 E pollFirst() 獲取並移除此列表的第一個元素；如果此列表爲空，則返回 null。 
 E pollLast() 獲取並移除此列表的最後一個元素；如果此列表爲空，則返回 null。 
 E pop() 從此列表所表示的堆棧處彈出一個元素。 
 void push(E e) 將元素推入此列表所表示的堆棧。 
 E remove() 獲取並移除此列表的頭（第一個元素）。 
 E remove(int index) 移除此列表中指定位置處的元素。 
 boolean remove(Object o) 從此列表中移除首次出現的指定元素（如果存在）。 
 E removeFirst() 移除並返回此列表的第一個元素。 
 boolean removeFirstOccurrence(Object o) 從此列表中移除第一次出現的指定元素（從頭部到尾部遍歷列表時）。 
 E removeLast() 移除並返回此列表的最後一個元素。 
 boolean removeLastOccurrence(Object o) 從此列表中移除最後一次出現的指定元素（從頭部到尾部遍歷列表時）。
 （其他方法同ArrayList）

4.HashSet集合

4.1特點

• 無序唯一。
• 底層爲hash表結構。
• 可以存儲任意對象，最多容納一個null。
• 要保證添加的元素不重複，需要覆寫hashCode和equals方法。
• 線程不安全，可以通過封裝實現線程同步。

 Set s = Collections.synchronizedSet(new HashSet(...));

4.2判斷元素重複的標準

• 如果兩個對象的hashCode值相等，並且equals方法返回爲ture就表示對象相等。
• 自定義對象需要覆寫hashCode和equals方法（自動生成）。

public class Student {
    String name;
    int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //重寫equals方法
    @Override
    public boolean equals(Object o) {
        //比較地址，如果地址相同，則表示是同一個對象
        if (this == o) return true;
        //如果參與比較的對象是null，或者傳入的對象類型不一致，返回false
        if (o == null || getClass() != o.getClass()) return false;
        //強轉
        Student student = (Student) o;
        //比較字段
        return age == student.age && name.equals(student.name);
    }

    @Override
    public int hashCode() {
        //調用Objects類中的hash方法
        return Objects.hash(name, age);
    }
    /**
     * Objects類中的hash方法
     * public static int hash(Object... values) {
     *    //調用Arrays中的hashCode方法
     *    return Arrays.hashCode(values);
     * }
     *
     * public static int hashCode(Object a[]) {
     *     //如果a爲null，返回0
     *     if (a == null)
     *         return 0;
     *     int result = 1;
     *     //循環遍歷參數
     *     for (Object element : a)
     *         //1 * 31 + name.hashCode()
     *         //(1 * 31 + name.hashCode()) * 31 + age.hashCode()
     *         //將範圍擴大，減小重複的概率
     *         result = 31 * result + (element == null ? 0 : element.hashCode());
     *     return result;
     * }
     *
     */
    @Override
    public String toString() {
        return "["+name+","+age+"]";
    }
}

5.TreeSet集合

5.1特點

• 無序唯一。
• 添加一種類型後不能再添加其他的類型。
• TreeSet內部是按照一定（大小）的順序存放的。
• 線程不安全，可以通過封裝實現線程同步。

 Set s = Collections.synchronizedSet(new HashSet(...));

• 要將元素添加進TreeSet集合，元素【對象】必須具有自然排序的能力，即實現了Comparable接口，並且重寫了comparaTo()方法。若沒有實現Comparable接口，則需要添加此元素的集合添加了定製比較器。

5.2自然排序

自定義的類實現Comparable接口，並重寫CompareTo方法。

class Student implements Comparable{
    String name;
    int age;
    @Override
    public int compareTo(Object o) {
        //強制類型轉換
       Student stu = (Student) o;
       //用年齡字段作爲比較對象大小的依據
       if(this.age>stu.age){
           return -1;
       }else if(this.age< stu.age){
           return 1;
       }else{
           //通過上面的比較，age字段已經相同，下面應該取決於name字段。
           return name.compareTo(stu.name);
       }
    }
}
public class TreeSetDemo {
    public static void main(String[] args) {
        TreeSet treeSet = new TreeSet();
        treeSet.add(new Student("劉備",43));
        treeSet.add(new Student("關羽",45));
        treeSet.add(new Student("張飛",39));
        System.out.println(treeSet);
    }
}

5.3定製排序

給集合指定排序規則。需要自定義一個比較器類，實現Comparator接口，重寫CompareTo()方法。並且將這個比較器對象作爲TreeSet構造函數的參數傳遞。
若某個類即實現了自然排序，有指定了定製比較器，則優先使用定製比較器

5.3.1自定義一個比較器類

public class Student {
    String name;
    int age;
}

//自定義比較器，實現Comparator接口，重寫compare方法。
public class StudentComparator implements Comparator {
    //重寫compare方法
    @Override
    public int compare(Object o1, Object o2) {
        //強制類型轉換
        Student stu1 = (Student) o1;
        Student stu2 = (Student) o2;
        //首先按照年齡進行比較
        if(stu1.age>stu2.age){
            return -1;
        }else if(stu1.age<stu2.age){
            return 1;
        }else {
            //如果年齡相同，則比較姓名
            return stu1.name.compareTo(stu2.name);
        }
    }
}

public class Test {
    public static void main(String[] args) {
        StudentComparator sc = new StudentComparator();
        TreeSet ts = new TreeSet(sc);
        ts.add(new Student("劉備",43));
        ts.add(new Student("關羽",45));
        ts.add(new Student("張飛",39));
        System.out.println(ts);
    }
}

6.集合的遍歷

6.1for循環遍歷

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

6.2foreach遍歷

    //foreach遍歷
    for (Object obj :list) {
    	System.out.println(obj);
    }

6.3迭代器遍歷

	//迭代器遍歷
    Iterator iterator = list.iterator();
    while (iterator.hasNext()){
		System.out.println(iterator.next());
	}

6.4轉成數組遍歷

Object[] objects = list.toArray();