集合框架：

Java中的集合框架大類可分為Collection和Map；兩者的區別：

• Collection是單列集合；Map是雙列集合

• Collection中只有Set系列要求元素唯一；Map中鍵需要唯一，值可以重復

• Collection的數據結構是針對元素的；Map的數據結構是針對鍵的。

泛型：

在說兩大集合體系之前先說說泛型，因為在后面的集合中都會用到；
所謂的泛型就是：類型的參數化

泛型是類型的一部分，類名+泛型是一個整體

如果有泛型，不使用時，參數的類型會自動提升成Object類型，如果再取出來的話就需要向下強轉，就可能發生類型轉化異常(ClassCaseException)；不加泛型就不能在編譯期限定向集合中添加元素的類型，導致后期的處理麻煩。

下面就來對比加了泛型和不加泛型的區別：

package 好好學java;import java.util.ArrayList; import java.util.Iterator; import java.util.List;public class Test {public static void main(String[] args) {// 不加泛型，添加和遍歷List list = new ArrayList<>();list.add(1);list.add("123");list.add("hello");Iterator it = list.iterator();while(it.hasNext()){// 沒有添加泛型，這里只能使用Object接收Object obj = it.next();System.out.println(obj);}}} package 好好學java;import java.util.ArrayList; import java.util.Iterator; import java.util.List;public class Test {public static void main(String[] args) {// 加泛型，添加和遍歷List<String> list = new ArrayList<String>();list.add("123");list.add("hello");Iterator<String> it = list.iterator();while(it.hasNext()){// 因為添加了泛型，就說明集合中裝的全部都是String類型的數據// 所以這里用String類型接收，就不會發生異常，并且可以使用String的方法String str = it.next();System.out.println(str.length());}}}

自定義帶泛型的類:

package 好好學java;public class Test {// 自定義一個帶有一個參數的泛型類,可以向傳入什么類型就傳入什么類型public static void main(String[] args) {// 進行測試, 傳入一個String對象Person<String> perStr = new Person<String>();perStr.setT("我是字符串");String str = perStr.getT();System.out.println(str);// 進行測試，傳入一個Integer對象Person<Integer> perInt = new Person<Integer>();perInt.setT(100);Integer intVal = perInt.getT();System.out.println(intVal);}} //自定義一個帶有一個參數的泛型類 class Person<T>{private T t;void setT(T t){this.t = t;}T getT(){return t;} }

實現帶有泛型的接口類型：

實現接口的同時, 指定了接口中的泛型類型. (定義類時確定)；

public class GenericImpl1 implements GenericInter<String> {}

實現接口時, 沒有指定接口中的泛型類型.此時, 需要將該接口的實現類定義為泛型類.接口的類型需要在創建實現類對象時才能真正確定其類型. (始終不確定類型, 直到創建對象時確定類型);

public class GenericImpl2<T> implements GenericInter<T> {}

泛型的通配符(?)：

上限限定：比如定義方法的時候出現，public void getFunc(List<? extends Animal> an)，

那么表示這里的參數可以傳入Animal，或者 Animal的子類

下限限定: 比如定義方法的時候出現，public void getFunc(Set<? super Animal> an ),

那么表示這里的參數可以傳入Animal，或者Animal的父類

使用泛型的注意點:

1、泛型不支持基本數據類型

2、泛型不支持繼承，必須保持前后一致（比如這樣是錯誤的：List<Object> list = new ArrayList<String>();

Collection體系：

ollection包括兩大體系，List和Set

List的特點：

存取有序，有索引，可以根據索引來進行取值，元素可以重復

Set的特點：

存取無序，元素不可以重復

List:

下面有ArrayList，LinkedList，Vector(已過時)

集合的的最大目的就是為了存取；List集合的特點就是存取有序，可以存儲重復的元素，可以用下標進行元素的操作

ArrayList: 底層是使用數組實現，所以查詢速度快，增刪速度慢

package 好好學java;import java.util.ArrayList; import java.util.Iterator; import java.util.List;public class Test {// 使用ArrayList進行添加和遍歷public static void main(String[] args) {List<String> list = new ArrayList<String>();list.add("接口1");list.add("接口2");list.add("接口3");// 第一種遍歷方式,使用迭代器Iterator<String> it = list.iterator();while(it.hasNext()){String next = it.next();System.out.println(next);}System.out.println("-------------------");// 第二種遍歷方式，使用foreachfor (String str : list){System.err.println(str);}}}

LinkedList:是基于鏈表結構實現的，所以查詢速度慢，增刪速度快，提供了特殊的方法，對頭尾的元素操作（進行增刪查）。

使用LinkedList來實現棧和隊列；棧是先進后出，而隊列是先進先出

package com.xiaoshitou.classtest;import java.util.LinkedList;/*** 利用LinkedList來模擬棧* 棧的特點：先進后出* @author Beck**/ public class MyStack {private LinkedList<String> linkList = new LinkedList<String>();// 壓棧public void push(String str){linkList.addFirst(str);}// 出棧public String pop(){return linkList.removeFirst();}// 查看public String peek(){return linkList.peek();}// 判斷是否為空public boolean isEmpty(){return linkList.isEmpty();} }package 好好學java;public class Test {public static void main(String[] args) {// 測試棧StackTest stack = new StackTest();stack.push("我是第1個進去的");stack.push("我是第2個進去的");stack.push("我是第3個進去的");stack.push("我是第4個進去的");stack.push("我是第5個進去的");// 取出while (!stack.isEmpty()){String pop = stack.pop();System.out.println(pop);}// 打印結果/*我是第5個進去的我是第4個進去的我是第3個進去的我是第2個進去的我是第1個進去的*/}}

LinkedList實現Queue:

package 好好學java;import java.util.LinkedList;/*** 利用linkedList來實現隊列* 隊列: 先進先出* @author Beck**/ public class QueueTest {private LinkedList<String> link = new LinkedList<String>();// 放入public void put(String str){link.addFirst(str);}// 獲取public String get(){return link.removeLast();}// 判斷是否為空public boolean isEmpty(){return link.isEmpty();} } package 好好學java;public class Test {public static void main(String[] args) {// 測試隊列QueueTest queue = new QueueTest();queue.put("我是第1個進入隊列的");queue.put("我是第2個進入隊列的");queue.put("我是第3個進入隊列的");queue.put("我是第4個進入隊列的");// 遍歷隊列while (!queue.isEmpty()){String str = queue.get();System.out.println(str);}// 打印結果/*我是第1個進入隊列的我是第2個進入隊列的我是第3個進入隊列的我是第4個進入隊列的*/}}

Vector:因為已經過時，被ArrayList取代了；它還有一種迭代器通過vector.elements()獲取，判斷是否有元素和取元素的方法為：hasMoreElements()，nextElement()。

package 好好學java;import java.util.Enumeration; import java.util.Vector;public class Test {public static void main(String[] args) {Vector<String> vector = new Vector<String>();vector.add("搜索");vector.add("vector");vector.add("list");Enumeration<String> elements = vector.elements();while (elements.hasMoreElements()){String nextElement = elements.nextElement();System.out.println(nextElement);}}}

Set:

Set集合的特點：元素不重復，存取無序，無下標
Set集合下面有：HashSet，LinkedHashSet，TreeSet

HashSet存儲字符串:

package 好好學java;import java.util.HashSet; import java.util.Iterator; import java.util.Set;public class Test {public static void main(String[] args) {// 利用HashSet來存取Set<String> set = new HashSet<String>();set.add("我的天");set.add("我是重復的");set.add("我是重復的");set.add("welcome");// 遍歷 第一種方式 迭代器Iterator<String> it = set.iterator();while(it.hasNext()){String str = it.next();System.out.println(str);}System.out.println("--------------");for (String str : set){System.out.println(str);}// 打印結果，重復的已經去掉了/*我的天welcome我是重復的--------------我的天welcome我是重復的*/}

那哈希表是怎么來保證元素的唯一性的呢，哈希表是通過hashCode和equals方法來共同保證的。

哈希表的存儲數據過程（哈希表底層也維護了一個數組）：

根據存儲的元素計算出hashCode值，然后根據計算得出的hashCode值和數組的長度進行計算出存儲的下標；如果下標的位置無元素，那么直接存儲；如果有元素，那么使用要存入的元素和該元素進行equals方法，如果結果為真，則已經有相同的元素了，所以直接不存；如果結果假，那么進行存儲，以鏈表的形式存儲。

演示HashSet來存儲自定義對象：

package 好好學java;public class Person {// 屬性private String name;private int age;// 構造方法public Person() {super();}public Person(String name, int age) {super();this.name = name;this.age = age;}// 要讓哈希表存儲不重復的元素，就必須重寫hasCode和equals方法@Overridepublic int hashCode() {final int prime = 31;int result = 1;result = prime * result + age;result = prime * result + ((name == null) ? 0 : name.hashCode());return result;}@Overridepublic boolean equals(Object obj) {if (this == obj)return true;if (obj == null)return false;if (getClass() != obj.getClass())return false;Person other = (Person) obj;if (age != other.age)return false;if (name == null) {if (other.name != null)return false;} else if (!name.equals(other.name))return false;return true;}@Overridepublic String toString() {return "Person [name=" + name + ", age=" + age + "]";}// getter & setter...}package 好好學java;import java.util.HashSet; import java.util.Set;public class Test {public static void main(String[] args) {// 利用HashSet來存取自定義對象 PersonSet<Person> set = new HashSet<Person>();set.add(new Person("cy", 12));set.add(new Person("李四", 13));set.add(new Person("王五", 22));set.add(new Person("cy", 12));// 遍歷for (Person p : set){System.out.println(p);}// 結果：向集合中存儲兩個cy對象，但是集合中就成功存儲了一個/*Person [name=王五, age=22]Person [name=李四, age=13]Person [name=cy, age=12]*/}}

所以在向HashSet集合中存儲自定義對象時，為了保證set集合的唯一性，那么必須重寫hashCode和equals方法。

LinkedHashSet:

是基于鏈表和哈希表共同實現的，所以具有存取有序，元素唯一

package 好好學java;import java.util.LinkedHashSet;public class Test {public static void main(String[] args) {// 利用LinkedHashSet來存取自定義對象 PersonLinkedHashSet<Person> set = new LinkedHashSet<Person>();set.add(new Person("cy", 12));set.add(new Person("李四", 13));set.add(new Person("王五", 22));set.add(new Person("cy", 12));// 遍歷for (Person p : set){System.out.println(p);}// 結果：向集合中存儲兩個cy對象，但是集合中就成功存儲了一個,// 并且存進的順序，和取出來的順序是一致的/*Person [name=cy, age=12]Person [name=李四, age=13]Person [name=王五, age=22]*/}}

TreeSet：

特點：存取無序，元素唯一，可以進行排序（排序是在添加的時候進行排序）。

TreeSet是基于二叉樹的數據結構，二叉樹的：一個節點下不能多余兩個節點。

二叉樹的存儲過程：

如果是第一個元素，那么直接存入，作為根節點，下一個元素進來是會跟節點比較，如果大于節點放右邊的，小于節點放左邊；等于節點就不存儲。后面的元素進來會依次比較，直到有位置存儲為止

TreeSet集合存儲String對象

package 好好學java;import java.util.TreeSet;public class Test {public static void main(String[] args) {TreeSet<String> treeSet = new TreeSet<String>();treeSet.add("abc");treeSet.add("zbc");treeSet.add("cbc");treeSet.add("xbc");for (String str : treeSet){System.out.println(str);}// 結果：取出來的結果是經過排序的/*abccbcxbczbc*/}}

TreeSet保證元素的唯一性是有兩種方式：

1、自定義對象實現Comparable接口，重寫comparaTo方法，該方法返回0表示相等，小于0表示準備存入的元素比被比較的元素小，否則大于0；

2、在創建TreeSet的時候向構造器中傳入比較器Comparator接口實現類對象，實現Comparator接口重寫compara方法。

如果向TreeSet存入自定義對象時，自定義類沒有實現Comparable接口，或者沒有傳入Comparator比較器時，會出現ClassCastException異常

下面就是演示用兩種方式來存儲自定義對象

package 好好學java; public class Person implements Comparable<Person>{// 屬性private String name;private int age;// 構造方法public Person() {super();}public Person(String name, int age) {super();this.name = name;this.age = age;}// 要讓哈希表存儲不重復的元素，就必須重寫hasCode和equals方法@Overridepublic int hashCode() {final int prime = 31;int result = 1;result = prime * result + age;result = prime * result + ((name == null) ? 0 : name.hashCode());return result;}@Overridepublic boolean equals(Object obj) {if (this == obj)return true;if (obj == null)return false;if (getClass() != obj.getClass())return false;Person other = (Person) obj;if (age != other.age)return false;if (name == null) {if (other.name != null)return false;} else if (!name.equals(other.name))return false;return true;}@Overridepublic String toString() {return "Person [name=" + name + ", age=" + age + "]";}// getter & setter...@Overridepublic int compareTo(Person o) {int result = this.age - o.age;if (result == 0){return this.name.compareTo(o.name);}return result;}}package 好好學java;import java.util.TreeSet;public class Test {public static void main(String[] args) {// 利用TreeSet來存儲自定義類Person對象TreeSet<Person> treeSet = new TreeSet<Person>();// Person類實現了Comparable接口，并且重寫comparaTo方法// 比較規則是先按照 年齡排序，年齡相等的情況按照年齡排序treeSet.add(new Person("張山1", 20));treeSet.add(new Person("張山2", 16));treeSet.add(new Person("張山3", 13));treeSet.add(new Person("張山4", 17));treeSet.add(new Person("張山5", 20));for (Person p : treeSet){System.out.println(p);}// 結果：按照comparaTo方法內的邏輯來排序的/*Person [name=張山3, age=13]Person [name=張山2, age=16]Person [name=張山4, age=17]Person [name=張山1, age=20]Person [name=張山5, age=20]*/}}

另一種方式：使用比較器Comparator

package 好好學java;public class Person{// 屬性private String name;private int age;// 構造方法public Person() {super();}public Person(String name, int age) {super();this.name = name;this.age = age;}// 要讓哈希表存儲不重復的元素，就必須重寫hasCode和equals方法@Overridepublic int hashCode() {final int prime = 31;int result = 1;result = prime * result + age;result = prime * result + ((name == null) ? 0 : name.hashCode());return result;}@Overridepublic boolean equals(Object obj) {if (this == obj)return true;if (obj == null)return false;if (getClass() != obj.getClass())return false;Person other = (Person) obj;if (age != other.age)return false;if (name == null) {if (other.name != null)return false;} else if (!name.equals(other.name))return false;return true;}@Overridepublic String toString() {return "Person [name=" + name + ", age=" + age + "]";}// getter & setter...}package 好好學java;import java.util.Comparator; import java.util.TreeSet;public class Test {public static void main(String[] args) {// 利用TreeSet來存儲自定義類Person對象// 創建TreeSet對象的時候傳入Comparator比較器，使用匿名內部類的方式// 比較規則是先按照 年齡排序，年齡相等的情況按照年齡排序TreeSet<Person> treeSet = new TreeSet<Person>(new Comparator<Person>() {@Overridepublic int compare(Person o1, Person o2) {if (o1 == o2){return 0;}int result = o1.getAge() - o2.getAge();if (result == 0){return o1.getName().compareTo(o2.getName());}return result;}});treeSet.add(new Person("張山1", 20));treeSet.add(new Person("張山2", 16));treeSet.add(new Person("張山3", 13));treeSet.add(new Person("張山4", 17));treeSet.add(new Person("張山5", 20));for (Person p : treeSet){System.out.println(p);}// 結果：按照compara方法內的邏輯來排序的/*Person [name=張山3, age=13]Person [name=張山2, age=16]Person [name=張山4, age=17]Person [name=張山1, age=20]Person [name=張山5, age=20]*/}}

比較器總結：

Collection體系總結：

• List : “特點 :” 存取有序,元素有索引,元素可以重復.

• ArrayList : 數組結構,查詢快,增刪慢,線程不安全,因此效率高.

• Vector : 數組結構,查詢快,增刪慢,線程安全,因此效率低.

• LinkedList : 鏈表結構,查詢慢,增刪快,線程不安全,因此效率高.

addFirst() removeFirst() getFirst()

• Set :”特點 :” 存取無序,元素無索引,元素不可以重復.

• HashSet : 存儲無序,元素無索引,元素不可以重復.底層是哈希表.

請問 : 哈希表如何保證元素唯一呢 ? 底層是依賴 hashCode 和 equals 方法.

當存儲元素的時候,先根據 hashCode + 數組長度 計算出一個索引,判斷索引位置是否有元素.

如果沒有元素,直接存儲,如果有元素,先判斷 equals 方法,比較兩個元素是否相同,不同則存儲,相同則舍棄.

我們自定義對象存儲的元素一定要實現 hashCode 和 equals.

• LinkedHashSet : 存儲有序,元素不可以重復.

• TreeSet : 存取無序, 但是可以排序 (自然排序), 元素不可以重復.

有兩種排序方式 :

• 自然排序 :

我們的元素必須實現 Comparable 接口.可比較的.實現 CompareTo 方法.

• 比較器排序 :

我們需要自定義類,實現Comparetor接口,這個類就是比較器實現 compare 方法.

然后在創建 TreeSet 的時候,把比較器對象作為參數傳遞給 TreeSet.

Map:

Map是一個雙列集合，其中保存的是鍵值對，鍵要求保持唯一性，值可以重復

鍵值是一一對應的，一個鍵只能對應一個值

Map的特點：是存取無序，鍵不可重復

Map在存儲的時候，將鍵值傳入Entry，然后存儲Entry對象

其中下面有HashMap，LinkedHashMap和TreeMap

HashMap：

是基于哈希表結構實現的，所以存儲自定義對象作為鍵時，必須重寫hasCode和equals方法。存取無序的

下面演示HashMap以自定義對象作為鍵：

package 好好學java;import java.util.HashMap; import java.util.Iterator; import java.util.Map.Entry; import java.util.Set;public class Test {public static void main(String[] args) {// 利用HashMap存儲，自定義對象Person作為鍵// 為了保證鍵的唯一性，必須重寫hashCode和equals方法HashMap<Person,String> map = new HashMap<Person,String>();map.put(new Person("cy", 12), "JAVA");map.put(new Person("李四", 13), "IOS");map.put(new Person("小花", 22), "JS");map.put(new Person("sihai", 32), "PHP");map.put(new Person("cy", 12), "C++");Set<Entry<Person, String>> entrySet = map.entrySet();Iterator<Entry<Person, String>> it = entrySet.iterator();while (it.hasNext()){Entry<Person, String> entry = it.next();System.out.println(entry.getKey() + "---" + entry.getValue());}// 結果：存入的時候添加了兩個cy，如果Map中鍵相同的時候，當后面的值會覆蓋掉前面的值/*Person [name=李四, age=13]---IOSPerson [name=cy, age=12]---C++Person [name=sihai, age=32]---PHPPerson [name=小花, age=22]---JS*/}}

LinkedHashMap:

用法跟HashMap基本一致，它是基于鏈表和哈希表結構的所以具有存取有序，鍵不重復的特性

下面演示利用LinkedHashMap存儲，注意存的順序和遍歷出來的順序是一致的:

package 好好學java;import java.util.LinkedHashMap; import java.util.Map.Entry;public class Test {public static void main(String[] args) {// 利用LinkedHashMap存儲，自定義對象Person作為鍵// 為了保證鍵的唯一性，必須重寫hashCode和equals方法LinkedHashMap<Person,String> map = new LinkedHashMap<Person,String>();map.put(new Person("cy", 12), "JAVA");map.put(new Person("李四", 13), "IOS");map.put(new Person("小花", 22), "JS");map.put(new Person("sihai", 32), "PHP");map.put(new Person("cy", 12), "C++");// foreach遍歷for (Entry<Person,String> entry : map.entrySet()){System.out.println(entry.getKey()+"==="+entry.getValue());}// 結果：存入的時候添加了兩個cy，如果Map中鍵相同的時候，當后面的值會覆蓋掉前面的值// 注意：LinkedHashMap的特點就是存取有序，取出來的順序就是和存入的順序保持一致/*Person [name=cy, age=12]===C++Person [name=李四, age=13]===IOSPerson [name=小花, age=22]===JSPerson [name=sihai, age=32]===PHP*/} }

TreeMap:

給TreeMap集合中保存自定義對象，自定義對象作為TreeMap集合的key值。由于TreeMap底層使用的二叉樹，其中存放進去的所有數據都需要排序，要排序，就要求對象具備比較功能。對象所屬的類需要實現Comparable接口。或者給TreeMap集合傳遞一個Comparator接口對象。

利用TreeMap存入自定義對象作為鍵：

package 好好學java;import java.util.Comparator; import java.util.Map.Entry; import java.util.TreeMap;public class Test {public static void main(String[] args) {// 利用TreeMap存儲，自定義對象Person作為鍵// 自定義對象實現Comparable接口或者傳入Comparator比較器TreeMap<Person,String> map = new TreeMap<Person,String>(new Comparator<Person>() {@Overridepublic int compare(Person o1, Person o2) {if (o1 == o2){return 0;}int result = o1.getAge() - o2.getAge();if (result == 0){return o1.getName().compareTo(o2.getName());}return result;}});map.put(new Person("cy", 12), "JAVA");map.put(new Person("李四", 50), "IOS");map.put(new Person("小花", 32), "JS");map.put(new Person("sihai", 32), "PHP");map.put(new Person("cy", 12), "C++");// foreach遍歷for (Entry<Person,String> entry : map.entrySet()){System.out.println(entry.getKey()+"==="+entry.getValue());}// 結果：存入的時候添加了兩個cy，如果Map中鍵相同的時候，當后面的值會覆蓋掉前面的值// 注意：TreeMap 取出來的順序是經過排序的，是根據compara方法排序的/*Person [name=cy, age=12]===C++Person [name=小花, age=32]===JSPerson [name=sihai, age=32]===PHPPerson [name=李四, age=50]===IOS*/} } 《新程序員》：云原生和全面數字化實踐50位技術專家共同創作，文字、視頻、音頻交互閱讀

總結

以上是生活随笔為你收集整理的java基础系列：集合入门的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。