java集合框架

Java集合框架

Collection接口API

Iterator迭代器接口

Collection子接口之一：Set接口

HashSet  LinkedHashSet  TreeSet

Collection子接口之二：List接口

ArrayList LinkedList Vector

Map接口

HashMap TreeMap Hashtable

Collections工具類


java集合概述：

一方面， 面嚮對象語言對事物的體現都是以對象的形式，爲了方便對多個對象的操作，就要對對象進行存儲。另一方面，使用Array存儲對象方面具有一些弊端，而Java集合就像一種容器，可以動態地把多個對象的引用放入容器中。

Java 集合類可以用於存儲數量不等的多個對象，還可用於保存具有映射關係的關聯數組。

 1.存儲對象可以考慮：①數組 ②集合
 * 2.數組存儲對象的特點：Student[] stu = new Student[20]; stu[0] = new Student();....
 *    >弊端：①一旦創建，其長度不可變。②真實的數組存放的對象的個數是不可知。
 * 3.集合
 *     Collection接口
 *             |------List接口：存儲有序的，可以重複的元素
 *                     |------ArrayList（主要的實現類）、LinkedList（對於頻繁的插入、刪除操作）、Vector（古老的實現類、線程安全的）
 *             |------Set接口：存儲無序的，不可重複的元素
 *                     |------HashSet、LinkedHashSet、TreeSet
 *     Map接口：存儲“鍵-值”對的數據
 *             |-----HashMap、LinkedHashMap、TreeMap、Hashtable(子類：Properties)

lJava 集合可分爲Collection和Map兩種體系

Collection接口：

    Set：元素無序、不可重複的集合---類似高中的“集合”

    List：元素有序，可重複的集合 ---”動態”數組

Map接口：具有映射關係“key-value對”的集合---類似於高中的“函數”y =f(x)   (x1,y1) (x2,y2)

Collection 接口是List、Set 接口的父接口，該接口裏定義了List、Set的常用抽象方法。

       1.size():返回集合中元素的個數
       
        2.add(Object obj):向集合中添加一個元素
   
        3.addAll(Collection coll):將形參coll中包含的所有元素添加到當前集合中
        Collection coll1 = Arrays.asList(1, 2, 3);
        coll.addAll(coll1);

        // 4.isEmpty():判斷集合是否爲空
        System.out.println(coll.isEmpty());

        // 5.clear():清空集合元素
        coll.clear();
        System.out.println(coll.isEmpty());

        // 6.contains(Object obj):判斷集合中是否包含指定的obj元素。如果包含，返回true，反之返回false
        // 判斷的依據：根據元素所在的類的equals()方法進行判斷
        // 明確：如果存入集合中的元素是自定義類的對象。要求：自定義類要重寫equals()方法！

       // 7.containsAll(Collection coll):判斷當前集合中是否包含coll中所有的元素

      // 8.retainAll(Collection coll):求當前集合與coll的共有的元素，返回給當前集合（將當前集合修改了）

        // 9.remove(Object obj):刪除集合中的obj元素。若刪除成功，返回true。否則，返回false

      //13.toArray() :將集合轉化爲數組
        Object[] obj = coll.toArray();
     
      //14  Iterator iterator = coll.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

集合的遍歷：
方式一：
Iterator i = coll.iterator();
        while(i.hasNext()){
            System.out.println(i.next());
        }
示意圖：

方式二：//使用增強for循環實現集合的遍歷

for(Object i:coll){
            System.out.println(i);
        }
//使用增強for循環實現數組的遍歷
    @Test
    public void testFor1(){
        String[] str = new String[]{"AA","BB","DD"};
        for(String s:str){
            System.out.println(s);
        }
    }
增強for循環的注意點：
String[] str = new String[]{"AA","BB","DD"};
        for(int i = 0;i < str.length;i++){
            str[i] = i + "";
        }
        
        for(int i = 0;i < str.length;i++){
            System.out.print(str[i]+“ ”);
        }
打印結果：0 1 2
通過str[i]這種方式可以修改數組的值。

String[] str = new String[]{"AA","BB","DD"};
        for(String s : str){
            s =  "MM";//此處的s是新定義的局部變量，其值的修改不會對str本身造成影響。
            System.out.println(s);
        }        
        
        for(int i = 0;i < str.length;i++){
            System.out.print(str[i]+“ ”);
        }
打印結果AA BB CC
s是新定義的局部變量，其值的修改不會對str本身造成影響。


