2. 程式人生 > >ArrayList詳解

ArrayList詳解

阿新 • • 發佈：2017-07-20
ast close 部分 返回 initial mat set等 dog init

閱讀目錄

  • 什麽是ArrayList
  • ArrayList特點
  • ArrayList繼承的類和實現的接口
  • ArrayList內部數組擴容
  • ArrayList遍歷

各種原因，前兩年做C語言去了，現在重新做JAVA, 感覺自己基礎很不紮實，要好好學習啦， 先從簡單的開始~

以下內容基於jdk1.7.0_79源碼；

什麽是ArrayList

可以簡單的認為是一個動態數組；實際上ArrayList就是用數組實現的，長度不夠時，調用Arrays.copyOf方法，拷貝當前數組到一個新的長度更大的數組；

ArrayList特點

隨機訪問速度快，插入和移除性能較差(數組的特點)；

支持null元素；

有順序；

元素可以重復；

線程不安全；

ArrayList繼承的類和實現的接口

如下圖，是與ArrayList相關的接口和類，下面將一一介紹各個接口和類中的方法；

PS:ArrayList中的方法主要是由Collection接口和List接口定義的；

技術分享

Iterable接口

實現此接口以便支持foreach語法，如下代碼，ArrayList可以直接使用foreach語句遍歷元素：

技術分享 技術分享 
package com.pichen.basis.col;

import java.util.ArrayList;
import java.util.List;

public class Main {

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();
        for(int i = 0; i < 10; i++){
            list.add(i);
        }
        
        //foreach語法
        for(Integer i : list){
            System.out.print(i.toString() + " ");
        }
        
    }
}
技術分享

Collection接口

int size()方法：

返回集合的大小，在ArrayList類中有一個int類型的size私有屬性，當調用size方法時，直接返回該屬性；

boolean isEmpty()方法：

判斷集合是否為空，在ArrayList中，通過判斷size == 0來判斷集合是否為空；

boolean contains(Object o)方法：

判斷集合是否含有對象o，在ArrayList中，通過判斷indexOf(o) >= 0來判斷是否含有o對象；

查看indexOf(o)方法，代碼如下，主要功能是返回元素第一次出現時的下標索引，所以當下標索引大於等於0時，表示集合中存在該元素：

技術分享 
    public int indexOf(Object o) {
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }
技術分享

註意這裏的相等判斷，調用的是o對象的equals方法，所以在調用contains方法時，要特別關註集合中對象的equals方法，是否有被重寫過，如Integer、String的equals方法是被重寫過的，一般我們自己定義的對象，如果沒重寫equals的話，默認調用的是Object的equals方法，舉個例子，看一下就明白了：

技術分享 技術分享 
package com.pichen.basis.col;

import java.util.ArrayList;
import java.util.List;

class Dog{
}
public class ContainsTest {

    public static void main(String[] args) {
        List<Dog> dogList = new ArrayList<Dog>();
        Dog dog1 = new Dog();
        Dog dog2 = new Dog();
        dogList.add(dog1);
        System.out.println(dogList.contains(dog2));//false
        
        List<String> strList = new ArrayList<String>(); 
        strList.add("teststr");
        
        String str = new String("teststr");
        System.out.println(strList.contains(str));//true
        
    }

}
技術分享

Iterator<E> iterator()方法：

返回一個叠代器對象，用於遍歷集合，事實上，ArrayList類裏有兩個內部類ArrayList.Itr和ArrayList.ListItr，分別對應Iterator叠代器和ListIterator叠代器，後者比前者功能更加強大；從ArrayList.ListItr繼承自ArrayList.Itr就可以看出來，ListIterator叠代器支持更多的操作，如判斷前面還有沒有元素，即hasPrevious()方法，等；

Object[] toArray()方法：

將集合ArrayList轉換成Object數組,有時候需要用到數組的一些api時，可以使用該方法，註意返回的結果是Object類型的數組，如果想返回指定類型的數組，可以使用以下方法，<T> T[] toArray(T[] a);

