Java基礎之集合-有解無憂

集合 java.util.Collection \ java.util.Iterator \ java.util.Map

集合和陣列的區別
- 陣列長度是固定的, 集合長度是可變的
- 陣列存盤同一型別的資料型別值; 集合存盤的是物件, 物件型別可以不一致

集合框架-Collection介面

介面結構

Collection介面
        |                                   1) 定義所有集合中共性的方法
        |                                   2) 底層是介面或抽象類, 無法直接創建物件, 需要使用創建子類物件使用
        |-  List介面
                |                           1) 有序
                |                           2) 允許重復元素
                |                           3) 有索引, 可使用for回圈遍歷
                |-  ArrayList集合
                |                           底層陣列實作, 查詢快, 增刪慢
                |-  LinkedList集合
                |                           底層鏈表實作, 查詢慢, 增刪快
                |-  Vector集合
        |-  Set介面
                |                           1) 不允許重復元素
                |                           2) 無索引, 不能使用普通for回圈遍歷
                |-  HashSet集合
                |                           底層哈希表實作, 存取無序; hashCode()和equals()方法保證資料元素的唯一性
                        |-LinkedHashSet集合
                        |                   底層 哈希表+鏈表 實作, 存取有序
                |-  TreeSet集合
                |                           底層 紅黑樹 實作

常用方法

boolean add(E e):    向集合中添加元素
boolean remove(E e)
void clear()
boolean contains(E e)
boolean isEmpty()
int size()
Object[] toArray():   將集合轉為陣列

集合框架-Iterator介面

Iterator迭代器
- 迭代遍歷Collection集合中的元素, 遍歷前要先判斷集合中是否有元素
- 適合無索引集合的遍歷
- Iterator是一個介面, 無法直接使用; 使用Collection介面中提供的 Iterator

常用方法

public E next():            回傳迭代的下一個元素
public boolean hasNext():   判斷集合中是否有元素, 若有元素, 回傳true

小Demo

private static Collection<String> demo1() {
    Collection<String> col = new ArrayList<>();
    col.add("lisa");
    col.add("sam");
    col.add("tom");

    Iterator<String> iterator = col.iterator(); // 多型 向下轉型
    while (iterator.hasNext()) {
        System.out.println(iterator.next());
    }
    return col;
}

增強for回圈

底層仍然是Iterator迭代器, 遍歷目標只能說集合或陣列
for (資料型別變數名 : 集合/陣列) {...}

小Demo

private static void demo2(Collection<String> col) {
    for (String str : col) {
        System.out.println(str);
    }
    System.out.println("=====================");

    int[] num = {1,2,3,4,5};
    for (int i : num) {
        System.out.println(i);
    }
}

集合框架-Map介面

特點
- Map集合是一個雙列集合, 一個元素包含兩個值(key, value)
- Map集合中key和value的資料型別可相同, 可不同
- Map集合中key不允許重復, value可重復, 并且key和value可為null值
- Map集合中key和value是一一對應的

Map介面結構

|-  HashMap
      |                   1) 底層 哈希表 實作, 存取無序, 多執行緒, 執行緒不安全
      |                   2) jdk1.8之前: 陣列 + 單向鏈表
      |                   3) jdk1.8之后: 陣列 + 單向鏈表 / 紅黑樹(長度超多8)
      |-  LinkedHashMap
      |                   1) 底層 哈希表+鏈表 實作, 存取有序
|-  TreeMap
|                         底層 紅黑樹 實作
|-  HashTable
|                         1) 底層是執行緒安全的 哈希表, 單執行緒, 速度慢, key和value值不可為null
|                         2) 其子類 Properties集合是一個唯一和IO流有結合的集合

常用方法

public V put(K key, V value):           添加鍵值對(key, value)
    若向map集合放入的key不是重復的,回傳null; 反之, 使用key對應的新value值替換原來的value值, 并回傳舊的value值
public V get(Object key):               根據key回傳value
public V remove(Object key)
    通過key洗掉鍵值對, 若key存在回傳洗掉對應的value值, 反之則回傳null
boolean containsKey(Object key)
public Set<K> keySet():                 將Map集合中所有的Key存盤到Set集合中, 然后用Set集合的方法遍歷所有的key
public Set<Map.Entry<K, V>> entrySet()  將Map集合中所有的key-value鍵值對存盤到Set集合中, 然后遍歷所有的key-value對