List的常用方法（有序可以重複的集合）：（在繼承colletion的基礎上，會有一些自己的方法）

     * List中相對於Collection，新增加的方法
     *  void add(int index, Object ele):在指定的索引位置index添加元素ele
        boolean addAll(int index, Collection eles)
        Object get(int index):獲取指定索引的元素
        Object remove(int index):刪除指定索引位置的元素
        Object set(int index, Object ele):設置指定索引位置的元素爲ele
        int indexOf(Object obj):返回obj在集合中首次出現的位置。沒有的話，返回-1
        int lastIndexOf(Object obj)：返回obj在集合中最後一次出現的位置.沒有的話，返回-1
        List subList(int fromIndex, int toIndex):返回從fromIndex到toIndex結束的左閉右開一個子list
        
        List常用的方法：增(add(Object obj)) 刪(remove) 改(set(int index,Object obj))
                    查(get(int index)) 插(add(int index, Object ele)) 長度(size())
     */
      ArrayList：List的主要實現類，底層數組存儲。
      LinkedList:相對於ArrayList，linkedList底層是用鏈表實現的。
     新增加的方法：

     void addFirst(Objectobj)

     void addLast(Objectobj) 

     Object getFirst()

     Object getLast()

      Vector 是一個古老的集合類，是線程安全的。

ArrayList 採用的是數組形式來保存對象的，這種方式將對象放在連續的位置中，查詢時候很快，
但是最大的缺點就是插入刪除時非常麻煩(會有大量的位置移動)
LinkedList 採用的將對象存放在獨立的空間中，而且在每個空間中還保存下一個鏈接的索引，
對於頻繁的插入或刪除元素的操作 ，效率很高， 但是缺點就是查找非常麻煩 要叢第一個索引開始。

Set 接口：

Set接口是Collection的子接口，set接口沒有提供額外的方法 Set:存儲的元素是無序的，不可重複的！ *  1.無序性：無序性！= 隨機性。真正的無序性，指的是元素在底層存儲的位置是無序的。 * 2.不可重複性：當向Set中添加進相同的元素的時候，後面的這個不能添加進去。

HashSet：是 Set 接口的典型實現，大多數時候使用 Set 集合時都使用這個實現類。

HashSet具有以下特點：

不能保證元素的排列順序

HashSet不是線程安全的

集合元素可以是 null

* 說明：要求添加進HashSet中的元素所在的類，一定要重寫equals()和hashCode()方法。
 進而保證Set中元素的不可重複性！
* HashSet中的元素時如何存儲的呢？使用了哈希算法。
* 當向Set中添加對象時，首先調用此對象所在類的hashCode()方法，計算此對象的哈希值，此哈希值
* 決定了此對象在Set中的存儲位置。若此位置之前沒有對象存儲，則這個對象直接存儲到此位置。若此位置
* 已有對象存儲，再通過equals()比較這兩個對象是否相同。如果相同，後一個對象就不能再添加進來。 萬一返回false呢，都存儲。（不建議如此）
* >要求：hashCode()方法要與equals()方法一致。


LinkedHashSet:

LinkedHashSet是 HashSet的子類

使用鏈表維護了一個添加進集合中的順序。導致當我們遍歷LinkedHashSet集合元素時，是按照添加進去的順序遍歷的！
LinkedHashSet根據元素的 hashCode值來決定元素的存儲位置，但它同時使用鏈表維護元素的次序，這使得元素看起來是以插入順序保存的
LinkedHashSet插入性能略低於 HashSet（因爲得維護鏈表的結構），但在迭代訪問 Set 裏的全部元素時有很好的性能（）。

TreeSet: 不是HashSet的子類，是Set的實現類。
1.向TreeSet中添加的元素必須是同一個類的。
     * 2.可以按照添加進集合中的元素的指定的順序遍歷。像String，包裝類等默認按照從小到大的順序遍歷。
     * 3.當向TreeSet中添加自定義類的對象時，有兩種排序方法：①自然排序②定製排序
     * 4.自然排序：要求自定義類實現java.lang.Comparable接口並重寫其compareTo(Object obj)的抽象方法
     * 在此方法中，指明按照自定義類的哪個屬性進行排序。
     //當向TreeSet中添加Person類的對象時，依據此方法，確定按照哪個屬性排列。
public class Person implements Comparable
    @Override
    public int compareTo(Object o) {
        if(o instanceof Person){
            Person p = (Person)o;
            //return this.name.compareTo(p.name);
            //return -this.age.compareTo(p.age);
            int i = this.age.compareTo(p.age);
            if(i == 0){
                return this.name.compareTo(p.name);
            }else{
                return i;
            }
        }
        return 0;
    }
     *
     * 5.向TreeSet中添加元素時，首先按照compareTo()進行比較，一旦返回0，雖然僅是兩個對象的此
     * 屬性值相同，但是程序會認爲這兩個對象是相同的，進而後一個對象就不能添加進來。
     * 6，添加元素時，先compareTo（），如果return 0，則不添加，如果return的不是0，再hashcode（）和equals方法比較。
     * >要求compareTo()與hashCode()以及equals()三者保持一致！


     * TreeSet的定製排序： 見下面的步驟 compare()與hashCode()以及equals()三者保持一致！
     */
    @Test
    public void testTreeSet2() {
        // 1.創建一個實現了Comparator接口的類對象
        Comparator com = new Comparator() {
            // 向TreeSet中添加Customer類的對象，在此compare()方法中，指明是按照Customer
            // 的哪個屬性排序的。
            @Override
            public int compare(Object o1, Object o2) {
                if (o1 instanceof Customer && o2 instanceof Customer) {
                    Customer c1 = (Customer) o1;
                    Customer c2 = (Customer) o2;
                    int i = c1.getId().compareTo(c2.getId());
                    if (i == 0) {
                        return c1.getName().compareTo(c2.getName());
                    }
                    return i;
                }
                return 0;
            }
        };
        // 2.將此對象作爲形參傳遞給TreeSet的構造器中
        TreeSet set = new TreeSet(com);
        // 3.向TreeSet中添加Comparator接口中的compare方法中涉及的類的對象。
        set.add(new Customer("AA", 1003));
        set.add(new Customer("BB", 1002));
        set.add(new Customer("GG", 1004));
        set.add(new Customer("CC", 1001));
        set.add(new Customer("DD", 1001));

        for (Object str : set) {
            System.out.println(str);
        }
    }

