前言

AbstractList是實現List介面的一個抽象類，它的地位之與List類似於AbstractCollection之與Collection，同事，AbstractList繼承了AbstractCollection，並針對List介面給出了一些預設的實現。而且它是針對隨機訪問儲存資料的方式的，如果需要使用順序訪問儲存資料方式，還有一個AbstractSequentialList是AbstractList的子類，順序訪問時應該優先使用它。

框架圖

原始碼

接下來，我們來看一下AbstractList的原始碼，看看他針對於List介面相較於AbstractCollection

package java.util;


public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
    
    //只提供了一個protected修飾的無參構造器，供子類使用。
    protected AbstractList() {
    }

    //新增一個元素，實際上並沒有實現。
    public boolean add(E e) {
        //實際上，size()在這個方法中並沒有實現，交由子類去實現。
 

        add(size(), e);
        return true;
    }

    //抽象方法，需要子類去實現，根據索引值獲取集合中的某個元素(隨機訪問)
    abstract public E get(int index);

    //由於該集合是不可變的，所以一切可能會改變集合元素的操作都會丟擲一個UnsupportedOperationException()
    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) {
        //這裡是由AbstractList內部已經提供了Iterator, ListIterator迭代器的實現類，分別為Itr，ListItr。這裡是呼叫了一個例項化ListItr的方法
        ListIterator<E> it = listIterator();
        if (o==null) {
            while (it.hasNext())
                if (it.next()==null)
                    return it.previousIndex();
        } else {
            while (it.hasNext())
                if (o.equals(it.next()))
                    return it.previousIndex();
        }
        //如果集合中不存在該元素，返回-1
        return -1;
    }

    //獲取某個元素在集合中最後一次出現的索引
    public int lastIndexOf(Object o) {
        ListIterator<E> it = listIterator(size());
        if (o==null) {
            while (it.hasPrevious())
                if (it.previous()==null)
                    return it.nextIndex();
        } else {
            while (it.hasPrevious())
                if (o.equals(it.previous()))
                    return it.nextIndex();
        }
        return -1;
    }


    // Bulk Operations

    //清除集合中的元素
    public void clear() {
        removeRange(0, size());
    }

    //從某個索引開始，將c中的元素全部插入到集合中
    public boolean addAll(int index, Collection<? extends E> c) {
        rangeCheckForAdd(index);
        boolean modified = false;
        for (E e : c) {
            add(index++, e);
            modified = true;
        }
        return modified;
    }


    // Iterators

    //獲取Iterator介面Itr實現類迭代器
    public Iterator<E> iterator() {
        return new Itr();
    }

    //獲取從0開始（初始位置）的ListIterator的實現類ListItr
    public ListIterator<E> listIterator() {
        return listIterator(0);
    }

    //獲取從索引等於index的位置的迭代器
    public ListIterator<E> listIterator(final int index) {
        rangeCheckForAdd(index);
		return new ListItr(index);
    }

    /**
     *	內部實現了Iterator介面的實現類Itr
     */
    private class Itr implements Iterator<E> {
       
        //游標位置
        int cursor = 0;
		
        //上一次迭代到的元素的游標位置，如果是末尾會置為-1
        int lastRet = -1;
	
        //併發標誌，如果兩個值不一致，說明發生了併發操作，就會報錯
        int expectedModCount = modCount;

        //判斷是否存在下一條資料，即迭代器的位置是否走到尾 
        public boolean hasNext() {
            //如果游標位置不等於集合個數，說明迭代器沒有走到末尾，返回true
            return cursor != size();
        }

        //獲取下一個元素
        public E next() {
            //判斷是否有併發操作
            checkForComodification();
            try {
                int i = cursor;
                //通過索引位置來獲取元素
                E next = get(i);
                lastRet = i;
                //每次將+1，將迭代器位置向後移動一位
                cursor = i + 1;
                return next;
            } catch (IndexOutOfBoundsException e) {
                //時刻檢查是否有併發操作
                checkForComodification();
                throw new NoSuchElementException();
            }
        }

        //刪除上一次迭代器越過的元素
        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
       			//呼叫需要子類去實現的remove方法
                AbstractList.this.remove(lastRet);
                if (lastRet < cursor)
                    cursor--;
                //每次刪除後，將lastRet置為-1，防止連續的刪除
                lastRet = -1;
                //將修改次數賦給迭代器對物件的結構修改次數這個會在下面進行詳解
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException e) {
                //如果出現索引越界，說明發生了併發的操作導致，所以丟擲一個併發操作異常。
                throw new ConcurrentModificationException();
            }
        }

        //判斷是否發生了併發操作
        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

    //繼承自Itr的ListIterator的實現類ListItr
    private class ListItr extends Itr implements ListIterator<E> {
        
        //指定游標位置等於索引的迭代器構造
        ListItr(int index) {
            cursor = index;
        }

        //如果不是第一位，返回true
        public boolean hasPrevious() {
            return cursor != 0;
        }

        //獲取上一位的元素，這裡在後面會有畫圖幫助理解
        public E previous() {
            checkForComodification();
            try {
                //這裡和父類的寫法略有不同，先將游標的位置進行減一
                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 < 0)
                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 {
                //設定新增的位置為當前游標所在的位置
                int i = cursor;
                AbstractList.this.add(i, e);
                //這裡講lastRet設定為-1，即新增的元素不允許立即刪除
                lastRet = -1;
                //新增後，將游標移到
                cursor = i + 1;
                //迭代器併發標誌和集合併發標誌統一
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                //如果出現了索引越界，說明發生了併發操作
                throw new ConcurrentModificationException();
            }
        }
    }

    //切取子List
    public List<E> subList(int fromIndex, int toIndex) {
        //是否支援隨機訪問
        return (this instanceof RandomAccess ?
                new RandomAccessSubList<>(this, fromIndex, toIndex) :
                new SubList<>(this, fromIndex, toIndex));
    }

    // Comparison and hashing

    //通過迭代器來遍歷進行判斷每項是否相等來重寫equals方法
    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());
    }

    //重寫hashCode
    public int hashCode() {
        int hashCode = 1;
        for (E e : this)
            hashCode = 31*hashCode + (e==null ? 0 : e.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;

    //判斷索引是否越界
    private void rangeCheckForAdd(int index) {
        if (index < 0 || index > size())
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    private String outOfBoundsMsg(int index) {
        return "Index: "+index+", Size: "+size();
    }
}

//繼承自AbstractList的內部類SubList，代表了它父類的一部分
class SubList<E> extends AbstractList<E> {
   
    private final AbstractList<E> l;
    private final int offset;
    private int size;

    //根據父類來構造一個SubList
    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;
        //修改次數（併發標誌）和父類保持一致
        this.modCount = l.modCount;
    }

    //實際上還是呼叫的父類的set方法和get方法
    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);
    }

    //size = toIndex - fromIndex;
    public int size() {
        checkForComodification();
        return size;
    }

    public void add(int index, E element) {
        rangeCheckForAdd(index);
        checkForComodification();
        //實際上還是在父類上進行新增
        l.add(index+offset, element);
        this.modCount = l.modCount;
        //然後把size + 1
        size++;
    }

    public E remove(int index) {
        rangeCheck(index);
        checkForComodification();
        //實際上還是在父類上進行刪除
        E result = l.remove(index+offset);
        this.modCount = l.modCount;
        size--;
        return result;
    }

    protected void removeRange(int fromIndex, int toIndex) {
        checkForComodification();
        //呼叫父類的removeRange方法
        l.removeRange(fromIndex+offset, toIndex+offset);
        this.modCount = l.modCount;
        size -= (toIndex-fromIndex);
    }

    public boolean addAll(Collection<? extends E> c) {
        return addAll(size, c);
    }

    public boolean addAll(int index, Collection<? extends E> c) {
        
        rangeCheckForAdd(index);
        int cSize = c.size();
        if (cSize==0)
            return false;

        checkForComodification();
        //在當前的子集合開始的位置進行插入
        l.addAll(offset+index, c);
        this.modCount = l.modCount;
        size += cSize;
        return true;
    }

    public Iterator<E> iterator() {
        return listIterator();
    }

    public ListIterator 
 

            
  
           

              
              
            
            
