前言
在之前的博客文章中已經介紹了Collection接口使用，本篇將介紹Collection接口中的子類的用法，至於為啥要講它的子類這種小白問題就不要問我了。啥？有小白在看我寫的文章...不好意思不好意思，原諒我剛才說的話，請允許博主我重新組織一下語言...咳咳，至於為啥要講Collection接口的子類呢？小白童鞋啊，Collection接口他是接口哇，接口的目的是啥？就是定義一套規范，沒有具體類去實現接口，接口就毫無意義了！小白童鞋你何什左咩鴨。
還有一點就是如果對Collection接口還不熟悉的小白童鞋強烈建議先去了解Collection接口之后再看這篇文章，不然只會事倍功半！好吧，我就知道就是博主我強烈建議過了肯定還有小白童鞋不去找，沒事，博主沒別的目的，就是想讓小白童鞋好好學java，所以我已經准備好了下面這篇文章點擊藍色字體即可進入Collection集合以及Iterator迭代器實現原理
@
List接口
接下來，我們一起學習Collection中的常用兩個子類java.util.List集合、java.util.Set集合。
1.1 List接口介紹
java.util.List接口繼承自Collection接口，在List集合元素可重復、元素有序。所有的元素是以一種線性方式進行存儲的，在程序中可以通過索引來訪問集合中的指定元素，而且元素的存入順序和取出順序一致。
List接口特點分析：
- 元素存取有序：例如，存元素的順序是“我”、“是”、“佩”、“奇”，那么集合中，元素的存儲就是按照“我”、“是”、“佩”、“奇”的順序完成的。
- 帶有索引的集合：與數組的索引是一個道理
- 元素重復：通過元素的
equals方法，來比較是否為重復的元素。
1.2 List接口中常用方法
List作為Collection集合的子接口，不但繼承了Collection接口中的全部方法，還有一些根據元素索引來操作集合的特有方法，如下：
public void add(int index, E element): 將指定的元素，添加到該集合中的指定位置上。- public E get(int index):返回集合中指定位置的元素。
public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。
public E set(int index, E element):用指定元素替換集合中指定位置的元素,返回值的更新前的元素。
List集合特有的方法都是跟索引相關，代碼如下：
public class ListDemo {
public static void main(String[] args) {
// 創建List集合對象
List<String> list = new ArrayList<String>();
// 往 尾部添加 指定元素
list.add("安琪拉屎");
list.add("劉備胎");
list.add("廉頗婦");
System.out.println(list);
// add(int index,String s) 往指定位置添加
list.add(1,"豬腳亮");
System.out.println(list);
// String remove(int index) 刪除指定位置元素 返回被刪除元素
// 刪除索引位置為2的元素
System.out.println("刪除索引位置為2的元素");
System.out.println(list.remove(2));
System.out.println(list);
// String set(int index,String s)
// 在指定位置 進行 元素替代（改）
// 修改指定位置元素
list.set(0, "東皇太二");
System.out.println(list);
// String get(int index) 獲取指定位置元素
// 跟size() 方法一起用 來 遍歷的
for(int i = 0;i<list.size();i++){
System.out.println(list.get(i));
}
//還可以使用增強for
for (String string : list) {
System.out.println(string);
}
}
}
List的子類
2.1 ArrayList集合
java.util.ArrayList集合數據存儲的結構是數組結構。元素增刪慢，查找快，由於日常開發中使用最多的功能為查詢數據、遍歷數據，所以ArrayList是最常用的集合。
2.2 LinkedList集合
java.util.LinkedList集合數據存儲的結構是鏈表結構。元素增刪快，查找慢的集合。
LinkedList是一個雙向鏈表，那么雙向鏈表是什么樣子的呢？
實際開發中對一個集合元素的添加與刪除經常涉及到首尾操作，而LinkedList提供了大量首尾操作的方法。下面這些方法我們作為了解即可：
public void addFirst(E e):將指定元素插入此列表的開頭。public void addLast(E e):將指定元素添加到此列表的結尾。public E getFirst():返回此列表的第一個元素。public E getLast():返回此列表的最后一個元素。public E removeFirst():移除並返回此列表的第一個元素。public E removeLast():移除並返回此列表的最后一個元素。public E pop():從此列表所表示的堆棧處彈出一個元素。public void push(E e):將元素推入此列表所表示的堆棧。public boolean isEmpty()：如果列表不包含元素，則返回true。
LinkedList是List的子類，List中的方法LinkedList都是可以使用，這里就不做詳細介紹，我們只需要了解LinkedList的特有方法即可。在開發時，LinkedList集合也可以作為堆棧，隊列的結構使用。（了解即可）
方法代碼如下：
public class LinkedListDemo {
public static void main(String[] args) {
LinkedList<String> link = new LinkedList<String>();
//添加元素
link.addFirst("大喬");
link.addFirst("小橋");
link.addFirst("老喬");
System.out.println(link);
// 獲取元素
System.out.println(link.getFirst());
System.out.println(link.getLast());
// 刪除元素
System.out.println(link.removeFirst());
System.out.println(link.removeLast());
while (!link.isEmpty()) { //判斷集合是否為空
System.out.println(link.pop()); //彈出集合中的棧頂元素
}
System.out.println(link);
}
}
好了，到這里，list集合就先告一段落。
Set接口
3.1 Set接口介紹
java.util.Set接口和java.util.List接口一樣，同樣繼承自Collection接口，它與Collection接口中的方法基本一致，並沒有對Collection接口進行功能上的擴充，只是比Collection接口更加嚴格了。與List接口不同的是，Set接口中元素無序且不重復，剛好全與list相反，set會以某種規則保證存入的元素不出現重復。
Set集合有多個子類，這里我們介紹其中的java.util.HashSet、java.util.LinkedHashSet這兩個集合。
Set集合取出元素的方式可以采用：迭代器、增強for。
Set接口子類
4.1 HashSet集合介紹
java.util.HashSet是Set接口的一個實現類，它所存儲的元素是不可重復、無序(即存取順序不一致)。java.util.HashSet底層的實現其實是一個java.util.HashMap支持。
HashSet是根據對象的哈希值來確定元素在集合中的存儲位置，因此具有良好的存取和查找性能。保證元素唯一性的方式依賴於：hashCode與equals方法。
我們先來使用一下Set集合存儲，看下現象，再進行原理的講解:
public class HashSetDemo {
public static void main(String[] args) {
//創建 Set集合
HashSet<String> set = new HashSet<String>();
//添加元素
set.add(new String("安琪拉屎"));
set.add("劉備胎");
set.add("豬八戒煙");
set.add("安琪拉屎");
//遍歷
for (String name : set) {
System.out.println(name);
}
}
}
輸出結果如下，說明集合中不能存儲重復元素：
安琪拉屎
劉備胎
豬八戒煙
根據結果我們發現字符串 "安琪拉屎" 只存儲了一個，也就是說重復的元素set集合不存儲。
4.2 HashSet集合存儲數據的結構（哈希表）
什么是哈希表呢？
在JDK1.8之前，哈希表底層采用數組+鏈表實現，即使用鏈表處理沖突，同一hash值的鏈表都存儲在一個鏈表里。但是當位於一個桶中的元素較多，即hash值相等的元素較多時，通過key值依次查找的效率較低。而JDK1.8中，哈希表存儲采用數組+鏈表+紅黑樹實現，當鏈表長度超過閾值（8）時，將鏈表轉換為紅黑樹，這樣大大減少了查找時間。
簡單的來說，哈希表是由數組+鏈表+紅黑樹（JDK1.8增加了紅黑樹部分）實現的，如下圖所示。
看到這張圖就有童鞋要問了，這個是怎么存儲的呢？看下圖就明白了
總而言之，JDK1.8引入紅黑樹大程度優化了HashMap的性能，那么對於我們來講保證HashSet集合元素的唯一，其實就是根據對象的hashCode和equals方法來決定的。如果我們往集合中存放自定義的對象，那么保證其唯一，就必須復寫hashCode和equals方法建立屬於當前對象的比較方式。
至於數據結構關於數組以及鏈表我之前寫過，為了方便各位閱讀，我就貼在下面了
啥？還要看紅黑樹？額...暫時還沒寫，如果不是特別急着看博主就往后推一點寫，畢竟忙嘛 實在急着看博主盡量抽空寫一篇出來...
4.3源碼分析
QnQ
public class HashSet<E>
extends AbstractSet<E>
implements Set<E>, Cloneable, java.io.Serializable
{
static final long serialVersionUID = -5024744406713321676L;
// 底層使用HashMap來保存HashSet中所有元素。
private transient HashMap<E,Object> map;
// 定義一個虛擬的Object對象作為HashMap的value，將此對象定義為static final。
private static final Object PRESENT = new Object();
/**
* 默認的無參構造器，構造一個空的HashSet。
*
* 實際底層會初始化一個空的HashMap，並使用默認初始容量為16和加載因子0.75。
*/
public HashSet() {
map = new HashMap<E,Object>();
}
/**
* 構造一個包含指定collection中的元素的新set。
*
* 實際底層使用默認的加載因子0.75和足以包含指定
* collection中所有元素的初始容量來創建一個HashMap。
* @param c 其中的元素將存放在此set中的collection。
*/
public HashSet(Collection<? extends E> c) {
map = new HashMap<E,Object>(Math.max((int) (c.size()/.75f) + 1, 16));
addAll(c);
}
/**
* 以指定的initialCapacity和loadFactor構造一個空的HashSet。
*
* 實際底層以相應的參數構造一個空的HashMap。
* @param initialCapacity 初始容量。
* @param loadFactor 加載因子。
*/
public HashSet(int initialCapacity, float loadFactor) {
map = new HashMap<E,Object>(initialCapacity, loadFactor);
}
/**
* 以指定的initialCapacity構造一個空的HashSet。
*
* 實際底層以相應的參數及加載因子loadFactor為0.75構造一個空的HashMap。
* @param initialCapacity 初始容量。
*/
public HashSet(int initialCapacity) {
map = new HashMap<E,Object>(initialCapacity);
}
/**
* 以指定的initialCapacity和loadFactor構造一個新的空鏈接哈希集合。
* 此構造函數為包訪問權限，不對外公開，實際只是是對LinkedHashSet的支持。
*
* 實際底層會以指定的參數構造一個空LinkedHashMap實例來實現。
* @param initialCapacity 初始容量。
* @param loadFactor 加載因子。
* @param dummy 標記。
*/
HashSet(int initialCapacity, float loadFactor, boolean dummy) {
map = new LinkedHashMap<E,Object>(initialCapacity, loadFactor);
}
/**
* 返回對此set中元素進行迭代的迭代器。返回元素的順序並不是特定的。
*
* 底層實際調用底層HashMap的keySet來返回所有的key。
* 可見HashSet中的元素，只是存放在了底層HashMap的key上，
* value使用一個static final的Object對象標識。
* @return 對此set中元素進行迭代的Iterator。
*/
public Iterator<E> iterator() {
return map.keySet().iterator();
}
/**
* 返回此set中的元素的數量（set的容量）。
*
* 底層實際調用HashMap的size()方法返回Entry的數量，就得到該Set中元素的個數。
* @return 此set中的元素的數量（set的容量）。
*/
public int size() {
return map.size();
}
/**
* 如果此set不包含任何元素，則返回true。
*
* 底層實際調用HashMap的isEmpty()判斷該HashSet是否為空。
* @return 如果此set不包含任何元素，則返回true。
*/
public boolean isEmpty() {
return map.isEmpty();
}
/**
* 如果此set包含指定元素，則返回true。
* 更確切地講，當且僅當此set包含一個滿足(o==null ? e==null : o.equals(e))
* 的e元素時，返回true。
*
* 底層實際調用HashMap的containsKey判斷是否包含指定key。
* @param o 在此set中的存在已得到測試的元素。
* @return 如果此set包含指定元素，則返回true。
*/
public boolean contains(Object o) {
return map.containsKey(o);
}
/**
* 如果此set中尚未包含指定元素，則添加指定元素。
* 更確切地講，如果此 set 沒有包含滿足(e==null ? e2==null : e.equals(e2))
* 的元素e2，則向此set 添加指定的元素e。
* 如果此set已包含該元素，則該調用不更改set並返回false。
*
* 底層實際將將該元素作為key放入HashMap。
* 由於HashMap的put()方法添加key-value對時，當新放入HashMap的Entry中key
* 與集合中原有Entry的key相同（hashCode()返回值相等，通過equals比較也返回true），
* 新添加的Entry的value會將覆蓋原來Entry的value，但key不會有任何改變，
* 因此如果向HashSet中添加一個已經存在的元素時，新添加的集合元素將不會被放入HashMap中，
* 原來的元素也不會有任何改變，這也就滿足了Set中元素不重復的特性。
* @param e 將添加到此set中的元素。
* @return 如果此set尚未包含指定元素，則返回true。
*/
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
/**
* 如果指定元素存在於此set中，則將其移除。
* 更確切地講，如果此set包含一個滿足(o==null ? e==null : o.equals(e))的元素e，
* 則將其移除。如果此set已包含該元素，則返回true
* （或者：如果此set因調用而發生更改，則返回true）。（一旦調用返回，則此set不再包含該元素）。
*
* 底層實際調用HashMap的remove方法刪除指定Entry。
* @param o 如果存在於此set中則需要將其移除的對象。
* @return 如果set包含指定元素，則返回true。
*/
public boolean remove(Object o) {
return map.remove(o)==PRESENT;
}
/**
* 從此set中移除所有元素。此調用返回后，該set將為空。
*
* 底層實際調用HashMap的clear方法清空Entry中所有元素。
*/
public void clear() {
map.clear();
}
/**
* 返回此HashSet實例的淺表副本：並沒有復制這些元素本身。
*
* 底層實際調用HashMap的clone()方法，獲取HashMap的淺表副本，並設置到HashSet中。
*/
public Object clone() {
try {
HashSet<E> newSet = (HashSet<E>) super.clone();
newSet.map = (HashMap<E, Object>) map.clone();
return newSet;
} catch (CloneNotSupportedException e) {
throw new InternalError();
}
}
}
說白了，HashSet就是限制了功能的HashMap，所以了解HashMap的實現原理，這個HashSet自然就通,對於HashSet中保存的對象，主要要正確重寫equals方法和hashCode方法，以保證放入Set對象的唯一性,雖說是Set是對於重復的元素不放入，倒不如直接說是底層的Map直接把原值替代了（這個Set的put方法的返回值真有意思）。HashSet沒有提供get()方法，願意是同HashMap一樣，Set內部是無序的，只能通過迭代的方式獲得。
4.4 HashSet存儲自定義類型元素
給HashSet中存放自定義類型元素時，需要重寫對象中的hashCode和equals方法，建立自己的比較方式，才能保證HashSet集合中的對象唯一
創建自定義Student類
public class Student {
private String name;
private int age;
public Student() {
}
public Student(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 boolean equals(Object o) {
if (this == o)
return true;
if (o == null || getClass() != o.getClass())
return false;
Student student = (Student) o;
return age == student.age &&
Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
public class HashSetDemo2 {
public static void main(String[] args) {
//創建集合對象 該集合中存儲 Student類型對象
HashSet<Student> stuSet = new HashSet<Student>();
//存儲
Student stu = new Student("程序員老王", 43);
stuSet.add(stu);
stuSet.add(new Student("程序員小王", 44));
stuSet.add(new Student("程序員老王", 43));
stuSet.add(new Student("程序員禿頭哥", 23));
stuSet.add(stu);
for (Student stud : stuSet) {
System.out.println(stud);
}
}
}
執行結果：
Student [name=程序員小王, age=44]
Student [name=程序員老王, age=43]
Student [name=程序員禿頭哥, age=23]
4.5 LinkedHashSet
我們知道HashSet保證元素唯一，可是元素存放進去是沒有順序的，那么我們要保證有序，怎么辦呢？在HashSet下面有一個子類java.util.LinkedHashSet，它是鏈表和哈希表組合的一個數據存儲結構。
代碼如下:
public class LinkedHashSetDemo {
public static void main(String[] args) {
Set<String> set = new LinkedHashSet<String>();
set.add("禿頭哥");
set.add("地中海哥");
set.add("平頭哥");
set.add("假發哥");
Iterator<String> it = set.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
}
}
結果：
禿頭哥
地中海哥
平頭哥
假發哥
最后，歡迎各位關注我的公眾號，一起探討技術，向往技術，追求技術...
