1三、Java的集合

數組和集合的區別：

一、數組的長度是固定的，集合的長度是可變的

二、數組中存儲的是同一類型的元素，能夠存儲基本數據類型值。集合存儲的都是對象，並且對象的類型能夠不一致。

 

Collection：因此單列集合的父接口，定義了單列集合通用的一些方法

示例代碼：

public class Demo {
    public static void main(String [] args) {
        Collection<String> coll = new ArrayList<>();
        System.out.println(coll);

        boolean b1=coll.add("讀者A");
        boolean b2=coll.add("讀者B");
        System.out.println(coll);

        boolean b3=coll.remove("讀者C");
        boolean b4=coll.remove("讀者B");
        boolean b5=coll.contains("讀者A");
        boolean b6=coll.isEmpty();
        System.out.println(b1);
        System.out.println(b2);
        System.out.println(b3);
        System.out.println(b4);
        System.out.println(b5);
        System.out.println(b6);
        System.out.println(coll.size());
        System.out.println(coll.toArray()[0]);

    }
}

iterator ：迭代器接口，迭代，就是collection集合元素的通用獲取方式。在取元素以前先要判斷集合中有沒有元素，若是有，就把這個元素取出來，繼續判斷，若是還有就再取出來，一直到集合中的全部元素都取出。

示例代碼：

public class Demo {
    public static void main(String [] args) {
        Collection<String> coll = new ArrayList<>();
        System.out.println(coll);

        boolean b1=coll.add("讀者A");
        boolean b2=coll.add("讀者B");
        Iterator<String> it = coll.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
}

加強for循環：底層使用迭代器，使用for循環的格式，簡化迭代器書寫，用來遍歷集合和數組

格式 ： for（集合/數組的數據類型 變量名 ： 集合名/數組名）{方法體}

示例代碼：

public class Demo {
    public static void main(String [] args) {
        Collection<String> coll = new ArrayList<>();
        System.out.println(coll);

        boolean b1=coll.add("讀者A");
        boolean b2=coll.add("讀者B");
        for (String str:coll) {
            System.out.println(str);
        }
    }
}

注意：加強for循環的目標只能是集合或者數組

 

泛型：是一種未知的數據類型，當咱們不知道使用什麼數據類型的時候，可使用泛型 E e :Element 元素 ，T t :Type 類型

 

建立集合，不使用泛型：

好處：集合不使用泛型，默認類型就是Object類型，能夠存儲任意類型的數據

壞處：不安全，容易引起異常

建立集合，使用泛型：

好處：一、避免了類型轉換的麻煩，存儲的是什麼數據，取出的就是什麼類型

         二、把運行期間的異常提高到了編譯期間

壞處：泛型是什麼類型，只能存儲什麼類型的數據

 

定義一個泛型的類：修飾符 class 類名<表明泛型的變量>{}

定義一個泛型的方法： 修飾符 <泛型> 返回值類型 方法名 （參數列表（使用泛型））{方法體}，含有泛型的方法在調用方法的時候肯定泛型的數據類型，參數傳遞什麼類型，泛型就是什麼類型

定義一個泛型的接口： 修飾符 interface 接口名<泛型>{}

含義泛型的接口的使用方式：一、定義接口的實現類，實行接口，指定接口的泛型

                                       二、接口使用什麼泛型，實現類就使用什麼泛型

 

泛型通配符：當使用泛型類或者接口時，傳遞的數據中，泛型的類型不肯定，能夠經過通配符<?>表示。可是一旦使用了泛型通配符後，只能使用Object類中的共性方法，集合中的元素自身方法沒法使用

示例代碼

public class Demo {
    public static void main(String[] args){}
    
    private class Demo2<E>{
        private E name;

        public E getName() {
            return name;
        }

        public void setName(E name) {
            this.name = name;
        }
        
        public <M> void method(M m){
            
        }
        
        public void printArray(ArrayList<?> list){
            Iterator<?>it = list.iterator();
            while (it.hasNext()){
                System.out.println(it.next());
            }
        }
    }
}

List接口：一、他是一個元素存取有序的集合

              二、他是一個帶有索引的集合

