10.集合框架

落落的学习發表於2024-05-06
框架

1.Collection

1.1.List

1.1.1.ArrayList 類

基於陣列演算法的列表，底層其實就是一個 Object 陣列
常用方法的 API：

方法名 作用 呼叫語法
add(E e) 新增元素，E 是建立集合時定義的泛型，新增的元素的型別就是傳入的這個泛型型別 集合物件.add(E e)
remove(int index)、remove(Object 0) 刪除元素，第一個方法是根據元素的索引刪除；第二個方法時直接根據元素的內容刪除元素，第二個方法時 List 集合的父類 collection 中的方法 集合物件.remove(int index)
set(int index, E e) 修改元素，第一個形參就是需要修改的元素索引，第二個集合物件.形參就是修改後的值 集合物件.set(int index, E e)
get(int index) 根據索引獲取元素 集合物件.get(int index)
size() 獲取集合的長度 集合物件.size()
isEmpty() 判斷集合是否為空 集合物件.isEmpty()
contains(Object o) 判斷集合是否包含目標元素 集合物件.contains(Object o)
toArray() 將集合轉換為陣列 集合物件.toArray() 
public class ArrayListDemo1 {
    public static void main(String[] args) {
        // 建立一個預設長度的列表物件
        List list = new ArrayList();
        // 列印集合中元素的個數
        System.out.println("元素數量："+list.size());//0
        // 新增操作：向列表中新增4個元素
        list.add("Will");
        list.add(100);
        list.add(true);
        list.add("Lucy");
        // 查詢操作:
        System.out.println("列表中所有元素："+list);//輸出:[Will, 100, true, Lucy]
        System.out.println("元素數量："+list.size());//4
        System.out.println("第一個元素："+list.get(0));//Will
        
        // 修改操作：把索引為2的元素，替換為wolfcode
        list.set(2, "wolfcode");
        System.out.println("修改後："+list);//輸出:[Will, 100, wolfcode, Lucy]
        // 刪除操作：刪除索引為1的元素
        list.remove(1);
        System.out.println("刪除後："+list);//輸出:[Will, wolfcode, Lucy]
    }
}

1.1.2.LinkedList 類

底層採用連結串列演算法，實現了連結串列、佇列、棧的資料結構。無論是連結串列還是佇列，主要操作的都是頭和尾的元素。
LinkedList 常用方法的 API：

方法名 作用 呼叫語法
addFirst() 從連結串列的開頭處新增元素 物件.addFirst()
addLast() 從連結串列的結尾處新增元素 物件.addLast()
getFirst() 獲取到連結串列開頭處的第一個元素 物件.getFirst()
getLast() 獲取到連結串列結尾處的最後一個元素 物件.getLast()
removeFirst() 刪除連結串列開頭處的第一個元素 物件.removeFirst()
removeLast() 刪除連結串列結尾處的最後一個元素 物件.removeLast()

其餘方法

boolean offerFirst(Object e) 在此列表的開頭插入指定的元素。
boolean offerLast(Object e) 在此列表末尾插入指定的元素。
Object peekFirst() 獲取但不移除此列表的第一個元素；如果此列表為空，則返回 null。
Object peekLast() 獲取但不移除此列表的最後一個元素；如果此列表為空，則返回 null。
Object pollFirst() 獲取並移除此列表的第一個元素；如果此列表為空，則返回 null。
Object pollLast() 獲取並移除此列表的最後一個元素；如果此列表為空，則返回 null。
void push(Object e) 將元素推入此列表所表示的棧。
Object pop() 從此列表所表示的棧處彈出一個元素。
Object peek() 獲取但不移除此列表的頭（第一個元素）。

public class LinkedListDemo {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        //新增元素
        list.addFirst("A");
        list.addFirst("B");
        System.out.println(list);
        list.addFirst("C");
        System.out.println(list);
        list.addLast("D");
        System.out.println(list);
        //獲取元素
        System.out.println("獲取第一個元素：" + list.getFirst());//C
        System.out.println("獲取最後一個元素：" + list.getLast());//D
        //刪除元素
        list.removeFirst();
        System.out.println("刪除第一個元素後：" + list);//[B, A, D]
        list.removeLast();
        System.out.println("刪除最後一個元素後：" + list);//[B, A]
    }
}

//結果
[B, A]
[C, B, A]
[C, B, A, D]
獲取第一個元素：C
獲取最後一個元素：D
刪除第一個元素後：[B, A, D]
刪除最後一個元素後：[B, A]

1.2.Set

特點：

  • 不允許元素重複
  • 不會基類元素的新增先後順序

Set 只包含從 Collection 繼承的方法，當試圖新增兩個相同元素進 Set 集合，新增操作失敗，add() 方法返回 false
常用的實現類：

  • HashSet 類：底層採用雜湊表實現，開發中使用最多的實現類
  • TreeSet 類：底層採用紅黑樹實現，可以對集合中元素排序，使用不對

HashSet 和 TreeSet 類的 API 都是一樣的

方法名 作用 呼叫語法
add(E e) 新增元素，E 是建立集合時定義的泛型，新增的元素的型別就是傳入的這個泛型型別 集合物件.add(E e)
remove(int index)、remove(Object 0) 刪除元素，第一個方法是根據元素的索引刪除；第二個方法時直接根據元素的內容刪除元素，第二個方法時 List 集合的父類 collection 中的方法 集合物件.remove(int index)
set(int index, E e) 修改元素，第一個形參就是需要修改的元素索引，第二個集合物件.形參就是修改後的值 集合物件.set(int index, E e)
get(int index) 根據索引獲取元素 集合物件.get(int index)
size() 獲取集合的長度 集合物件.size()
isEmpty() 判斷集合是否為空 集合物件.isEmpty()
contains(Object o) 判斷集合是否包含目標元素 集合物件.contains(Object o)
toArray() 將集合轉換為陣列 集合物件.toArray()

