Java進階學習之集合與泛型（1）

liquorppp發表於2020-12-08
Java泛型

目錄

1.集合

1.1.集合是什麼

之前的基礎篇中我們知道了一種資料結構：陣列，可以存放很多資料。但是資料有很大的侷限性：

  • 支援的資料型別單一
  • 宣告時需要指定大小，大小固定，可擴充套件性差
  • 連續的儲存單元，對記憶體要求苛刻

那麼是否有其他的資料結構或者資料型別用於儲存資料以解決陣列的侷限性呢，集合框架就是如此，也稱為容器。

1.2.集合框架結構

集合型別可分為Collection和Map。

1.2.1.Collection

Collection的結構圖如下：複雜繼承和介面實現

介面名 描述與作用
Iterator 迭代器，之前在說增強for迴圈中有提到過迭代器，是Collection的父介面
Collection 是List、Set和Queue的父介面，儲存一組不唯一、無序的物件，一般使用其子介面實現類進行運算元據
List 可通過索引獲取物件，儲存一組不唯一、有序的物件
Set 儲存一組唯一、無序的物件
Queue 佇列介面
1.2.2.Map

Map地結構圖如下：

介面名 描述與作用
Map 儲存key-value的一組鍵值物件

1.3.集合介面實現類

接下我會選出常用的實現類進行解析。

1.3.1.LinkedList

實現了List介面和Queue介面，即儲存一組不唯一、允許null，有序的物件，並且也可作為佇列使用。採用連結串列結構進行實現，便於集合的插入和刪除元素，訪問元素相對較慢。由於其實現方法沒有synchronized關鍵字修飾，所以是執行緒不安全的。
例1（正常）：

public class TestLinkedList1 {
      public static void main(String[] args) {
            List<String> linkedList = new LinkedList<>();
            //新增元素
            linkedList.add("zhangsan");
            linkedList.add("lisi");
            linkedList.add(null);
            linkedList.add(null);
        
            //通過索引獲取物件
            System.out.println(linkedList.get(0));
            System.out.println("------------------");
            //使用增強for迴圈遍歷迭代器
            for (String name : linkedList) {
                  System.out.println(name);
            }
            System.out.println("------------------");
            //刪除元素
            linkedList.remove(null);
            for (String name : linkedList) {
                  System.out.println(name);
            }
      }
}

執行結果：

例2（當作佇列）：

public class TestLinkedList2 {
	public static void main(String[] args) {
		Queue<String> queue = new LinkedList<>();
        //新增元素
        queue.add("zhangsan");
        queue.add("lisi");

        System.out.println(queue.peek());

        //刪除元素
        String name = queue.poll();
        System.out.println(name);
        }
}

執行結果：

遵循佇列的先進先出原則。

1.3.2.ArrayList

實現了List介面，儲存一組不唯一、允許null，有序的物件。採用大小可變的陣列實現，可進行快速的隨機訪問，即索引訪問，但是插入和刪除元素較為費時。初始大小為10，也可使用構造器指定大小建立。和LinkedList一樣是執行緒不安全的。
例子：

public class TestArrayList {
	public static void main(String[] args) {
		List<String> list = new ArrayList<>();
        list.add("zhangsan");
        list.add("lisi");
        list.add("lisi");

        System.out.println(list.get(0));
        System.out.println("--------------");

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

        System.out.println("--------------");

        list.remove("lisi");
        for (String name : list) {
            System.out.println(name);
        }
        }
}

執行結果：

1.3.3.HashSet

實現了Set介面，即儲存一組唯一的、無序的、可以為null的物件。由於使用hash演算法儲存集合元素，因此具有很好的存取和查詢的新娘功能。是執行緒不安全的。

public class TestHashSet {
	public static void main(String[] args) {
		Set<String> hashSet = new HashSet<>();
        hashSet.add("zhangsan");
        hashSet.add("zhangsan");
        hashSet.add("lisi");

        System.out.println(hashSet.size());
        System.out.println(hashSet.contains("lisi"));
        System.out.println("-------------------");

        for (String name : hashSet) {
            System.out.println(name);
        }

        System.out.println("-------------------");
        hashSet.remove("zhangsan");
        for (String name : hashSet) {
            System.out.println(name);
        }
        }
}

