ArrayList详解

最新推荐文章于 2025-06-27 14:52:08 发布
原创 最新推荐文章于 2025-06-27 14:52:08 发布 · 801 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

1.ArrayList简介：

ArrayList继承关系:

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

  1. ArrayList是基于数组实现的，是一个动态数组，其容量能自动增长，类似于C语言中的动态申请内存，动态增长内存。

  2. ArrayList不是线程安全的，只能用在单线程环境下，多线程环境下可以考虑用 Collections.synchronizedList(List l)函数返回一个线程安全的ArrayList类，也可以使用concurrent并发包下的CopyOnWriteArrayList类。

  3. ArrayList实现了Serializable接口，因此它支持序列化，能够通过序列化传输，实现了RandomAccess接口，支持快速随机访问，实际上就是通过下标序号进行快速访问，实现了Cloneable接口，能被克隆。

2、ArrayList 成员变量：

序列版本号：

private static final long serialVersionUID = 8683452581122892189L;

内部结构是一个Object类型的数组：

private transient Object[] elementData;

有关键字transient修饰这个Object数组，那么ArrayList中的数据还可以通过持久化保存下来吗？
答：transient默认是不被序列化的。但是，ArrayList实现了Serializable的writeObject()，readObject()方法，实现了自己定义的持久化方式。

/**
     * Reconstitute the <tt>ArrayList</tt> instance from a stream (that is,
     * deserialize it).
     */
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
    // Read in size, and any hidden stuff
    s.defaultReadObject();

        // Read in array length and allocate array
        int arrayLength = s.readInt();
        Object[] a = elementData = new Object[arrayLength];

    // Read in all elements in the proper order.
    for (int i=0; i<size; i++)
            a[i] = s.readObject();
    }

ArrayList中实际数据的数量 ：

 private int size;

3、ArrayList构造函数:

1、ArrayList无参构造函数。默认容量是10 。

public ArrayList() {
    this(10);
    }

2、ArrayList带容量大小的构造函数

public ArrayList(int initialCapacity) {
    super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);
    this.elementData = new Object[initialCapacity];
    }

3、 创建一个包含collection的ArrayList

public ArrayList(Collection<? extends E> c) {
    elementData = c.toArray();
    size = elementData.length;
    // c.toArray might (incorrectly) not return Object[] (see 6260652)
    if (elementData.getClass() != Object[].class)
        elementData = Arrays.copyOf(elementData, size, Object[].class);
    }

4、ArrayList常用方法

1、add()方法：

    // 确定ArrarList的容量。    
    // 若ArrayList的容量不足以容纳当前的全部元素，设置 新的容量=“(原始容量x3)/2 + 1”    
    public void ensureCapacity(int minCapacity) {    
        // 将“修改统计数”+1，该变量主要是用来实现fail-fast机制的    
        modCount++;    
        int oldCapacity = elementData.length;    
        // 若当前容量不足以容纳当前的元素个数，设置 新的容量=“(原始容量x3)/2 + 1”    
        if (minCapacity > oldCapacity) {    
            Object oldData[] = elementData;    
            int newCapacity = (oldCapacity * 3)/2 + 1;    
            //如果还不够，则直接将minCapacity设置为当前容量  
            if (newCapacity < minCapacity)    
                newCapacity = minCapacity;    
            elementData = Arrays.copyOf(elementData, newCapacity);    
        }    
    }    

    // 添加元素e    
    public boolean add(E e) {    
        // 确定ArrayList的容量大小    
        ensureCapacity(size + 1);  // Increments modCount!!    
        // 添加e到ArrayList中    
        elementData[size++] = e;    
        return true;    
    } 


    // 将e添加到ArrayList的指定位置    
    public void add(int index, E element) {    
        if (index > size || index < 0)    
            throw new IndexOutOfBoundsException(    
            "Index: "+index+", Size: "+size);    

        ensureCapacity(size+1);  // Increments modCount!!    
        System.arraycopy(elementData, index, elementData, index + 1,    
             size - index);    
        elementData[index] = element;    
        size++;    
    }    

    // 将集合c追加到ArrayList中    
    public boolean addAll(Collection<? extends E> c) {    
        Object[] a = c.toArray();    
        int numNew = a.length;    
        ensureCapacity(size + numNew);  // Increments modCount    
        System.arraycopy(a, 0, elementData, size, numNew);    
        size += numNew;    
        return numNew != 0;    
    }