小Demo-Map常用方法

private static void demo8() {
    Map<Integer, String> map = new HashMap<>();
    // public V put(K key, V value)
    String mp1 = map.put(1, "lisa");
    System.out.println(mp1);    // null
    String mp2 = map.put(1, "sam");
    System.out.println(mp2);    // lisa

    map.put(2, "jerry");
    map.put(3, "sam");  // key不能重復, 但是value可以重復

    // public Set<K> keySet()
    Set<Integer> set1 = map.keySet();    // [1,2,3]
    for (Integer i : set1) {             // 增強for回圈遍歷
        System.out.println(map.get(i));
    }

    // public Set<Map.Entry<K, V>> entrySet()
    Iterator<Map.Entry<Integer, String>> it = map.entrySet().iterator();    // Iterator迭代器遍歷
    while (it.hasNext()) {
        Map.Entry<Integer, String> entry = it.next();
        Integer key = entry.getKey();
        String value = https://www.cnblogs.com/itensor/p/entry.getValue();
        System.out.println(key +"-" + value);
    }

}

小Demo-Map存盤自定義型別作為key

private static void demo9() {
    /*
        String型別作為Map集合的key
        String已經重寫了hashCode()方法和equals()方法, 保證了存入Map集合時key的唯一性
        使用keySet()方法遍歷, 運行結果:
            DivMapClass{name='Hanmeimei', age=19}
            DivMapClass{name='Linda', age=26}
            DivMapClass{name='Tomas', age=22}
     */
    Map<String, DivMapClass> map1 = new HashMap<>();
    map1.put("China", new DivMapClass("Liming", 18));
    map1.put("America", new DivMapClass("Linda", 26));
    map1.put("Germany", new DivMapClass("Tomas", 22));
    map1.put("China", new DivMapClass("Hanmeimei", 19));

    Set<String> set1 = map1.keySet();
    for (String s : set1) {
        DivMapClass divMapClass = map1.get(s);
        System.out.println(divMapClass);
    }

    /*
        自定義DivMapClass類作為Map集合的key
        DivMapClass類需要自己重寫hashCode()方法和equals()方法, 保證類作為key的唯一性
        重寫前, 使用entrySet()的Iterator迭代器遍歷, 運行結果:
            DivMapClass{name='Tomas', age=22}-Germany
            DivMapClass{name='Linda', age=26}-America
            DivMapClass{name='Liming', age=18}-China
            DivMapClass{name='Liming', age=18}-Japan
        重寫后, 使用entrySet()的增強for回圈遍歷, 運行結果:
            DivMapClass{name='Tomas', age=22}-Germany
            DivMapClass{name='Liming', age=18}-Japan
            DivMapClass{name='Linda', age=26}-America
     */
    Map<DivMapClass, String> map2 = new HashMap<>();
    map2.put(new DivMapClass("Liming", 18), "China");
    map2.put(new DivMapClass("Linda", 26), "America");
    map2.put(new DivMapClass("Tomas", 22), "Germany");
    map2.put(new DivMapClass("Liming", 18), "Japan");

//        Iterator<Map.Entry<DivMapClass, String>> it = map2.entrySet().iterator();
//        while (it.hasNext()) {
//            Map.Entry<DivMapClass, String> next = it.next();
//            DivMapClass key = next.getKey();
//            String value = https://www.cnblogs.com/itensor/p/next.getValue();
//            System.out.println(key +"-" + value);
//        }

    for (Map.Entry<DivMapClass, String> entry : map2.entrySet()) {
        DivMapClass key = entry.getKey();
        String value = https://www.cnblogs.com/itensor/p/entry.getValue();
        System.out.println(key +"-" + value);
    }
}

泛型

是一種未知的資料型別, 不知道使用什么資料型別時使用
兩種方法
- 創建集合物件時不使用泛型
  
  集合默認是Object型別, 可以存盤任意型別的資料; 不安全, 會引發例外
```
ex. ArrayList<String> list = new ArrayList<>()
```
- 創建集合物件時使用泛型
  
  集合只能存盤指定泛型型別的資料; 但是避免了型別轉換的麻煩