<T> T[] toArray(T[] a)方法：

集合轉數組，返回指定類型的數組，註意入參T[] a需要指定數組存儲的空間，返回值為指定類型的數組；舉個例子，假如有一個Integer類型的集合，如果想把它轉換成Integer類型的數組，可以這樣寫：Integer[] arr = list.toArray(new Integer[list.size()]);

boolean add(E e)方法：

在集合最後面增加一個元素，在ArrayList中，其實現就是在其內部數組後面增加一個元素，不過要先保證內部數組長度足夠，如下代碼：

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

boolean remove(Object o)方法：

在集合中移除對象o，在ArrayList中，其實現較add方法復雜，涉及空對象判斷，equals比較，數組移動等，性能相對較差；

boolean containsAll(Collection<?> c)方法：

判斷是否包含集合c中的所有元素，在ArrayList中，其實現方法是遍歷集合c中的每一個元素，調用contains方法，判斷集合是否包含該元素，只要有一個不包含就返回false，如下代碼：

    public boolean containsAll(Collection<?> c) {
        for (Object e : c)
            if (!contains(e))
                return false;
        return true;
    }

boolean addAll(Collection<? extends E> c)方法：

將集合c中的所有元素加到目標集合中去，在ArrayList中，其實現是先將集合c轉換成數組，然後通過數組拷貝實現；

boolean removeAll(Collection<?> c)方法：

移除目標集合中含有‘集合c中元素’的所有元素，在ArrayList中，最終還是操作數組，性能相對較差；

boolean retainAll(Collection<?> c)方法：

移除目標集合中‘不包含集合c中元素’的所有元素，在ArrayList中removeAll方法和retainAll方法都是通過調用ArrayList的batchRemove方法來實現的，後續詳細了解該方法的實現；

void clear()方法：

移除目標集合中的所有元素，在ArrayList中，就是將其內部數組所有元素賦null；

boolean equals(Object o)和int hashCode()方法

在ArrayLisy中，上面兩個方法都被重寫，equals方法依次取出集合中的所有元素進行比較，通過元素的equals方法，判斷是否相等，全部相等返回true；

hashCode方法的計算是通過所有元素的hashCode計算得到；順便說下hashcode，在java中隨處可見，一般用在HashMap, Hashtable, HashSet等等中，可用於減少equals方法的調用，快速訪問元素等，其實就是散列表的概念，如比較元素先比較其hashcode，如果hashcode不相等，那麽這兩個元素肯定不相等，也就不用調用其equals方法了；

demo代碼:以上方法的簡單使用

技術分享 技術分享 
package com.pichen.basis.col;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

public class Test {

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();
        for(int i = 0; i < 10; i++){
            list.add(i);
        }
        
        //直接打印
        System.out.println(list.toString());
        
        //size()
        System.out.println(list.size());
        
        //contains
        System.out.println(list.contains(2));
        
        //iterator
        Iterator<Integer> iterator = list.iterator();
        while(iterator.hasNext()){
            System.out.print(iterator.next() + " ");
        }
        
        //toArray
        Object[] objArr = list.toArray();
        Integer[] intArr = list.toArray(new Integer[list.size()]);
        System.out.println("\n" + list.toArray());
        
        //add
        list.add(5);
        
        //remove
        list.remove(5);
        
        System.out.println(list);
        
        //containsAll
        System.out.println(list.containsAll(Arrays.asList(5,6)));
        
        //addAll
        list.addAll(Arrays.asList(555,666));
        System.out.println(list);
        
        //removeAll
        list.removeAll(Arrays.asList(555,666));
        System.out.println(list);
        
        //clear
        list.clear();
        System.out.println(list);
        
    }
}
技術分享

List接口

除了Collection中定義的方法為，該接口增加了以下方法

boolean addAll(int index, Collection<? extends E> c);

在ArrayList中，該方法是在指定位置處增加一個集合中的所有元素，該操作涉及數組移動；