当ArrayList容量不足以容纳全部元素时，ArrayList会重新设置容量：新的容量=“(原始容量x3)/2 + 1”。

2、remove()方法：

    /**
     * Removes the element at the specified position in this list.
     * Shifts any subsequent elements to the left (subtracts one from their
     * indices).
     *
     * @param index the index of the element to be removed
     * @return the element that was removed from the list
     * @throws IndexOutOfBoundsException {@inheritDoc}
     */    
    public E remove(int index) {    
        RangeCheck(index);    

        modCount++;    
        E oldValue = (E) elementData[index];    

        int numMoved = size - index - 1;    
        if (numMoved > 0)    
            System.arraycopy(elementData, index+1, elementData, index,    
                 numMoved);    
        elementData[--size] = null; // Let gc do its work    

        return oldValue;    
    }

   /**
     * Removes the first occurrence of the specified element from this list,
     * if it is present.  If the list does not contain the element, it is
     * unchanged.  More formally, removes the element with the lowest index
     * <tt>i</tt> such that
     * <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>
     * (if such an element exists).  Returns <tt>true</tt> if this list
     * contained the specified element (or equivalently, if this list
     * changed as a result of the call).
     *
     * @param o element to be removed from this list, if present
     * @return <tt>true</tt> if this list contained the specified element
     */
    // 删除元素    
    public boolean remove(Object o) {    
        if (o == null) {    
            for (int index = 0; index < size; index++)    
            if (elementData[index] == null) {    
                fastRemove(index);    
            return true;    
            }    
        } else {    
            // 便利ArrayList，找到“元素o”，则删除，并返回true。    
            for (int index = 0; index < size; index++)    
            if (o.equals(elementData[index])) {    
                fastRemove(index);    
            return true;    
            }    
        }    
        return false;    
    }

3、查找方法：

//正向查找到指定元素，返回索引
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;
    }
//反向查找到指定元素，返回索引
public int lastIndexOf(Object o) {
    if (o == null) {
        for (int i = size-1; i >= 0; i--)
        if (elementData[i]==null)
            return i;
    } else {
        for (int i = size-1; i >= 0; i--)
        if (o.equals(elementData[i]))
            return i;
    }
    return -1;
    }
//获得索引元素处的值
public E get(int index) {
    RangeCheck(index);

    return (E) elementData[index];
    }

4、修改方法：

public E set(int index, E element) {
    RangeCheck(index);

    E oldValue = (E) elementData[index];
    elementData[index] = element;
    return oldValue;
    }

5、contains(Object o)方法：

public boolean contains(Object o) {
    return indexOf(o) >= 0;
    }

6、clone()方法：

public Object clone() {
    try {
        ArrayList<E> v = (ArrayList<E>) super.clone();
        // 将当前ArrayList的全部元素拷贝到v中
        v.elementData = Arrays.copyOf(elementData, size);
        v.modCount = 0;
        return v;
    } catch (CloneNotSupportedException e) {
        // this shouldn't happen, since we are Cloneable
        throw new InternalError();
    }
    }

5、ArrayList遍历方式：

1、通过迭代器遍历。即通过Iterator去遍历。

    Integer value = null;  
    Iterator iter = list.iterator();  
    while (iter.hasNext()) {  
        value = (Integer)iter.next();  
    }

2、 随机访问，通过索引值去遍历。由于ArrayList实现了RandomAccess接口，它支持通过索引值去随机访问元素。

    Integer value = null;  
    int size = list.size();  
    for (int i=0; i<size; i++) {  
        value = (Integer)list.get(i);          
    }