```
ex. ArrayList<String> list = new ArrayList<>()
```

定義一個泛型類 GenericClass

類似ArrayList, 可以直接使用指定的資料型別

小Domo

public class GenericClass<E> {
    private E variable;
    public GenericClass() {}

    public GenericClass(E variable) {
        this.variable = variable;
    }

    public E getVariable() {
        return variable;
    }

    public void setVariable(E variable) {
        this.variable = variable;
    }
}

private static void demo3() {
    GenericClass<Integer> egi = new GenericClass<>();    // 創建ExampleGeneric物件, 泛型使用Integer型別
    egi.setVariable(366);
    Integer i = egi.getVariable();
    System.out.println(i);                               // 366

    GenericClass<String> egs = new GenericClass<>();     // 創建ExampleGeneric物件, 泛型使用String型別
    egs.setVariable("hello");
    String str = egs.getVariable();
    System.out.println(str);                             // hello
}

定義一個泛型介面 GenericInterface

定義介面的實作類, 并指定介面的泛型型別
- 比如Scanner類實作了Iterator介面, 并指定介面泛型為String型別. 所以重寫的next()方法的型別默認就為String
```
ex. public final class Scanner implements Iterator<String>
```
介面使用什么泛型, 實作類就使用什么泛型. 相當于定義一個含有泛型的類, 創建物件時再確定泛型的型別
- 比如ArrayList類實作了List介面, 并直接使用List介面的泛型. 所以使用時再手動給定泛型的型別
```
ex. public class ArrayList<E> implements List<E>
```

小Demo

public class GenericInterfaceImpl1 implements GenericInterface<String> {
    @Override
    public void method(String s) {
        System.out.println(s);
    }
}

private static void demo4() {
    // 實作方法1
    GenericInterfaceImpl1 gi1 = new GenericInterfaceImpl1();
    gi1.method("字串型別");
    System.out.println("=============================");

    // 實作方法2
    GenericInterfaceImpl2<Integer> gi2 = new GenericInterfaceImpl2<>();
    gi2.method(5);
    GenericInterfaceImpl2<Double> gi3 = new GenericInterfaceImpl2<>();
    gi3.method(3.14);
}

通配符

不知道使用什么型別接收資料時, 可以使用 ? 表示未知通配符
- 不同創建物件使用, 只能作為方法的引數使用. 此時只能接收資料, 不能往集合中存盤資料

小Demo

private static void demo5() {
    ArrayList<Integer> list1 = new ArrayList<>();
    list1.add(1);
    list1.add(2);
    ArrayList<String> list2 = new ArrayList<>();
    list2.add("alex");
    list2.add("fox");

    printList(list1);                         // 作為方法的引數使用
    printList(list2);

//        ArrayList<?> list = new ArrayList<?>(); // 不能定義使用
}

private static void printList(ArrayList<?> list) {
    Iterator ie = list.iterator();
    while (ie.hasNext()) {
        System.out.println(ie.next());
    }
}

高級通配符 - 受限泛型

泛型的上限

只能接收該型別及其子型別: 型別名稱 <? extends 類> 物件名稱
泛型的下限

只能接收該型別及其父型別: 型別名稱 <? super 類> 物件名稱

小Demo

private static void demo7() {
    Collection<Integer> list1 = new ArrayList<>();
    Collection<String> list2 = new ArrayList<>();
    Collection<Number> list3 = new ArrayList<>();   // Number是Integer的父類
    Collection<Object> list4 = new ArrayList<>();   // 所有類的父類

    getElement1(list1);
//        getElement1(list2); // Error
    getElement1(list3);
//        getElement1(list4); //Error

//        getElement2(list1); //Error
//        getElement2(list2); //Error
    getElement2(list3);
    getElement2(list4);
}
// 泛型的上限: 此時的泛型 ? 必須是Number型別或者Number的子類
public static void getElement1(Collection<? extends Number> col){}
// 泛型的上限: 此時的泛型 ? 必須是Number型別或者Number的父類
public static void getElement2(Collection<? super Number> col){}

更詳細以及具體代碼實作請參考： Github: Java-Colletcion

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/13881.html

標籤：Java

上一篇：LeetCode–N 皇后

下一篇：JVM-String Tab字串常量池