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

目錄

• 1.集合
  • 1.1.集合是什麼
  • 1.2.集合框架結構
    • 1.2.1.Collection
    • 1.2.2.Map
  • 1.3.集合接口實現類
    • 1.3.1.LinkedList
    • 1.3.2.ArrayList
    • 1.3.3.HashSet
    • 1.3.4.TreeSet
    • 1.3.5.HashMap
    • 1.3.6.TreeMap
• 2.泛型

1.集合

1.1.集合是什麼

以前的基礎篇中咱們知道了一種數據結構：數組，能夠存放不少數據。可是數據有很大的侷限性：

• 支持的數據類型單一
• 聲明時須要指定大小，大小固定，可擴展性差
• 連續的存儲單元，對內存要求苛刻

那麼是否有其餘的數據結構或者數據類型用於存儲數據以解決數組的侷限性呢，集合框架就是如此，也稱爲容器。

1.2.集合框架結構

集合類型可分爲Collection和Map。

1.2.1.Collection

Collection的結構圖以下：複雜繼承和接口實現

	接口名	描述與做用
	Iterator	迭代器，以前在說加強for循環中有提到過迭代器，是Collection的父接口
	Collection	是List、Set和Queue的父接口，存儲一組不惟1、無序的對象，通常使用其子接口實現類進行操做數據
	List	可經過索引獲取對象，存儲一組不惟1、有序的對象
	Set	存儲一組惟1、無序的對象
	Queue	隊列接口

1.2.2.Map

Map地結構圖以下：

	接口名	描述與做用
	Map	存儲key-value的一組鍵值對象

1.3.集合接口實現類

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

1.3.1.LinkedList

實現了List接口和Queue接口，即存儲一組不惟1、容許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接口，存儲一組不惟1、容許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) {
        Map<String, Integer> hashMap = new HashMap<>();
        hashMap.put("zhangsan", 20);
        hashMap.put("lisi", 33);
        hashMap.put("zhangsan", 22);
        hashMap.put("wanger", 15);
        hashMap.put("wanger2", null);

        for (Map.Entry<String, Integer> entry : hashMap.entrySet()) {
            System.out.println("key=" + entry.getKey() + ", value=" + entry.getValue());
        }
        System.out.println("----------------");

        hashMap.remove("zhangsan");
        for (Map.Entry<String, Integer> entry : hashMap.entrySet()) {
            System.out.println("key=" + entry.getKey() + ", value=" + entry.getValue());
        }
    }
}

執行結果：

1.3.6.TreeMap

實現了SortedMap接口，故名思意是有序的，key有序、不可爲null、不可重複。是線程不安全的。
例子：

public class TestTreeMap {
	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("-------------------");
        }
}

執行結果：