3、for循环遍历

Integer value = null;  
for (Integer integ:list) {  
    value = integ;  
}

6、总结：

1、注意其三个不同的构造方法。无参构造方法构造的ArrayList的容量默认为10，带有Collection参数的构造方法，将Collection转化为数组赋给ArrayList的实现数组elementData。

2、注意扩充容量的方法ensureCapacity。ArrayList在每次增加元素（可能是1个，也可能是一组）时，都要调用该方法来确保足够的容量。设置新的容量为旧的容量的1.5倍加1。

3、注意ArrayList的两个转化为静态数组的toArray方法。
第一个，Object[] toArray()方法。该方法有可能会抛出java.lang.ClassCastException异常，如果直接用向下转型的方法，将整个ArrayList集合转变为指定类型的Array数组，便会抛出该异常，而如果转化为Array数组时不向下转型，而是将每个元素向下转型，则不会抛出该异常，显然对数组中的元素一个个进行向下转型，效率不高，且不太方便。

第二个， T[] toArray(T[] a)方法。该方法可以直接将ArrayList转换得到的Array进行整体向下转型（转型其实是在该方法的源码中实现的），且从该方法的源码中可以看出，参数a的大小不足时，内部会调用Arrays.copyOf方法，该方法内部创建一个新的数组返回。

5、ArrayList基于数组实现，可以通过下标索引直接查找到指定位置的元素，因此查找效率高，但每次插入或删除元素，就要大量地移动元素，插入删除元素的效率低。

6、在查找给定元素索引值等的方法中，源码都将该元素的值分为null和不为null两种情况处理，ArrayList中允许元素为null。

参考资料：
Java容器类—ArrayList