相關推薦
			   
            
            
            
 

    

    
    
Java基礎系列（四十二）：集合之AbstractList
     
  
 
  
  
 前言 
 AbstractList是實現List介面的一個抽象類，它的地位之與List類似於AbstractCollection之與Collection，同事，AbstractList繼承了AbstractCollection，並針對List介面給出了一些預設的實現。而且它是針對隨機訪問 

  
 

    

    
    
Java基礎系列（四十五）：集合之Map
     
  
 
  
  
 簡介 
 Map是一個介面，代表的是將鍵對映到值的物件。一個對映不能包含重複的鍵，每個鍵最多隻能對映到一個值。 
 Map 介面提供了三種collection檢視，允許以鍵集、值集或鍵-值對映關係集的形式檢視某個對映的內容。對映順序 定義為迭代器在對映的 collection 檢視上返回 

  
 

    

    
    
Java基礎系列（四十一）：集合之List
     
  
 
  
  
 前言 
 List是繼承自Collection的一個子介面，它提供了一個有序的集合，在這個集合中我們可以使用索引去獲取集合中的值，同時，我們也可以通過迭代器去訪問集合中的元素，第一種方法被稱為隨機訪問，因為我們可以按照任意的順序去訪問元素，而使用迭代器就必須順序的去訪問元素。 
 結構圖 

  
 

    

    
    