E get(int index);

返回下標為index的元素；

E set(int index, E element);

改變下標為index的元素的值

void add(int index, E element);

在下標為index的地方插入元素element，該操作涉及數組移動；

E remove(int index);

移除下標為index的元素，該操作涉及數組移動；

int indexOf(Object o);

返回元素o的最小下標，通過調用o的equals方法與集合中的元素進行比較；

int lastIndexOf(Object o);

返回元素o的最大下標，通過調用o的equals方法與集合中的元素進行比較；

ListIterator<E> listIterator();

返回listIterator叠代器，該叠代器支持向前操作；

ListIterator<E> listIterator(int index);

返回listIterator叠代器，從特定的位置開始，該叠代器支持向前操作；

List<E> subList(int fromIndex, int toIndex);

返回下標在fromIndex和toIndex之間的元素集合；

demo代碼:以上方法的簡單使用：

技術分享 View Code

RandomAccess, Cloneable, java.io.Serializable接口

這三個接口是標識接口，裏面都是空的；

RandomAccess標識其支持快速隨機訪問；

Cloneable標識其支持對象復制；

Serializable標識其可序列化；

AbstractCollection類

大部分方法前面已經說明過了，不過該類下的contains方法、toArray方法等，遍歷的時候都是使用更加通用的叠代器方式進行遍歷；

AbstractList類

大部分方法前面已經說明過了，不過該類中有兩個私有內部類Itr和ListItr，對應的分別是兩個叠代器；

ArrayList類

ArrayList的具體實現

成員屬性：

private static final int DEFAULT_CAPACITY = 10;//初始容量

private static final Object[] EMPTY_ELEMENTDATA = {};//空ArrayList實例共享的一個空數組

private transient Object[] elementData; //真正存儲ArrayList中的元素的數組；

private int size;//存儲ArrayList的大小，註意不是elementData的長度；

除了其父接口定義的方法外，該類增加了以下方法

public ArrayList(int initialCapacity)：

構造函數，指定初始大小

public ArrayList()

構造函數，使用共享的EMPTY_ELEMENTDATA空數組

public ArrayList(Collection<? extends E> c)

構造函數，通過集合初始化ArrayList

public void trimToSize()

節省空間用的，ArrayList是通過數組實現的，大小不夠時，增加數組長度，有可能出現數組長度大於ArrayList的size情況；

public void ensureCapacity(int minCapacity)

保證ArrayList能容納minCapacity個元素；

私有方法

略

ArrayList內部數組擴容

查看ArrayList的add源碼方法，如下：

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

在往ArrayList增加e對象前，要先保證內部數組空間足夠，即調用ensureCapacityInternal判斷，查看其代碼，如下：

技術分享 
    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }
技術分享

入參minCapacity為ArrayList要保證的最小空間大小，首先判斷內部數組elementData是否是初始的空數組(當ArrayList是空實例的情況)，如果是的話，且minCapacity比DEFAULT_CAPACITY小，則設minCapacity為默認的初始容量大小DEFAULT_CAPACITY；接著調用ensureExplicitCapacity方法，查看其代碼，如下：

技術分享 
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
技術分享

首先，是對修改次數modCount加一，這裏的modCount給ArrayList的叠代器使用的，在並發操作被修改時，提供快速失敗行為（保證modCount在叠代期間不變，否則拋出ConcurrentModificationException異常，可以查看源碼859行），接著判斷minCapacity是否大於當前ArrayList內部數組長度，大於的話調用grow方法對內部數組elementData擴容，grow方法代碼如下：

技術分享 
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
技術分享

