java_集合體系之Collection框架相關抽象類介面詳解、原始碼——02
阿新 • • 發佈：2018-12-26
java_集合體系之Collection框架相關抽象類介面詳解、原始碼——02
一：Collection相關介面、抽象類結構圖
二：Collection相關
1、介面簡介：
Collection作為佇列形式儲存的集合的抽象介面 Collection 是一個被高度抽象出來的介面、提供基本的操作資料的行為、屬性的定義、要求子類必須提供兩個構造方法、一個無參構造方法、一個以另一個Collection為基礎的構造方法。
2、原始碼：
雖然Collection是一個介面、僅有方法的宣告沒有方法體、但是個人覺得知道原始碼中對各個方法的目的或者意義的說明對後面的理解還是很有必要的、同時在這裡也不再將Collection的API一一列出來、會在後面的介面抽象類中標識列出、原始碼是一些方法的定義、
package com.chy.collection.core; import java.util.Iterator; /** * Collection 是一個被高度抽象出來的介面、是一個獨立元素的序列、這些獨立元素服從一條或者多條規則 * 本身提供一類集合所具有的共同的方法、所有作為其子類的集合都不能直接實現他、而是應該實現他的子介面、 * 並且必須要提供兩個構造方法、一個無參構造方法、一個以一個集合為基礎的有參構造方法。具體有什麼規則 * 在後面的具體的類的時候會有說明。 * * @author andyChen */ public interface Collection<E> extends Iterable<E> { /** 返回當前集合的大小、如果超過int的範圍、則返回int的最大值*/ int size(); /** 標識當前Collection是否有元素、是返回true、否返回false*/ boolean isEmpty(); /** 當前Collection是否包含o、*/ boolean contains(Object o); /** 返回當前Collection的包含所有元素的一個迭代器 */ Iterator<E> iterator(); /** 將當前Collection以一個Object陣列的形式返回 */ Object[] toArray(); /** 將當前Collection中所有元素以一個與T相同型別的陣列的形式返回*/ <T> T[] toArray(T[] a); // Modification Operations /** 確保此 collection 包含指定的元素*/ boolean add(E e); /** 從此 collection 中移除指定元素的單個例項，如果存在的話*/ boolean remove(Object o); // Bulk Operations /** 如果此 collection 包含指定 collection 中的所有元素，則返回 true*/ boolean containsAll(Collection<?> c); /** 將指定 collection 中的所有元素都新增到此 collection 中*/ boolean addAll(Collection<? extends E> c); /** 移除此 collection 中那些也包含在指定 collection 中的所有元素（可選操作）*/ boolean removeAll(Collection<?> c); /** 僅保留此 collection 中那些也包含在指定 collection 的元素、即求兩個Collection的交集 */ boolean retainAll(Collection<?> c); /** 移除此 collection 中的所有元素*/ void clear(); // Comparison and hashing /** 比較此 collection 與指定物件是否相等*/ boolean equals(Object o); /** 返回此 collection 的雜湊碼值*/ int hashCode(); }
三：AbstractCollection
1、抽象類簡介：
AbstractCollection是一個實現Collection介面的抽象類、本身沒有提供任何額外的方法、所有想要實現Collection介面的實現類都必須從AbstractCollection繼承、他存在的意義就是大大減少編碼的工作量、AbstractCollection中的方法都是從Collection介面中繼承、除兩個關鍵方法abstract Iterator<E> iterator();abstract int size();方法外都提供了簡單的實現（這裡要注意add()只是丟擲異常、要求子類必須去實現、因為不同資料結構新增元素的方式不一致）、其他的方法都是通過Iterator的方法來實現的、所以在子類中要實現Iterator的方法、講到Iterator才具體列舉有哪些方法、這就是此類為什麼能減少程式碼量的原因。
2、原始碼：
API與Collection的完全相同、只是有簡單實現、具體如何實現可見原始碼
package com.chy.collection.core;
import java.util.Arrays;
import java.util.Iterator;
/**
* 此類提供 Collection 介面的骨幹實現，以最大限度地減少了實現此介面所需的工作。
*
* 子類要繼承此抽象類、
* 1、必須提供兩個構造方法、一個無參一個有參。
* 2、必須重寫抽象方法 Iterator<E> iterator();方法體中必須有hasNext()和next()兩個方法、同時必須實現remove方法 用於操作集合中元素。
* 3、一般要重寫add方法、否則子類呼叫add方法會拋UnsupportedOperationException異常。
* 子類通常要重寫此類中的方法已得到更有效的實現、
*/
@SuppressWarnings("unchecked")
public abstract class AbstractCollection<E> implements Collection<E> {
/**
* 基礎構造器
*/
protected AbstractCollection() {
}
// Query Operations
public abstract Iterator<E> iterator();
public abstract int size();
public boolean isEmpty() {
return size() == 0;
}
public boolean contains(Object o) {
Iterator<E> e = iterator();
if (o==null) {
while (e.hasNext())
if (e.next()==null)
return true;
} else {
while (e.hasNext())
if (o.equals(e.next()))
return true;
}
return false;
}
public Object[] toArray() {
// Estimate size of array; be prepared to see more or fewer elements
Object[] r = new Object[size()];
Iterator<E> it = iterator();
for (int i = 0; i < r.length; i++) {
if (! it.hasNext()) // fewer elements than expected
return Arrays.copyOf(r, i);
r[i] = it.next();
}
return it.hasNext() ? finishToArray(r, it) : r;
}
public <T> T[] toArray(T[] a) {
// Estimate size of array; be prepared to see more or fewer elements
int size = size();
T[] r = a.length >= size ? a :
(T[])java.lang.reflect.Array
.newInstance(a.getClass().getComponentType(), size);
Iterator<E> it = iterator();
for (int i = 0; i < r.length; i++) {
if (! it.hasNext()) { // fewer elements than expected
if (a != r)
return Arrays.copyOf(r, i);
r[i] = null; // null-terminate
return r;
}
r[i] = (T)it.next();
}
return it.hasNext() ? finishToArray(r, it) : r;
}
private static <T> T[] finishToArray(T[] r, Iterator<?> it) {
int i = r.length;
while (it.hasNext()) {
int cap = r.length;
if (i == cap) {
int newCap = ((cap / 2) + 1) * 3;
if (newCap <= cap) { // integer overflow
if (cap == Integer.MAX_VALUE)
throw new OutOfMemoryError
("Required array size too large");
newCap = Integer.MAX_VALUE;
}
r = Arrays.copyOf(r, newCap);
}
r[i++] = (T)it.next();
}
// trim if overallocated
return (i == r.length) ? r : Arrays.copyOf(r, i);
}
// Modification Operations
public boolean add(E e) {
throw new UnsupportedOperationException();
}
public boolean remove(Object o) {
Iterator<E> e = iterator();
if (o==null) {
while (e.hasNext()) {
if (e.next()==null) {
e.remove();
return true;
}
}
} else {
while (e.hasNext()) {
if (o.equals(e.next())) {
e.remove();
return true;
}
}
}
return false;
}
// Bulk Operations
public boolean containsAll(Collection<?> c) {
Iterator<?> e = c.iterator();
while (e.hasNext())
if (!contains(e.next()))
return false;
return true;
}
public boolean addAll(Collection<? extends E> c) {
boolean modified = false;
Iterator<? extends E> e = c.iterator();
while (e.hasNext()) {
if (add(e.next()))
modified = true;
}
return modified;
}
public boolean removeAll(Collection<?> c) {
boolean modified = false;
Iterator<?> e = iterator();
while (e.hasNext()) {
if (c.contains(e.next())) {
e.remove();
modified = true;
}
}
return modified;
}
public boolean retainAll(Collection<?> c) {
boolean modified = false;
Iterator<E> e = iterator();
while (e.hasNext()) {
if (!c.contains(e.next())) {
e.remove();
modified = true;
}
}
return modified;
}
public void clear() {
Iterator<E> e = iterator();
while (e.hasNext()) {
e.next();
e.remove();
}
}
// String conversion
public String toString() {
Iterator<E> i = iterator();
if (! i.hasNext())
return "[]";
StringBuilder sb = new StringBuilder();
sb.append('[');
for (;;) {
E e = i.next();
sb.append(e == this ? "(this Collection)" : e);
if (! i.hasNext())
return sb.append(']').toString();
sb.append(", ");
}
}
}四：List
1、介面簡介：
作為Collection的一個子介面、也是集合的一種、List是有序的佇列、其中存放的每個元素都有索引、第一個元素的索引從0開始、與Set相比、List允許存放重複的元素。因其具有索引這一概念、所以相比於Collection介面、List多了根據索引操作元素的方法、具體可為“增刪改查”、從前向後查詢某元素的索引值、從後向前查詢某元素的索引值、List特有的ListIterator和在指定的索引處新增一個Collection集合。
官方版：A List is a collection which maintains an ordering for its elements.Every element in the List has an index. Each element can thus be accessed byits index, with the first index being zero. Normally, Lists allow duplicateelements, as compared to Sets, where elements have to be unique.
2、相對於Collection多提供的方法的原始碼
public interface List<E> extends Collection<E> {
// Bulk Modification Operations
/**
* 將指定 collection 中的所有元素都插入到列表中的指定位置
*/
boolean addAll(int index, Collection<? extends E> c);
// Positional Access Operations
/** 返回列表中指定位置的元素。*/
E get(int index);
/** 用指定元素替換列表中指定位置的元素*/
E set(int index, E element);
/** 在列表的指定位置插入指定元素*/
void add(int index, E element);
/** 移除列表中指定位置的元素*/
E remove(int index);
// Search Operations
/** 返回此列表中第一次出現的指定元素的索引；如果此列表不包含該元素，則返回 -1*/
int indexOf(Object o);
/** 返回此列表中最後一次出現的指定元素的索引；如果此列表不包含該元素，則返回 -1*/
int lastIndexOf(Object o);
// List Iterators
/** 返回此列表元素的列表迭代器*/
ListIterator<E> listIterator();
/** 返回列表中元素的列表迭代器（按適當順序），從列表的指定位置開始*/
ListIterator<E> listIterator(int index);
// View
/** 返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之間的部分檢視*/
List<E> subList(int fromIndex, int toIndex);
}五：AbstractList
1、抽象類簡介：
同AbstractCollection定義相同、每個需要繼承List的方法都不能從List直接繼承、而是要通過AbstractList來實現、因List實現了Collection介面、所以為更一步簡化編碼、使得AbstractList繼承AbstractCollection、這樣AbstractList只需提供AbstractCollection中必須實現的方法的實現（具體是Iterator、add、size必須實現的方法、和一些為具有自己特色而重寫的方法）List相對於Collection多提供的方法的實現即可。對於AbstractList的原始碼中、需要理解獲取Iterator、ListIterator、
2、原始碼
package com.chy.collection.core;
import java.util.AbstractList;
import java.util.AbstractSequentialList;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.ListIterator;
import java.util.NoSuchElementException;
import java.util.RandomAccess;
import java.util.AbstractList.Itr;
/**
* 此類提供 List 介面的骨幹實現，以最大限度地減少實現“隨機訪問”資料儲存（如陣列）支援的該介面所需的工作。對於連續的訪問資料（如連結串列），應優先使用 AbstractSequentialList，而不是此類。
*
* 1、若子類要使用set(int index, E e)則必須自己重新實現
* 2、若子類要使用add(int index, E e)則必須自己重新實現
* 3、若子類要使用remove(int index)則必須自己從新實現
* 4、內部實現了iterator()方法、返回一個包含hasNext()、next()、remove()方法的Iterator。
* 許多方法都是由內部類來實現的
*/
public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
protected AbstractList() {
}
/**
* 將指定元素追加到List集合結尾處
*/
public boolean add(E e) {
add(size(), e);
return true;
}
abstract public E get(int index);
public E set(int index, E element) {
throw new UnsupportedOperationException();
}
public void add(int index, E element) {
throw new UnsupportedOperationException();
}
public E remove(int index) {
throw new UnsupportedOperationException();
}
// Search Operations
public int indexOf(Object o) {
ListIterator<E> e = listIterator();
if (o==null) {
while (e.hasNext())
if (e.next()==null)
return e.previousIndex();
} else {
while (e.hasNext())
if (o.equals(e.next()))
return e.previousIndex();
}
return -1;
}
public int lastIndexOf(Object o) {
ListIterator<E> e = listIterator(size());
if (o==null) {
while (e.hasPrevious())
if (e.previous()==null)
return e.nextIndex();
} else {
while (e.hasPrevious())
if (o.equals(e.previous()))
return e.nextIndex();
}
return -1;
}
// Bulk Operations
public void clear() {
removeRange(0, size());
}
public boolean addAll(int index, Collection<? extends E> c) {
boolean modified = false;
Iterator<? extends E> e = c.iterator();
while (e.hasNext()) {
add(index++, e.next());
modified = true;
}
return modified;
}
// Iterators
public Iterator<E> iterator() {
return new Itr();
}
public ListIterator<E> listIterator() {
return listIterator(0);
}
public ListIterator<E> listIterator(final int index) {
if (index<0 || index>size())
throw new IndexOutOfBoundsException("Index: "+index);
return new ListItr(index);
}
//fail-fast機制
private class Itr implements Iterator<E> {
/**
* 遊標的位置、用於獲取元素和標識是否遍歷完畢
*/
int cursor = 0;
/**
* 最後一次呼叫next或者previous返回的元素的下標、如果元素被刪除則返回-1
*/
int lastRet = -1;
/**
* 用於後面檢測在執行Iterator過程中是否被動手腳的變數
*/
int expectedModCount = modCount;
//是否還有下一個、從判斷標準中可以看出、下邊每遍歷出一個元素cursor都會++
public boolean hasNext() {
return cursor != size();
}
public E next() {
//類私有方法、檢測是否此類中元素被動過
checkForComodification();
try {
//獲取下一個元素、將返回的index元素的下標記錄下來、同時cursor自增1
E next = get(cursor);
lastRet = cursor++;
return next;
} catch (IndexOutOfBoundsException e) {
checkForComodification();
throw new NoSuchElementException();
}
}
//移除當前遍歷到的元素
public void remove() {
if (lastRet == -1)
throw new IllegalStateException();
checkForComodification();
try {
//呼叫當前的remove刪除最後被遍歷到的元素、在next()方法中記錄了此元素的idnex
AbstractList.this.remove(lastRet);
//將cursor--、繼續遍歷下一個
if (lastRet < cursor)
cursor--;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException e) {
throw new ConcurrentModificationException();
}
}
/**
* 檢測是否觸發fail-fast機制
*/
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
private class ListItr extends Itr implements ListIterator<E> {
//構造方法、初始化第一個被讀取的元素的下標
ListItr(int index) {
cursor = index;
}
//當前listIterator中cursor指向的元素是否還有上一個元素
public boolean hasPrevious() {
return cursor != 0;
}
//獲取當前ListIterator中cursor指向的元素
public E previous() {
checkForComodification();
try {
//獲取cursor上一個元素的
int i = cursor - 1;
E previous = get(i);
lastRet = cursor = i;
return previous;
} catch (IndexOutOfBoundsException e) {
checkForComodification();
throw new NoSuchElementException();
}
}
public int nextIndex() {
return cursor;
}
public int previousIndex() {
return cursor-1;
}
public void set(E e) {
if (lastRet == -1)
throw new IllegalStateException();
checkForComodification();
try {
AbstractList.this.set(lastRet, e);
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
public void add(E e) {
checkForComodification();
try {
AbstractList.this.add(cursor++, e);
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
}
public List<E> subList(int fromIndex, int toIndex) {
return (this instanceof RandomAccess ?
new RandomAccessSubList<E>(this, fromIndex, toIndex) :
new SubList<E>(this, fromIndex, toIndex));
}
// Comparison and hashing
public boolean equals(Object o) {
if (o == this)
return true;
if (!(o instanceof List))
return false;
ListIterator<E> e1 = listIterator();
ListIterator e2 = ((List) o).listIterator();
while(e1.hasNext() && e2.hasNext()) {
E o1 = e1.next();
Object o2 = e2.next();
if (!(o1==null ? o2==null : o1.equals(o2)))
return false;
}
return !(e1.hasNext() || e2.hasNext());
}
public int hashCode() {
int hashCode = 1;
Iterator<E> i = iterator();
while (i.hasNext()) {
E obj = i.next();
hashCode = 31*hashCode + (obj==null ? 0 : obj.hashCode());
}
return hashCode;
}
protected void removeRange(int fromIndex, int toIndex) {
ListIterator<E> it = listIterator(fromIndex);
for (int i=0, n=toIndex-fromIndex; i<n; i++) {
it.next();
it.remove();
}
}
protected transient int modCount = 0;
}
class SubList<E> extends AbstractList<E> {
private AbstractList<E> l;
private int offset;
private int size;
private int expectedModCount;
SubList(AbstractList<E> list, int fromIndex, int toIndex) {
if (fromIndex < 0)
throw new IndexOutOfBoundsException("fromIndex = " + fromIndex);
if (toIndex > list.size())
throw new IndexOutOfBoundsException("toIndex = " + toIndex);
if (fromIndex > toIndex)
throw new IllegalArgumentException("fromIndex(" + fromIndex +
") > toIndex(" + toIndex + ")");
l = list;
offset = fromIndex;
size = toIndex - fromIndex;
expectedModCount = l.modCount;
}
public E set(int index, E element) {
rangeCheck(index);
checkForComodification();
return l.set(index+offset, element);
}
public E get(int index) {
rangeCheck(index);
checkForComodification();
return l.get(index+offset);
}
public int size() {
checkForComodification();
return size;
}
public void add(int index, E element) {
if (index<0 || index>size)
throw new IndexOutOfBoundsException();
checkForComodification();
l.add(index+offset, element);
expectedModCount = l.modCount;
size++;
modCount++;
}
public E remove(int index) {
rangeCheck(index);
checkForComodification();
E result = l.remove(index+offset);
expectedModCount = l.modCount;
size--;
modCount++;
return result;
}
protected void removeRange(int fromIndex, int toIndex) {
checkForComodification();
l.removeRange(fromIndex+offset, toIndex+offset);
expectedModCount = l.modCount;
size -= (toIndex-fromIndex);
modCount++;
}
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}
public boolean addAll(int index, Collection<? extends E> c) {
if (index<0 || index>size)
throw new IndexOutOfBoundsException(
"Index: "+index+", Size: "+size);
int cSize = c.size();
if (cSize==0)
return false;
checkForComodification();
l.addAll(offset+index, c);
expectedModCount = l.modCount;
size += cSize;
modCount++;
return true;
}
public Iterator<E> iterator() {
return listIterator();
}
public ListIterator<E> listIterator(final int index) {
checkForComodification();
if (index<0 || index>size)
throw new IndexOutOfBoundsException(
"Index: "+index+", Size: "+size);
return new ListIterator<E>() {
private ListIterator<E> i = l.listIterator(index+offset);
public boolean hasNext() {
return nextIndex() < size;
}
public E next() {
if (hasNext())
return i.next();
else
throw new NoSuchElementException();
}
public boolean hasPrevious() {
return previousIndex() >= 0;
}
public E previous() {
if (hasPrevious())
return i.previous();
else
throw new NoSuchElementException();
}
public int nextIndex() {
return i.nextIndex() - offset;
}
public int previousIndex() {
return i.previousIndex() - offset;
}
public void remove() {
i.remove();
expectedModCount = l.modCount;
size--;
modCount++;
}
public void set(E e) {
i.set(e);
}
public void add(E e) {
i.add(e);
expectedModCount = l.modCount;
size++;
modCount++;
}
};
}
public List<E> subList(int fromIndex, int toIndex) {
return new SubList<E>(this, fromIndex, toIndex);
}
private void rangeCheck(int index) {
if (index<0 || index>=size)
throw new IndexOutOfBoundsException("Index: "+index+
",Size: "+size);
}
private void checkForComodification() {
if (l.modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
class RandomAccessSubList<E> extends SubList<E> implements RandomAccess {
RandomAccessSubList(AbstractList<E> list, int fromIndex, int toIndex) {
super(list, fromIndex, toIndex);
}
public List<E> subList(int fromIndex, int toIndex) {
return new RandomAccessSubList<E>(this, fromIndex, toIndex);
}
}六：Iterable、Iterator、ListIterator
1、Iterable介面說明及原始碼
Iterable介面中只有一個方法就是返回一個有序元素序列的迭代器Iterator
public interface Iterable<T> {
/** 返回一個元素序列的迭代器 */
Iterator<T> iterator();
}2、Iterator介面說明及原始碼
是集合依賴的介面、每個集合類或者其父類都必須實現獲取Iterator的方法、同時要提供Iterator中方法的實現、用於遍歷和作為一些方法的實現。
public interface Iterator<E> {
boolean hasNext();
E next();
void remove();
}3、ListIterator介面說明及原始碼
ListIterator繼承Iterator、用於提供額外的幾個方法、用於迭代List集合中的元素。
public interface ListIterator<E> extends Iterator<E> {
// Query Operations
/**
* 以正向遍歷列表時，如果列表迭代器有多個元素，則返回 true（換句話說，如果 next 返回一個元素而不是丟擲異常，則返回 true）。
*/
boolean hasNext();
/**
* 返回列表中的下一個元素。
*/
E next();
/**
* 如果以逆向遍歷列表，列表迭代器有多個元素，則返回 true。
*/
boolean hasPrevious();
/**
* 返回列表中的前一個元素。
*/
E previous();
/**
* 返回對 next 的後續呼叫所返回元素的索引。
*/
int nextIndex();
/**
* 返回對 previous 的後續呼叫所返回元素的索引。
*/
int previousIndex();
// Modification Operations
/**
* 從列表中移除由 next 或 previous 返回的最後一個元素（可選操作）。
*/
void remove();
void set(E e);
void add(E e);
}六：Set
1、介面簡介：
Set、作為Collection的一個子類、與List相比、其不允許有重複元素出現、存放的元素沒有索引一說、其API與Collection完全相同、只是對方法的定義不同
2、原始碼不再亂貼
七：AbstractSet
1、抽象類簡介：
同AbstractList很相似、因Set繼承與Collection介面、其也繼承AbstractCollection抽象類、由於Set的特性、他不像AbstractList一樣新增了有關索引的操作方法、他沒有新增任何方法、僅僅是實現了equals、hashCode、removeAll(Collection<?> c)方法的實現。注意：他不像AbstractList、內部提供了實現獲取Iterator的方法、他要求繼承他的子類去實現獲取Iterator的方法。
2、原始碼
package com.chy.collection.core;
import java.util.Iterator;
/**
* 此類提供 Set 介面的骨幹實現，從而最大限度地減少了實現此介面所需的工作。
* 此類並沒有重寫 AbstractCollection 類中的任何實現。它僅僅添加了 equals 和 hashCode 的實現。
*/
@SuppressWarnings("unchecked")
public abstract class AbstractSet<E> extends AbstractCollection<E> implements Set<E> {
protected AbstractSet() {
}
// Comparison and hashing
public boolean equals(Object o) {
if (o == this)
return true;
if (!(o instanceof Set))
return false;
Collection c = (Collection) o;
if (c.size() != size())
return false;
try {
return containsAll(c);
} catch (ClassCastException unused) {
return false;
} catch (NullPointerException unused) {
return false;
}
}
public int hashCode() {
int h = 0;
Iterator<E> i = iterator();
while (i.hasNext()) {
E obj = i.next();
if (obj != null)
h += obj.hashCode();
}
return h;
}
public boolean removeAll(Collection<?> c) {
boolean modified = false;
if (size() > c.size()) {
for (Iterator<?> i = c.iterator(); i.hasNext(); )
modified |= remove(i.next());
} else {
for (Iterator<?> i = iterator(); i.hasNext(); ) {
if (c.contains(i.next())) {
i.remove();
modified = true;
}
}
}
return modified;
}
}