Java基礎系列（四十七）：集合之AbstractMap
     
  
 
  
  
 AbstractMap 
 AbstractMap和AbstractList，AbstractCollection等抽象類類似，它實現了Map介面的部分方法，提供了一些基礎的實現，我們耳熟能詳的HashMap, TreeMap, ConcurrentHashMap 都是他的子類。 
 構 

  
 

    

    
    
Java基礎系列（三十九）：集合之Collection
     
  
 
  
  
 Collection是在前文中已經介紹過了，他是兩種集合型別之一的父介面，首先我們來看一下它的框架結構 
 框架圖 
  
 可以看出，作為頂級的框架，Collection僅僅是繼承了Iterable介面，接下來，我們來看一下Iterable的原始碼，看看有什麼收穫。 
 public  

  
 

    

    
    
Java基礎系列（四十六）：Set & AbstractSet
     
  
 
  
  
 Set 
 Set繼承了Collection介面，它本身也是一個介面，代表一種不能擁有重複元素的容器型別，更確切的說，集合不包含一對元素e1和e2 ，使得e1.equals(e2) 。 
 通過Set的一些實現，我們可以發現，Set是基於Map進行實現的，所以Set取值時不保證資料和存入 

  
 

    

    
    
Java基礎系列（三十二）：斷言 + 日誌入門
     
  
 
  
  
 斷言 
 在Java語言中，給出了3種處理系統錯誤的機制： 
  
   
   丟擲一個異常 
   日誌 
   使用斷言 
   
  
 那我們應該在什麼情況下去使用斷言呢？ 
  
   
   斷言失敗是致命的，不可恢復的錯誤 
   斷言失敗只用於開發和測試階段。 
    

  
 

    

    
    
Java基礎系列（三十八）：集合總覽
     
  
 
  
  
 前言 
 在我們日常的開發中，集合佔據著舉足輕重的地位。在不同的情況下，我們會去選擇效能更佳（或更安全的）集合類作為一個容器去儲存資料。在接下來的幾節中，我會帶著大家對於集合的知識進行一次系統的深入梳理，相信梳理過後，面試或日常開發再遇到有關集合的問題對我們來說都不會是問題了。 
 總覽 

  
 

    

    
    
Java基礎系列（三十七）：泛型繼承，萬用字元，泛型反射
     
  
 
  
  
 泛型型別的繼承規則 
 首先，我們來看一個類和它的子類，比如 Fruit 和 Apple。但是Pair<Apple>是Pair<Fruit>的一個子類麼？並不是。比如下面的這段程式碼就會編譯失敗： 
 Apple[] apples = ...;
Pair<F 

  
 

    

    
    
Java基礎系列（三十六）：泛型中需要注意的地方
     
  
 
  
  
 一、不能用型別引數代替基本型別 
 因為型別擦除之後，原本的型別會被替代為Object型別的域，而Object不能儲存基本型別的值。就是說沒有Pair<double>，取而代之的是該基本型別的包裝器型別Pair<Double> 
 二、執行時型別查詢之適用於原始型 

  
 

    

    
    