首先，獲取內部數組elementData長度，並對它的大小增加1.5倍（oldCapacity + (oldCapacity >> 1)），賦給newCapacity，當newCapacity仍然比minCapacity（要保證的最小空間大小）小的時候，直接讓newCapacity 等於minCapacity；然後再判斷newCapacity 是不是大於MAX_ARRAY_SIZE，如果大於的話，調用hugeCapacity方法，處理大容量空間的情況，該方法判斷是否溢出（拋出OutOfMemoryError），以及當minCapacity大於MAX_ARRAY_SIZE時，直接返回Integer.MAX_VALUE；最後就是真正地數組擴容了，調用Arrays.copyOf方法，拷貝舊的內部數組內容到一個新的（長度為newCapacity）的數組，並更改內部數組elementData的引用為新數組；

ArrayList遍歷

一般工作中用的比較多的是遍歷操作，ArrayList支持三種方式

  • for循環下標遍歷；
  • 叠代器(Iterator和ListIterator)；
  • foreach語句。
技術分享 
package com.pichen.basis.col;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class Test {

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();
        for(int i = 0; i < 10; i++){
            list.add(i);
        }
        
        //直接打印
        System.out.println(list.toString());
        
        //for循環
        System.out.println("for循環：");
        for(int i = 0; i < list.size(); i++){
            System.out.print(list.get(i) + " ");
        }
        
        //foreach
        System.out.println("\nforeach:");
        for(Integer i : list){
            System.out.print(i + " ");
        }
        
        //iterator
        System.out.println("\niterator:");
        Iterator<Integer> iterator = list.iterator();
        while(iterator.hasNext()){
            System.out.print(iterator.next() + " ");
        }
        
        //listIterator
        System.out.println("\nlistIterator:");
        ListIterator<Integer> listIterator = list.listIterator();
        while(listIterator.hasNext()){
            System.out.print(listIterator.next() + " ");
        }
        System.out.println();
        while(listIterator.hasPrevious()){
            System.out.print(listIterator.previous() + " ");
        }
    }
}
技術分享

ArrayList詳解

相關推薦

ArrayList詳解

ast close 部分 返回 initial mat set等 dog init 閱讀目錄 什麽是ArrayList ArrayList特點 ArrayList繼承的類和實現的接口 ArrayList內部數組擴容 ArrayList遍歷 各種原

java集合類之ArrayList詳解

int() 相等 toa isempty ont ati urn 影響 輸入 一、ArrayList源碼分析 1、全局變量 （1）默認容量（主要是通過無參構造函數創建ArrayList時第一次add執行擴容操作時指定的elementData的數組容量為10） privat

轉 Java學習 — ArrayList詳解

1、什麼是ArrayList ArrayList就是傳說中的動態陣列，用MSDN中的說法，就是Array的複雜版本，它提供瞭如下一些好處： 動態的增加和減少元素； 實現了ICollection和IList介面； 靈活的設定陣列的大小 2、如何使用

【java】ArrayList詳解

事實證明，你看完語法書之後，也不一定能寫出來程式碼，還需要不斷的來練習～ —— 小明醬lmx? ArrayList簡介 ArrayList是一個其容量能夠動態增長的動態陣列。它繼承了AbstractList，實現了List、RandomAccess, Clon

ArrayList詳解，看這篇就夠了

簡介 ArrayList 是 java 集合框架中比較常用的資料結構了。繼承自 AbstractList，實現了 List 介面。底層基於陣列實現容量大小動態變化。允許 null 的存在。同時還實現了 RandomAccess、Cloneable、Seri

Java還要再學一遍基礎（六）ArrayList詳解

ArrayList概要。 ArrayList是一個容量可變的動態陣列，繼承了AbstractList，並且AbstractList已經實現了一些基本的增刪改查，ListIterator等功能，ArrayList更關注的是內部的的陣列實現。 ArrayList

Java中的ArrayList詳解

ArrayList簡介 ArrayList是一個其容量能夠動態增長的動態陣列。它繼承了AbstractList，實現了List、RandomAccess, Cloneable, java.io.Serializable。 基本的ArrayList，長於隨

ArrayList 詳解

remove 刪除操作涉及陣列元素的複製移動！！ 比較重要的幾個元素 Object[] elementData