Map接口：

Map與Collection並列存在。用於保存具有映射關係的數據:Key-Value

Map 中的 key 和  value 都可以是任何引用類型的數據

Map 中的 key 用Set來存放，不允許重複，即同一個 Map 對象所對應的類，須重寫hashCode()和equals()方法。

常用String類作爲Map的“鍵”。

key 和 value 之間存在單向一對一關係，即通過指定的 key 總能找到唯一的、確定的 value

 HashMap： 1.key是用Set來存放的，不可重複。value是用Collection來存放的，可重複
     * 一個key-value對，是一個Entry。所有的Entry是用Set存放的，也是不可重複的。
     * 2.向HashMap中添加元素時，key是用set來存儲的。先根據hashcode（）判斷，在根據equals判斷，跟set的判斷一樣，若相同 則只能添加進後添加的那個元素（會被後面這個覆蓋）。
例如：
        map.put(new Person("zhangsan",45), 123);
        map.put(new Person("zhangsan",45), 789);//Person類重寫了hashCode，equals方法，下面的value爲789的會覆蓋之前的value爲123。

Map的遍歷：
方法一：
Set keySet = map.keySet();
        for (Object object : keySet) {
            System.out.println(object+"---->"+map.get(object));
        }
方法二：
Set entrySet = map.entrySet();
        for (Object object : entrySet) {
            Map.Entry entry=(Entry) object;
            System.out.println(entry.getKey()+"---->"+entry.getValue());
        }

Map接口的常用實現類：HashMap、TreeMap和Properties。

HashMap是Map接口使用頻率最高的實現類。

允許使用null鍵和null值，與HashSet一樣，不保證映射的順序。

HashMap判斷兩個key 相等的標準是：hashCode值相等，兩個key通過 equals()方法返回true。

HashMap判斷兩個value相等的標準是：兩個value通過 equals()方法返回 true。

LinkedHashMap是HashMap的子類

與LinkedHashSet類似，LinkedHashMap可以維護Map的迭代順序：迭代順序與Key-Value對的插入順序一致

TreeMap存儲Key-Value 對時，需要根據key-value對進行排序。TreeMap可以保證所有的Key-Value對處於有序狀態。

TreeMap的Key的排序：

自然排序：TreeMap的所有的Key必須實現 Comparable接口，而且所有的 Key應該是同一個類的對象，否則將會拋出 ClasssCastException

定製排序：創建TreeMap時，傳入一個Comparator對象，該對象負責對TreeMap中的所有key進行排序。此時不需要 Map的 Key實現Comparable 接口

TreeMap判斷兩個key相等的標準：跟treeSet一致。

Hashtable是個古老的Map實現類，線程安全。

與HashMap不同，Hashtable不允許使用null作爲 key 和value

與HashMap一樣，Hashtable也不能保證其中Key-Value對的順序

Hashtable判斷兩個key相等、兩個value相等的標準，與hashMap一致。

Properties 類是Hashtable的子類，該對象用於處理屬性文件

由於屬性文件裏的 key、value都是字符串類型，所以Properties裏的key和 value 都是字符串類型

存取數據時，建議使用setProperty(Stringkey,String value)方法和getProperty(String key)方法

•Properties pros = new Properties();

•pros.load(newFileInputStream("jdbc.properties"));

•String user = pros.getProperty("user");

•System.out.println(user);

操作集合的工具類Collections：

        reverse(List)：反轉 List 中元素的順序
        sort(List)：根據元素的自然順序對指定 List 集合元素按升序排序
        sort(List，Comparator)：根據指定的 Comparator 產生的順序對 List 集合元素進行排序
        swap(List，int， int)：將指定 list 集合中的 i 處元素和 j 處元素進行交換

        Object max(Collection)：根據元素的自然順序，返回給定集合中的最大元素
        Object max(Collection，Comparator)：根據 Comparator 指定的順序，返回給定集合中的最大元素
        Object min(Collection)
        Object min(Collection，Comparator)
        int frequency(Collection,Object)：返回指定集合中指定元素的出現次數

Collections 類中提供了多個 synchronizedXxx() 方法，該方法可使將指定集合包裝成線程同步的集合，從而可以解決多線程併發訪問集合時的線程安全問題