一、什麼是集合
1.廣義上的概念
集合，簡稱集，是數學中一個基本概念，也是集合論的主要研究對象。集合論的基本理論創立於19世紀，關於集合的最簡單的說法就是在樸素集合論（最原始的集合論）中的定義，即集合是“確定的一堆東西”，集合裏的“東西”則稱爲元素。現代的集合一般被定義爲：由一個或多個確定的元素所構成的整體
——百度百科
集合就是包含了一堆確定的元素的整體。
2.在java中的概念
集合是一種存放對象的數據結構。
主要分爲三類：
- List集合：元素存放有序，可以重複
- Set集合：元素存放無序，不可重複
- Map集合：按key-value對存儲，key不能重複，value可重複
接口
這不是全部接口和實現類，但是這是我們主要的研究對象。
二、接口介紹
1.Iterator（迭代器）
代碼
爲了節省篇幅，我把註釋都刪了。
public interface Iterator<E> {
/**
*實現這個方法時，需要實現的功能
*判斷是否還有下一個數據，返回一個布爾值
*/
boolean hasNext();
/*
*實現這個方法時，需要實現的功能
返回集合中的下一個對象
如果沒有下一個對象，則拋出異常
*/
E next();
/**
默認拋出一個異常
實現這個方法時，需要實現的功能
刪除當前迭代器上的元素
*/
default void remove() {
throw new UnsupportedOperationException("remove");
}
/**
實現這個方法時，需要實現的功能
看代碼也知道，這個就是把剩下的對象都走一邊
*/
default void forEachRemaining(Consumer<? super E> action) {
Objects.requireNonNull(action);
while (hasNext())
action.accept(next());
}
}
補充說明
- 這個是一個迭代器，一般都會存在與有序的集合類的內部，通過 iterator() 這個方法創建，而返回的對象一般都是實現了這個接口的對象。
- 通過這個迭代器的hasNext()方法，可以實現對集合進行遍歷操作。
實現類
一般是在實現了List接口、Set接口的實現類中，作爲內部類存在。
2.Iterable
代碼
在Collection接口中，就實現了這個接口。
public interface Iterable<T> {
/**
這是一個Iterator迭代器的構建方法
*/
Iterator<T> iterator();
/**
這是一個循環遍歷的方法，經常寫代碼的話就會認識了
不過這裏的action我看的不是很懂
*/
default void forEach(Consumer<? super T> action) {
Objects.requireNonNull(action);
for (T t : this) {
action.accept(t);
}
}
/**
這個方法是用來分割迭代器的
Spliterator這個類的內部會有一系列的數值用來記錄需要迭代的起始位置和數量
一般情況下實現類都會覆蓋這個方法
*/
default Spliterator<T> spliterator() {
return Spliterators.spliteratorUnknownSize(iterator(), 0);
}
}
補充說明
- 這是一個迭代器的構建器，實現這個接口，就可以實現獲取相應迭代器的功能
- 只要實現了Iterable這個接口，就可以使用java對forEach封裝的for(:)循環
- Iterable是對Iterator的一個封裝，這樣就能更好地在不同的實現類中實現不同的迭代器構建方法
3.Collection
代碼
代碼太多了，一些看方法名就能知道它要實現什麼功能的，我就不解釋了
public interface Collection<E> extends Iterable<E> {
/**
將size返回，爲了符合JavaBean的編程思想
*/
int size();
/**
需要實現的功能
判斷集合是否爲空
*/
boolean isEmpty();
/**
需要實現的功能
判斷集合中是否存在這個元素
*/
boolean contains(Object o);
Iterator<E> iterator();
/**
需要實現的功能
將當前集合轉化成數組並返回
*/
Object[] toArray();
/**
需要實現的功能
將當前集合轉化成數組，如果有傳入參數，就將數組賦值給傳入的參數
如果沒有傳入，就直接返回
*/
<T> T[] toArray(T[] a);
boolean add(E e);
boolean remove(Object o);
/**
需要實現的功能
判斷集合中是否存在這個集合中的全部元素
*/
boolean containsAll(Collection<?> c);
boolean addAll(Collection<? extends E> c);
/**
需要實現的功能
刪除集合中和傳入集合相同的元素，
*/
boolean removeAll(Collection<?> c);
/**
這個是傳入一個判斷規則，刪除集合中滿足條件的元素
當有刪除過元素，就返回true
*/
default boolean removeIf(Predicate<? super E> filter) {
Objects.requireNonNull(filter);
boolean removed = false;
final Iterator<E> each = iterator();
while (each.hasNext()) {
if (filter.test(each.next())) {
each.remove();
removed = true;
}
}
return removed;
}
/**
需要實現的功能
保留集合中和傳入集合相同的元素，
*/
boolean retainAll(Collection<?> c);
/**
《Object中的方法
*/
void clear();
boolean equals(Object o);
int hashCode();
/**
Object中的方法》
*/
@Override
default Spliterator<E> spliterator() {
return Spliterators.spliterator(this, 0);
}
/**
Stream跟mysql中的視圖類似，它佔用內存小
這個方法就是將該集合的視圖返回
*/
default Stream<E> stream() {
return StreamSupport.stream(spliterator(), false);
}
/**
是多線程的stream方法
相比與stream()的區別就是，在遍歷的時候，它是採用多線程的方式
*/
default Stream<E> parallelStream() {
return StreamSupport.stream(spliterator(), true);
}
}
補充說明
- Collection的實現類的實例對象，在使用remove時，避免在在forEach，for(:)中使用集合本身的remove方法，在這幾個循環中會使用在迭代器，如果直接在集合上刪除的話，會出發接口實現類（Arraylist）上的checkForComodification方法報錯
- removeIf是用來彌補remove的一種方法，可以在forEach，for(:)中使用
- Stream在使用時只能遍歷一次，是一種聲明式的數據處理方式，Stream不會存儲元素，在遍歷時按需計算。
4.List（有序集合）
代碼
因爲這些接口中存在實現，重複的方法我就不重複的複製了
public interface List<E> extends Collection<E> {
/**
這個是實現替換功能，這個替換不是直接替換
而是需要傳入一個替換規則，根據規則替換
貌似只有基本數據類型才能使用
*/
default void replaceAll(UnaryOperator<E> operator) {
Objects.requireNonNull(operator);
final ListIterator<E> li = this.listIterator();
while (li.hasNext()) {
li.set(operator.apply(li.next()));
}
}
/**
對集合進行排序，根據Comparator裏面的compare方法的實現進行排序
*/
@SuppressWarnings({"unchecked", "rawtypes"})
default void sort(Comparator<? super E> c) {
Object[] a = this.toArray();
Arrays.sort(a, (Comparator) c);
ListIterator<E> i = this.listIterator();
for (Object e : a) {
i.next();
i.set((E) e);
}
}
/**
需要實現功能
獲取指定下標的對象
*/
E get(int index);
/**
需要實現功能
獲取傳入對象的所在的第一個下標
*/
int indexOf(Object o);
/**
需要實現功能
獲取傳入對象的所在的最後一個下標
*/
int lastIndexOf(Object o);
/**
需要實現功能
返回一個list迭代器
這個迭代器能是雙向迭代器
*/
ListIterator<E> listIterator();
/**
需要實現功能
根據傳進來的參數，返回一個以參數爲下標的對象開始的list迭代器
*/
ListIterator<E> listIterator(int index);
/**
需要實現功能
返回一個以formIndex開始，toIndex-1結尾的list
*/
List<E> subList(int fromIndex, int toIndex);
}
補充說明
- indexOf的方法，需要根據實現類的具體實現來確定，對比的是地址，還是內容。
- get方法獲得的只是對象的地址
實現類
- LinkedList
LinkedList是基於鏈表實現的，也繼承了鏈表的特點，增刪快，查詢慢
- ArrayList
ArrayList是基於數組實現的，也繼承了數組的特點，查詢快，增刪慢。
- Vector
Vector是基於數組實現的，跟ArrayList類似，很多實現方法也是類似的，但是Vector是線程安全的，因爲它的方法加了synchronized關鍵字。
5.Set（無序集合）
代碼
public interface Set<E> extends Collection<E> {
/**
這個接口的方法跟Conlection接口的一模一樣，可能只是改了註釋，做了一下接口實現的描述，我也看不懂，方法體裏面是空的，也沒有新方法。。
*/
}
實現類
- HashSet
HashSet是基於哈希表實現的，它的構建方法會創建一個HashMap對象，用來存放對象。HashSet除了無序之外，還不能有重複的值。存取都快。
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
這是HashSet的方法，從這裏來看，HashSet是將對象當作Key存入HashMap中，所以纔不能有重複值。
- TreeSet
TreeSet是基於二叉樹實現的，不允許重複，不允許null，無序。存取效率比HashSet低。
- LinkedHashSet
LinkedHashSet是基於鏈表和哈希表（HashMap）實現的，這個和上面兩個不同，它是有序的，存取效率比HashSet低。
6.Map（映射）
Map接口的代碼太長了，就不在這裏做解釋了，有興趣的話自己去看吧。
實現類
- HashMap
HashMap是基於hash算法、數組、二叉樹實現的，插入快，查詢快，什麼都快。
- TreeMap
TreeMap是基於hash算法和二叉樹實現的，插入慢，查詢慢。
——————————————————————————————
如果本文章內容有問題，請直接評論或者私信我。
未經允許，不得轉載！
第一次寫這麼長的文章，快寫崩潰了，估計內容會出很多問題，也不是特別全，實現類的內容就不想寫了。