Java：ArrayList详解
2301_79783967的博客
03-28 2699
在集合框架中，ArrayList是一个普通的类，实现了List接口，具体框架图如下：不带参数 没有初始化，默认为空，只是一个数组引用常量数组，没有分配内存，长度是0 因此不带参数的构造并没有给数组大小 带参数初始化数组大小如果参数是0的情况下，就会是空数组如果是参数小于0就会抛出异常 另一个带一个参数的构造方法参数Collection是一个接口，只要是实现了该接口的都可以进行传递尖括号里的‘？’是通配符，尖括号里面可以写E或者E的子类举例： ArrayList实现了Collection接口，array
什么是 ArrayList
weixin_33826268的博客
02-24 3078
简介 ArrayList 是 java 集合框架中比较常用的数据结构了。继承自 AbstractList，实现了 List 接口。底层基于数组实现容量大小动态变化。允许 null 的存在。同时还实现了 RandomAccess、Cloneable、Serializable 接口，所以ArrayList 是支持快速访问、复制、序列化的。 成员变量 ArrayList 底层是基于数组来实现容量大小动态...
ArrayList 带参数（Collection<? extends E> c）构造器的一点见解
qq_22083043的博客
08-23 2768
先贴上源码： public class ArrayList extends AbstractList         implements List, RandomAccess, Cloneable, java.io.Serializable {       private static final Object[] EMPTY_ELEMENTDATA = {};     priv
ArrayList之坑点
05-15 958
ConcurrentModificationException异常详细原因参见 http://www.cnblogs.com/dolphin0520/p/3933551.html缘起iterator简单来说:在iterator中遍历以及删除时都会去执行如下检查final void checkForComodification() { if (modCount != expec
ArrayList 详解
热门推荐
Harbour_zhang的博客
02-18 2万+
ArrayList 是 java 集合框架中比较常用的数据结构了。继承自 AbstractList，实现了 List 接口。底层基于数组实现容量大小动态变化。允许 null 的存在。同时还实现了 RandomAccess、Cloneable、Serializable 接口，所以ArrayList 是支持快速访问、复制、序列化的。 成员变量 ArrayList 底层是基于数组来实现容量大小动态变化的。 /** * The size of the ArrayList (the number of element
Java ArrayList 详解
T_Y_F_的博客
12-05 1130
Java ArrayList 详解
259. ArrayList详解
最新发布
2303_79132118的博客
06-27 669
每次我们往 ArrayList 里加元素，其实就是往这个数组里加。如果数组满了，ArrayList 会自动扩容，扩容的策略是原来容量的1.5倍，比如原来容量是10，加到第11个的时候，容量就会变成15。扩容的时候，底层是用 Arrays.copyOf 这个方法，先新建一个更大的数组，再把原有的数据复制过去，然后把 elementData 指向新的数组。所以总结一下，ArrayList底层就是数组，扩容是按1.5倍来扩，扩容的时候会拷贝数组，扩容比较消耗性能，建议有大数据量的时候提前指定容量大小。
Java中ArrayList详解
weixin_74375289的博客
05-28 492
泛型:限定集合中存储数据的类型(下面String即为泛型)定义一个名为list，类型为String的集合 4.获取元素 E get(int index) //获取指定索引的元素
Java ArrayList详解
qq_35939417的博客
01-20 6165
简介 ArrayList是List接口的典型实现，它是基于数组的，里面封装了一个动态的、允许再分配的Object[]数组。 学过数据结构的应该都知道线性表的顺序存储结构，ArrayList就是线性表的顺序存储结构，所以它存、取和求表长的时间复杂度为O(1);插入和删除元素的时间复杂度为O(n).好多初学者没有搞明白存和插入的区别，这里稍作解释。存是指往某个位置放一个元素，不涉及其他位置元素的移动。以排队为例，队伍中第三个位置已经给你预留好了（包括空间），你直接走过去站在那就行，不管那里有没有人，有人你就替换
精选资源
java关键字ArrayList详解
07-04
ArrayList是Java集合框架中的一种重要实现，它是List接口的一个具体类，主要特点是基于数组实现，提供了灵活的元素存储和操作。ArrayList支持动态扩容，可以根据需要自动增加数组的大小，这使得在不知道确切元素数量...
ArrayList详解和使用示例_动力节点Java学院整理
08-30
"ArrayList详解和使用示例" ArrayList是Java中的一种动态数组，相比于传统数组，它的容量可以动态增长。在本文中，我们将对ArrayList进行详细的介绍，并提供相关的使用示例代码。 ArrayList简介 ArrayList是一个...
C# 中 Array和 ArrayList详解及区别
12-31
C# 中 Array和 ArrayList详解及区别 一、Array 的用法 type[] typename=new type[size];  或者  type[] typename=new type[]{ };  Array类型的变量在声明的同时必须进行实例化(如果初始化至少得初始化数组...
Java的Clone方法
JerryBurning的专栏
08-28 2万+
1、什么是”clone”？ 在实际编程过程中，我们常常要遇到这种情况：有一个对象A，在某一时刻A中已经包含了一些有效值，此时可能 会需要一个和A完全相同新对象B，并且此后对B任何改动都不会影响到A中的值，也就是说，A与B是两个独立的对象，但B的初始值是由A对象确定的。在 Java语言中，用简单的赋值语句是不能满足这种需求的。要满足这种需求虽然有很多途径，但实现clone（）方法是其中最简单，也是最
二叉树的创建(前序中序创建二叉树、中序后序创建二叉树)
JerryBurning的专栏
09-03 2万+
前序中序创建二叉树: preOrder:{1,2,4,7,3,5,6,8} inOrder:{4,7,2,1,5,3,8,6}
浅谈对java多态的理解
JerryBurning的专栏
04-15 5674
浅谈对java多态的理解
java多线程之三
JerryBurning的专栏
08-25 5296
临界资源：虽然多个线程可以共享系统中的各种资源，但是对于一些资源一次只能被一个线程访问，这种资源叫做临界资源。对于临界资源不采取互斥的访问，可能会引发线程安全问题。
Java容器类
JerryBurning的专栏
07-23 3011
java容器类
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值