ArrayList詳解-原始碼分析

# ArrayList詳解-原始碼分析 ### 1. 概述 在平時的開發中，用到最多的集合應該就是ArrayList了，本篇文章將結合原始碼來學習ArrayList。 - **ArrayList是基於陣列實現的集合列表** - **支援任意性的訪問（可根據索引直接得到你想要的元素）** - **執行緒不

ArrayList擴容機制詳解

文章目錄 初始化 擴容條件 擴容細節 總結 初始化 初始化有三種方式 1.預設的構造器，將會以預設的大小來初始化內部的陣列：public ArrayList(); 2.用一個ICollection物件來構造

ArrayList的詳解

陣列一旦給定大小就是固定的，只能放同類型的不能再改，還有一種高階的可擴充的，就是arrayList類，被稱作動態陣列或者集合。 使用步驟： 1. 引用名稱空間system.collections； 2. 建立示例； 3. 引用對應的屬性或方法 程式碼示例： ArrayList list = new

Java11 ArrayList類詳解

ArrayList ArrayList是List介面的可變大小陣列的實現。實現所有可選連結串列操作，允許所有元素，包括null。除了實現了List介面之外，這個類還提供了操作用來內部儲存連結串列的陣列大小的方法（這個類大致等同於Vector，除了他是非同步的以外）。 size()、isEmpty()、ge

ArrayList 集合詳解

特點: 1.底層資料結構是陣列 2.預設陣列大小是10 3.保證了資料的有序性,按照插入順尋來儲存 4.查詢效率高,基於陣列索引來定位資料 5.集合擴容每次擴容為原大小的1.5倍. 6.集合資料可以重 方法 trimToSize():作用是去掉預留元素的位置,記憶體緊張的時候用

Java中的集合詳解，結合 ArrayList、HashSet 的區別以及HashCode的作用。

Java中的集合：      (1）Collection                           List(有序,可重複)             ArrayList         

java資料結構之：ArrayList與LinkedList詳解

前篇博文講到了Java底層怎麼知道ArrayList和LinkedList哪個是隨機訪問哪個是順序訪問的，本片博文主要介紹各自的資料特點。 ArrayList: 從他的這個建構函式我們可以知道他的底層實現就是一個Object物件陣列。 第二個建構函式構造一個空的

ArrayList中的remove方法詳解

ArrayList類中一共給出了兩種remove方法，下面來對這兩種方法詳解： 1、引數為元素下標（int型） 對於這個方法，裡面的引數是要刪除元素的下標，我們可以使用students(arraylis

JAVA中有序集合ArrayList/LinkedList/Vector 詳解

add：增加元素，兩個引數的制定位置增加 size：長度 get:獲取第i個 set：修改制定位置的元素 remove：可以放下標，也可以放元素;ps:如果刪除的元素存在多個，刪除第一個；可以remove(null);返回值：如果刪除元素了，返回true，沒有刪除返回false indexOf/lastIn

java集合類原始碼詳解-ArrayList（2）

上次關於ArrayList的結構沒有做總結。這次還是補充在自己部落格裡面吧。 ArrayList繼承自一個抽象類。實現了四個介面。 AbstractList繼承自AbstractCollection。AbstractCollection繼承自Object。 ArrayL

Java中 ArrayList、Vector和LinkedList 的使用和詳解（轉）

import java.util.*; /** * （1）ArrayList是最常用的List實現類，內部是通過陣列實現的，它允許對元素進行快速隨機訪問。陣列的缺點是每個元素之間不能含有“空隙”。 * 當陣列大小不滿足時會增加儲存能力，將已有陣

java中ArrayList用法詳解，基本用法（含增刪改查）

1、什麼是ArrayList ArrayList就是動態陣列，它提供了①動態的增加和減少元素 ②實現了ICollection和IList介面 ③靈活的設定陣列的大小ArrayList是一個其容量能夠動態增長的動態陣列。它繼承了AbstractList，實現了List、Rand