              三、集合中能夠有重複的元素

注意：要防止索引的越界異常

示例代碼

public class Demo {
    public static void main(String[] args){
        List<String> list =new ArrayList<>();
        list.add("讀者A");
        list.add("讀者B");
        list.add("讀者A");
        System.out.println(list);
        list.add(1,"讀者C");
        System.out.println(list);
        list.remove(1);
        System.out.println(list);
        list.set(1,"讀者D");
        System.out.println(list);
    }
}

ArrayList：前面已經用過，再也不講述，底層是數組數據結構

LinkedList：鏈表數據結構

示例代碼

public class Demo {
    public static void main(String[] args){
       LinkedList<String> list = new LinkedList<>();
       list.add("讀者A");
       list.add("讀者B");
       list.add("讀者A");
        System.out.println(list);
       list.addFirst("讀者C");
        System.out.println(list);
        list.addLast("讀者D");
        System.out.println(list);
        list.push("讀者E");
        System.out.println(list);
        list.pop();
        System.out.println(list);
        System.out.println(list.getFirst());
        System.out.println(list.getLast());
        list.removeFirst();
        list.removeLast();
    }
}

Vector：底層是數組數據結構，如今多用ArrayList代替使用

 

Set接口類：一、不容許存儲重複的元素

                二、沒有索引，沒有帶索引的方法，也不能使用普通的for循環遍歷

 

HashSet實現類：一、不容許存儲重複的元素

                        二、沒有索引，沒有帶索引的方法，也不能使用普通的for循環遍歷

                        三、是一個無序的集合，存儲元素和取出元素的順序有可能不一致

                        四、底層是一個哈希表結構（查詢的速度很是的快）

示例代碼：

public class Demo {
    public static void main(String[] args){
       Set<Integer> set = new HashSet<>();
       set.add(96);
       set.add(97);
       set.add(98);
       set.add(99);
       set.add(100);
       set.add(97);
        System.out.println(set);
       Iterator it = set.iterator();
       while (it.hasNext()){
           System.out.println(it.next());
       }
    }
}

擴展：哈希值，是一個十進制的整數，由系統隨機給出（就是對象的地址值，是一個邏輯地址，是模擬出來獲得地址，不是數據實際存儲的物理地址）

注意：使用HashSet存儲自定義類型的元素時，要重寫hashCode和equals方法

 

LinkedHashSet:HashSet的子類，元素不能夠重複，可是有序，底層是一個哈希表+鏈表

示例代碼：

public class Demo {
    public static void main(String[] args){
       LinkedHashSet<Integer> set = new LinkedHashSet<>();
       set.add(96);
       set.add(97);
       set.add(98);
       set.add(99);
       set.add(97);
        System.out.println(set);
        Iterator it = set.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
}

 可變參數：當方法的參數列表數據類型已經肯定，可是參數的個數不肯定，就可使用可變參數 ， 修飾符 返回值類型 方法名（數據類型...變量名）{},可變參數底層就是一個數組，根據傳遞的參數個數不一樣，會建立不一樣長度的數組，來存儲這些參數。

public class Demo {
    public static void main(String[] args){
        System.out.println(sum(1,2,3));
        System.out.println(sum(1,2));
    }

    public static int sum (int...a){
        int sum =0;
        for (int b:a) {
            sum+=b;
        }
        return sum;
    }
}

Collections：操做集合的工具類，對集合進行操做

示例代碼：

public class Demo {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(96);
        list.add(97);
        list.add(98);
        list.add(99);
        list.add(100);
        Collections.shuffle(list);
        System.out.println(list);
        Collections.sort(list);
        System.out.println(list);
    }
}

Map集合接口：一、Map集合是一個雙列集合，一個元素包含兩個值（Key，Value）

               二、Map集合中的元素，Key和Value的數據類型能夠相同也能夠不一樣

               三、Map集合中的元素，Key是不容許重複的，Value是能夠重複的

               四、Map集合中的元素，Key和Value是一一對應的

HashMap<K,V>，Map接口的實現類：一、底層是哈希表，查詢速度快

                                                    二、是一個無序的集合，存儲元素和取出元素的順序不一致

LinkedHashMap<K,V>，HashMap的子類：一、底層是哈希表+鏈表

                                                           二、集合是一個有序的集合，存儲元素和取出元素的順序一致

Map接口的示例代碼

public class Demo {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();
        map.put("讀者A","做品A");
        map.put("讀者B","做品B");
        map.put("讀者C","做品C");
        map.put("讀者D","做品D");
        System.out.println(map);
        map.remove("讀者D");
        System.out.println(map);
        System.out.println(map.get("讀者A"));
        System.out.println(map.containsKey("讀者A"));

        Set<String> set =map.keySet();
        Iterator<String> it1 = set.iterator();
        while(it1.hasNext()){
            String str = it1.next();
            System.out.println(map.get(str));
        }

        Set<Map.Entry<String,String >> set2 = map.entrySet();
        Iterator<Map.Entry<String ,String >> it2 = set2.iterator();
        while (it2.hasNext()){
            Map.Entry<String ,String > entry = it2.next();
            System.out.println(entry.getKey()+"="+entry.getValue());
        }




    }
}