執行結果：

1.3.4.TreeSet

實現了SortedSet介面（該介面繼承Set介面），即儲存一組唯一的、有序的物件，這裡的有序是有條件的，物件需要實現Comparable介面。是執行緒不安全的。
我們發現Comparable介面中只有一個方法public int compareTo(T o);，則返回物件實現該方法即可。如果當前物件小於、等於和大於方法中的物件，返回負整數、零和正整數。
例子：

public class Person implements Comparable {
    private String name;
    private int age;
    
    public Person(){}
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Person o) {
        if (this.age > o.getAge()) {
            return 1;
        } else if (this.age == o.getAge()) {
            return 0;
        } else {
            return -1;
        }
    }
}

public class TestTreeSet {
	public static void main(String[] args) {
		TreeSet<Person> treeSet = new TreeSet<>();
        treeSet.add(new Person("zhangsan", 20));
        treeSet.add(new Person("lisi", 33));
        treeSet.add(new Person("zhangsan2", 20));
        treeSet.add(new Person("wanger", 15));

        for (Person p : treeSet) {
            System.out.println(p);
        }
        System.out.println("----------------");

        treeSet.remove(new Person("lisi2", 33));
        for (Person p : treeSet) {
            System.out.println(p);
        }
	}
}

執行結果：

我們使用Person類的age屬性作為比較的依據，相同age的即相同物件。當我們插入資料時，會按照age進行升序排列；當刪除元素時，按照age相等的進行刪除。

1.3.5.HashMap

實現了Map介面，即鍵值對儲存物件，key不可重複，無序，使用hash演算法進行儲存元素，相同key進行插入時會覆蓋原有的值。是執行緒不安全的。
例子：

public class TestHashMap {
	public static void main(String[] args) {
		TreeSet<Person> treeSet = new TreeSet<>();
        treeSet.add(new Person("zhangsan", 20));
        treeSet.add(new Person("lisi", 33));
        treeSet.add(new Person("zhangsan2", 20));
        treeSet.add(new Person("wanger", 15));

        for (Person p : treeSet) {
            System.out.println(p);
        }
        System.out.println("----------------");

        treeSet.remove(new Person("lisi2", 33));
        for (Person p : treeSet) {
            System.out.println(p);
        }
	}
}

執行結果：

1.3.6.TreeMap

實現了SortedMap介面，故名思意是有序的，key有序、不可為null、不可重複。是執行緒不安全的。
例子：

public class TestHashMap {
	public static void main(String[] args) {
		Map<String, String> map = new TreeMap<>();
        map.put("zhangsan", "aaaa");
        map.put("lisi", "bbbb");
        map.put("zhangsan", "cccc");

        for (String name : map.keySet()) {
            System.out.println(map.get(name));
        }
        System.out.println("----------------");

        map.remove("lisi");
        for (String name : map.keySet()) {
            System.out.println(map.get(name));
        }
	}
}

執行結果：

2.泛型

集合框架的優勢在於元素通用性。在之前的集合中我們已經遇到了泛型，在Map<String, String> map = new TreeMap<>();中map的key指定為String類，value也指定String類，在TreeMap類定義中public class TreeMap<K,V>這裡的K和V就是泛型，泛型提供編譯時型別安全檢測機制。
例子：

public class TestHashMap {
	public static void main(String[] args) {
		Integer[] arr1 = {1,2,3,4,5};
        Double[] arr2 = {1.1,2.2,3.3,4.4,5.5};
        String[] arr3 = {"zhangsan", "lisi", "wanger"};

        printArray(arr1);
        printArray(arr2);
        printArray(arr3);
	}
	static <E> void printArray(E[] array) {
        for (E e : array) {
            System.out.println(e);
        }
        System.out.println("-------------------");
        }
}

執行結果：

相關文章