1.2.1.HashSet 類

是 Set 介面的實現類，底層資料結構是雜湊表，集合容器不吉利元素的新增順序，也不允許元素重複。通常也說 HashSet 中的元素是無序的、唯一的

public class HashSetDemo {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        //新增操作：向列表中新增4個元素
        set.add("Will");
        set.add("wolf");
        set.add("code");
        set.add("Lucy");
        
        //查詢操作:
        System.out.println("集合中所有元素：" + set);//[code, wolf, Will, Lucy]
        System.out.println("元素數量：" + set.size());//4
        System.out.println("是否存在某個元素：" + set.contains("code"));//true
        System.out.println("是否存在某個元素：" + set.contains("code2"));//false
        
        //刪除操作：刪除code元素
        set.remove("code");
        System.out.println("刪除後：" + set);//[wolf, Will, Lucy]
        
        //使用for-each遍歷
        for (String ele : set) {
            System.out.println(ele);
        }
        
        //使用迭代器遍歷
        Iterator<String> it = set.iterator();
        while (it.hasNext()) {
            Object ele = it.next();
            System.out.println(ele);
        }
    }
}

1.2.2.TreeSet 類

其底層才有紅黑樹演算法，會對儲存的元素物件預設使用自然排序（從小到大）
注意：必須保證 TreeSet 集合中的元素物件是相同的資料型別，否則報錯

public class TreeSetDemo{
    public static void main(String[] args) {
        Set<String> set = new TreeSet<>();
        set.add("wolf");
        set.add("will");
        set.add("sfef");
        set.add("allen");
        System.out.println(set);// [allen, sfef, will, wolf]
    }
}

2.Map

Map 常用的 API：
新增操作

boolean put(Object key,Object value)：儲存一個鍵值對到Map中
boolean putAll(Map m)：把m中的所有鍵值對新增到當前Map中

刪除操作

Object remove(Object key)：從Map中刪除指定key的鍵值對，並返回被刪除key對應的value

修改操作

無專門的方法，可以呼叫put方法，儲存相同key，不同value的鍵值對，可以覆蓋原來的。

查詢操作

int size()：返回當前Map中鍵值對個數
boolean isEmpty()：判斷當前Map中鍵值對個數是否為0.
Object get(Object key)：返回Map中指定key對應的value值，如果不存在該key，返回null
boolean containsKey(Object key):判斷Map中是否包含指定key
boolean containsValue(Object value):判斷Map中是否包含指定value
Set keySet()：返回Map中所有key所組成的Set集合
Collection values()：返回Map中所有value所組成的Collection集合
Set entrySet()：返回Map中所有鍵值對所組成的Set集合

2.1.HashMap

HashMap底層基於雜湊表演算法，Map中儲存的key物件的hashCode值決定了在雜湊表中的儲存位置，因為Map中的key是Set，所以不能保證新增的先後順序，也不允許重複。
HashMap key的底層資料結構是雜湊表

案例： 統計一個字串中每個字元出現次數

public class HashMapDemo2{
    public static void main(String[] args) {
        String str = "ABCDEFABCDEABCDABCABA";
        //把字串轉換為char陣列
        char[] charArray = str.toCharArray();
        //Map的key儲存字元，value儲存出現的次數
        Map<Character, Integer> map = new HashMap<>();
        //迭代每一個字元
        for (char ch : charArray) {
            //判斷Map中是否已經儲存該字元
            if (map.containsKey(ch)) {
                Integer count = map.get(ch);
                //如果已經儲存該字元，則把出現次數加上1
                map.put(ch, count+1);
            }else {
                //如果沒有儲存該字元，則把設定次數為1
                map.put(ch, 1);
            }
        }
        System.out.println(map); 
    }
}

2.2.TreeMap

TreeMap key底層基於紅黑樹演算法，因為Map中的key是Set，所以不能保證新增的先後順序，也不允許重複，但是Map中儲存的key會預設使用自然排序（從小到大），和TreeSet一樣，除了可以使用自然排序也可以自定義排序。

需求：測試HashMap和TreeMap中key的順序

public class App {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        map.put("girl4", "楊玉環");
        map.put("girl2", "王昭君");
        map.put("key1", "西施");
        map.put("key3", "貂蟬");
        System.out.println(map);
        //-------------------------------------------
        map = new TreeMap<>(map);
        System.out.println(map);
    }
}

結果：
{key1=西施, girl4=楊玉環, key3=貂蟬, girl2=王昭君}
{girl2=王昭君, girl4=楊玉環, key1=西施, key3=貂蟬}

3.集合元素變數

對集合中的每一個元素獲取出來

List<String> list = new ArrayList<>();
list.add("西施");
list.add("王昭君");
list.add("貂蟬");
list.add("楊玉環");


使用for遍歷

for (int index = 0; index < list.size(); index++) {
    String ele = list.get(index);
    System.out.println(ele);
}

使用迭代器遍歷
Iterator表示迭代器物件，迭代器中擁有一個指標，預設指向第一個元素之前，

  • boolean hasNext()：判斷指標後是否存在下一個元素
  • Object next()：獲取指標位置下一個元素，獲取後指標向後移動一位
Iterator<String> it = list.iterator();
while(it.hasNext()) {
    String ele = it.next();
    System.out.println(ele);
}

使用 for-each 遍歷（推薦使用）

for (String ele : list) {
    System.out.println(ele);
}

for-each操作集合時，其實底層依然是Iterator

相關文章