Java基礎系列（三十五）：泛型進階
     
  
 
  
  
 型別變數的限定 
 有時，類或方法需要對型別變數加以約束，就像下面這樣： 
 class ArrayAlg {
   public static <T extends Comparable> Pair<T> minmax(T[] a) {
      if (a  

  
 

    

    
    
Java基礎系列（三十一）：異常
     
  
 
  
  
 為什麼有異常機制 
 假如在一個Java程式執行期間出現了一個錯誤，這個錯誤可能是由於檔案包含了錯誤的資訊，或者由於網路連接出現超時，或者就因為使用了無效的陣列下標，或者試圖使用一個沒有賦值的物件（null）造成的。 
 當這些錯誤出現的時候，我們希望程式可以返回到一種安全的狀態或者允許 

  
 

    

    
    
Java基礎系列（四十四）：集合之ArrayList
     
  
 
  
  
 簡介 
 ArrayList與Vector非常相似，他們都是基於陣列實現的集合，都可以動態擴容，只不過Vector是同步的，所需的資源較多，而且比較老，有一些缺點，所以我們現在更多的是去使用ArrayList，而不是Vector。下面，我們在閱讀原始碼的過程中遇到的一些問題對ArrayL 

  
 

    

    
    
Java基礎系列（四十）：集合之AbstractCollection
     
  
 
  
  
 前言 
 （PS：上週由於準備自考，更新延誤了一些，見諒！） AbstractCollection類是Collection介面的一個實現類，它只是為了給我們提供了一些最基礎的介面的實現，在實際的應用中，我們並不會去使用這個類來封裝一些資訊，接下來我們首先去看一下這個類的繼承關係圖。 
  

  
 

    

    
    
Java架構學習（四十二）Zookeeper基礎&ZK概述&ZK資料結構&windows搭建ZK&Java操作ZK&ZK建立臨時節點&ZK的Watcher事件通知&架構面試
     
 
							
							
							一、Zookeeper概述
1、什麼是Zookeeper？
答：Zookeeper是分散式開源框架，是分散式協調工具。
2、應用場景：
答：dubbo 是rpc遠端呼叫框架+Zookeeper作為註冊中心,(命名服務)
	釋出訂閱 --- wathcher 對z 

  
 

    

    
    
Java開發筆記（四十二）日曆工具的常見應用
     
  
 
  
  
 前面介紹了日曆工具Calendar的基本用法，乍看起來Calendar與Date兩個半斤八兩，似乎沒有多大區別，那又何苦庸人自擾鼓搗一個新玩意呢？顯然這樣小瞧了Calendar，其實它的作用大著呢，接下來不妨深入探討一下Calendar的幾種實際應用，主要包括：Calendar和Date 

  
 

    

    
    
【鏈塊技術50期】區塊鏈技術基礎語言（三十二）：Go語言網路程式設計（下）
     
  
 
 原文連結：區塊鏈技術基礎語言（三十二）：Go語言網路程式設計（下） 
   
 本文緊接上文所述，講解socket程式設計和HTTP程式設計。 
 一、socket程式設計 
 在上一節我們介紹了網路體系的五層模型，介紹了每層模型所遵守的協議。TCP/IP是一個協議族，它由網路層的IP協議 

  
 

    

    
    
Java基礎系列（三十四）：泛型入門
     
  
 
  
  
 為什麼需要泛型 
 使用泛型機制編寫的程式碼要比那些雜亂的使用Object變數，然後再進行強制型別轉換的程式碼具有更好的安全性和可讀性，也就是說使用泛型機制編寫的程式碼可以被很多不同型別的物件所重用。 
 我們先來看看泛型程式設計的機制是如果演變的，這樣可以讓我們對泛型的作用有一個更深的 

  
 

    

    
    
Java基礎系列（四十三）：集合之Vector&Stack
     
  
 
  
  
 Vector 
 簡介 
 Vector是一種實現了動態陣列的集合，何為動態陣列呢？即長度可以自動增長的陣列，它是執行緒同步的，也就是說同一時刻只有一個執行緒可以寫Vector，可以避免多執行緒同時寫引起的不一致性，但是比較消耗資源。接下來，我們來看Vector的原始碼。 
 原始碼 
 

  
 

    

    
    
Java基礎系列（三十）：區域性內部類
     
  
 
  
  
 What 
 區域性內部類就是定義在某個方法內部的內部類，它的作用域僅限於這個方法。 
 Why 
 當我們在外圍類中定義的內部類僅僅在某個方法中使用了一次，這種情況下，我們就可以選擇去使用區域性內部類。 
 How 
 以上節課的例子繼續講解，由於TestListener這個內部類僅僅