ArrayList详解

最新推荐文章于 2024-01-11 15:51:55 发布
转载 最新推荐文章于 2024-01-11 15:51:55 发布 · 234 阅读 · 0
文章标签：

#ArrayList #集合框架

1、简介


ArrayList是Java集合框架中的一个重要的类，它继承于AbstractList，实现了List接口，是一个长度可变的集合，提供了增删改查的功能。集合中允许null的存在。ArrayList类还是实现了RandomAccess接口，可以对元素进行快速访问。实现了Serializable接口，说明ArrayList可以被序列化，还有Cloneable接口，可以被复制。和Vector不同的是，ArrayList不是线程安全的。

下图是ArrayList的结构层次：



2、主要方法详解


ArrayList底层使用的是Java数组来存储集合中的内容，这个数组是Object类型的：

[java]  view plain  copy
  1. transient Object[] elementData;  

同时，elementData的访问级别为包内私有，是为了使内部类能够访问到其中的元素。

使用int类型的size表示数组中元素的个数：

[java]  view plain  copy
  1. private int size;  

为了对应不同的构造函数，ArrayList使用了不同的数组：

[java]  view plain  copy
  1. /** 
  2.  * Shared empty array instance used for empty instances. 
  3.  */  
  4. private static final Object[] EMPTY_ELEMENTDATA = {};  
  5.   
  6. /** 
  7.  * Shared empty array instance used for default sized empty instances. We 
  8.  * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when 
  9.  * first element is added. 
  10.  */  
  11. private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};  

代码中有个常量，表示数组的默认容量，大小为10：

[java]  view plain  copy
  1. /** 
  2.  * Default initial capacity. 
  3.  */  
  4. private static final int DEFAULT_CAPACITY = 10;  
（1）构造函数

常量EMPTY_ELEMENTDATA和DEFAULTCAPACITY_EMPTY_ELEMENTDATA是为了初始化elementData的。如果为无参构造函数，使用DEFAULTCAPACITY_EMPTY_ELEMENTDATA；如果为含参构造函数，使用EMPTY_ELEMENTDATA：

[java]  view plain  copy
  1. public ArrayList(int initialCapacity) {  
  2.     if (initialCapacity > 0) {  
  3.         this.elementData = new Object[initialCapacity];  
  4.     } else if (initialCapacity == 0) {  
  5.         this.elementData = EMPTY_ELEMENTDATA;  
  6.     } else {  
  7.         throw new IllegalArgumentException("Illegal Capacity: "+  
  8.                                            initialCapacity);  
  9.     }  
  10. }  
  11.   
  12. /** 
  13.  * Constructs an empty list with an initial capacity of ten. 
  14.  */  
  15. public ArrayList() {  
  16.     this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;  
  17. }  

使用上述构造函数，elementData中没有元素，size为0，不过elementData的长度有可能不同。

ArrayList还提供了使用集合构造的构造函数：

[java]  view plain  copy
  1. public ArrayList(Collection<? extends E> c) {  
  2.     elementData = c.toArray();  
  3.     if ((size = elementData.length) != 0) {  
  4.         // c.toArray might (incorrectly) not return Object[] (see 6260652)  
  5.         if (elementData.getClass() != Object[].class)  
  6.             elementData = Arrays.copyOf(elementData, size, Object[].class);  
  7.     } else {  
  8.         // replace with empty array.  
  9.         this.elementData = EMPTY_ELEMENTDATA;  
  10.     }  
  11. }  
函数首先将集合c转化为数组，然后检查转化的类型，如果不是Object[]类型，使用Arrays类中的copyOf方法进行复制；同时，如果c中没有元素，使用EMPTY_ELEMENTDATA初始化。

（2）trimToSize()

由于表示集合中元素个数的size和表示集合容量的elementData.length可能不同，在不太需要增加集合元素的情况下容量有浪费，可以使用trimToSize方法减小elementData的大小。代码如下：

[java]  view plain  copy
  1. public void trimToSize() {  
  2.     modCount++;  
  3.     if (size < elementData.length) {  
  4.         elementData = (size == 0)  
  5.           ? EMPTY_ELEMENTDATA  
  6.           : Arrays.copyOf(elementData, size);  
  7.     }  
  8. }  
代码中有个modCount，这个是继承自AbstractList中的字段，表示数组修改的次数，数组每修改一次，就要增加modCount。可以看到，ArrayList的底层使用Object[]类型的数组存储内容，使用Arrays类来处理数组中的内容。

（3）ensureCapacity(int minCapacity)

这个方法可以用来保证数组能够包含给定参数个元素，也就是说如果需要的话可以扩大数组的容量。主要代码：

[java]  view plain  copy
  1. public void ensureCapacity(int minCapacity) {  
  2.     int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)  
  3.         // any size if not default element table  
  4.         ? 0  
  5.         // larger than default for default empty table. It's already  
  6.         // supposed to be at default size.  
  7.         : DEFAULT_CAPACITY;  
  8.   
  9.     if (minCapacity > minExpand) {  
  10.         ensureExplicitCapacity(minCapacity);  
  11.     }  
  12. }  
首先检查是不是DEFAULTCAPACITY_EMPTY_ELEMENTDATA，如果是的话，说明长度为10，如果不是，将minExpand设为0，比较与minCapacity的大小，然后调用私有函数进行操作：

[java]  view plain  copy
  1. private void ensureCapacityInternal(int minCapacity) {  
  2.     if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {  
  3.         minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);  
  4.     }  
  5.   
  6.     ensureExplicitCapacity(minCapacity);  
  7. }  
首先minCapacity和默认大小（10）比较，如果需要扩大容量，继续调用：

[java]  view plain  copy
  1. private void ensureExplicitCapacity(int minCapacity) {  
  2.     modCount++;  
  3.   
  4.     // overflow-conscious code  
  5.     if (minCapacity - elementData.length > 0)  
  6.         grow(minCapacity);  
  7. }  
然后比较minCapacity和当前长度的大小，如果需要扩容，调用grow方法：

[java]  view plain  copy
  1. private void grow(int minCapacity) {  
  2.     // overflow-conscious code  
  3.     int oldCapacity = elementData.length;  
  4.     int newCapacity = oldCapacity + (oldCapacity >> 1);  
  5.     if (newCapacity - minCapacity < 0)  
  6.         newCapacity = minCapacity;  
  7.     if (newCapacity - MAX_ARRAY_SIZE > 0)  
  8.         newCapacity = hugeCapacity(minCapacity);  
  9.     // minCapacity is usually close to size, so this is a win:  
  10.     elementData = Arrays.copyOf(elementData, newCapacity);  
  11. }  
这里，首先增加容量为原来的1.5倍，如果还不够，就用给定的容量minCapacity。同时，ArrayList设置了数组的最大长度MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8，如果没超出，使用Arrays类进行复制，不够的元素使用null。如果超出最大长度，调用函数检查是否溢出：

[java]  view plain  copy
  1. private static int hugeCapacity(int minCapacity) {  
  2.     if (minCapacity < 0) // overflow  
  3.         throw new OutOfMemoryError();  
  4.     return (minCapacity > MAX_ARRAY_SIZE) ?  
  5.         Integer.MAX_VALUE :  
  6.         MAX_ARRAY_SIZE;  
  7. }  
如果没有溢出就得到合适的minCapacity值，然后复制。

（4）size()

函数返回集合中元素的数量：

[java]  view plain  copy
  1. public int size() {  
  2.     return size;  
  3. }  
（5）isEmpty()

函数返回集合是否为空，检查size是否为0，即使容量不为0（没有元素）：

[java]  view plain  copy
  1. public boolean isEmpty() {  
  2.     return size == 0;  
  3. }  
（6）contains(Object o)

检查集合中是否包含给定的元素：

[java]  view plain  copy
  1. public boolean contains(Object o) {  
  2.     return indexOf(o) >= 0;  
  3. }  

使用indexOf方法，如果返回值非负，表示集合中函数这个元素。

（7）indexOf(Object o)

函数返回集合中给定元素的第一次出现的位置，如果没有就返回-1：

[java]  view plain  copy
  1. public int indexOf(Object o) {  
  2.     if (o == null) {  
  3.         for (int i = 0; i < size; i++)  
  4.             if (elementData[i]==null)  
  5.                 return i;  
  6.     } else {  
  7.         for (int i = 0; i < size; i++)  
  8.             if (o.equals(elementData[i]))  
  9.                 return i;  
  10.     }  
  11.     return -1;  
  12. }  

首先检查o是否为null，如果为null，就返回集合中第一个null元素的位置；如果不为null，就是用equals函数进行相等性检查。之所以这样，是因为如果直接对null调用equals方法，会抛出空指针异常。同时也不能循环遍历数组中的元素调用equals方法检查是否相等，因为ArrayList集合中允许有null元素的存在。

（8）lastIndexOf(Object o)

函数返回给定元素最后一次出现的位置，如果没有就返回-1：

[java]  view plain  copy
  1. public int lastIndexOf(Object o) {  
  2.     if (o == null) {  
  3.         for (int i = size-1; i >= 0; i--)  
  4.             if (elementData[i]==null)  
  5.                 return i;  
  6.     } else {  
  7.         for (int i = size-1; i >= 0; i--)  
  8.             if (o.equals(elementData[i]))  
  9.                 return i;  
  10.     }  
  11.     return -1;  
  12. }  

原理和indexOf一样，不过对集合元素遍历的时候是倒序遍历的。

（9）clone()

复制集合：

[java]  view plain  copy
  1. public Object clone() {  
  2.     try {  
  3.         ArrayList<?> v = (ArrayList<?>) super.clone();  
  4.         v.elementData = Arrays.copyOf(elementData, size);  
  5.         v.modCount = 0;  
  6.         return v;  
  7.     } catch (CloneNotSupportedException e) {  
  8.         // this shouldn't happen, since we are Cloneable  
  9.         throw new InternalError(e);  
  10.     }  
  11. }  

本质上就是使用Arrays类进行元素的复制。

（10）toArray()

将集合转化为数组：

[java]  view plain  copy
  1. public Object[] toArray() {  
  2.     return Arrays.copyOf(elementData, size);  
  3. }  
也是使用Arrays的复制操作。

（11）toArray(T[] a)

转化为数组，和上一个不同的是，上一个返回的数组是Object[]类型的，这个函数返回的数组类型根据参数确定：

[java]  view plain  copy
  1. @SuppressWarnings("unchecked")  
  2. public <T> T[] toArray(T[] a) {  
  3.     if (a.length < size)  
  4.         // Make a new array of a's runtime type, but my contents:  
  5.         return (T[]) Arrays.copyOf(elementData, size, a.getClass());  
  6.     System.arraycopy(elementData, 0, a, 0, size);  
  7.     if (a.length > size)  
  8.         a[size] = null;  
  9.     return a;  
  10. }  
（12）get(int index)

返回指定位置的元素，这里用到了一个私有函数：

[java]  view plain  copy
  1. @SuppressWarnings("unchecked")  
  2. E elementData(int index) {  
  3.     return (E) elementData[index];  
  4. }  
函数返回数组中指定位置的元素，不过这个函数没有进行下标范围检查，这个工作由另一个私有函数完成：

[java]  view plain  copy
  1. private void rangeCheck(int index) {  
  2.     if (index >= size)  
  3.         throw new IndexOutOfBoundsException(outOfBoundsMsg(index));  
  4. }  
对于get方法来说，首先调用rangeCheck检查下标，然后调用elementData返回元素：

[java]  view plain  copy
  1. public E get(int index) {  
  2.     rangeCheck(index);  
  3.   
  4.   
  5.     return elementData(index);  
  6. }  
（13）set(int index,E element)

设置给定位置的元素为给定的元素，然后返回原来的元素：

[java]  view plain  copy
  1. public E set(int index, E element) {  
  2.     rangeCheck(index);  
  3.   
  4.   
  5.     E oldValue = elementData(index);  
  6.     elementData[index] = element;  
  7.     return oldValue;  
  8. }  
同样，函数也先进行下标检查。

（14）add(E e)

添加元素：

[java]  view plain  copy
  1. public boolean add(E e) {  
  2.     ensureCapacityInternal(size + 1);  // Increments modCount!!  
  3.     elementData[size++] = e;  
  4.     return true;  
  5. }  
首先确保有足够的容量，然后再末尾添加元素。

（15）add(int index,E element)

在指定位置添加元素：

[java]  view plain  copy
  1. public void add(int index, E element) {  
  2.     rangeCheckForAdd(index);  
  3.   
  4.     ensureCapacityInternal(size + 1);  // Increments modCount!!  
  5.     System.arraycopy(elementData, index, elementData, index + 1,  
  6.                      size - index);  
  7.     elementData[index] = element;  
  8.     size++;  
  9. }  
（16）remove(int index)

删除指定位置的元素，然后返回这个元素：

[java]  view plain  copy
  1. public E remove(int index) {  
  2.     rangeCheck(index);  
  3.   
  4.     modCount++;  
  5.     E oldValue = elementData(index);  
  6.   
  7.     int numMoved = size - index - 1;  
  8.     if (numMoved > 0)  
  9.         System.arraycopy(elementData, index+1, elementData, index,  
  10.                          numMoved);  
  11.     elementData[--size] = null; // clear to let GC do its work  
  12.   
  13.     return oldValue;  
  14. }  
（17）remove(Object o)

删除指定的元素，如果集合中有，则删除第一次出现的并返回true；如果没有，集合不变并返回false：

[java]  view plain  copy
  1. public boolean remove(Object o) {  
  2.     if (o == null) {  
  3.         for (int index = 0; index < size; index++)  
  4.             if (elementData[index] == null) {  
  5.                 fastRemove(index);  
  6.                 return true;  
  7.             }  
  8.     } else {  
  9.         for (int index = 0; index < size; index++)  
  10.             if (o.equals(elementData[index])) {  
  11.                 fastRemove(index);  
  12.                 return true;  
  13.             }  
  14.     }  
  15.     return false;  
  16. }  
在找到集合中的元素后，函数调用私有方法fastRemove来删除这个元素：

[java]  view plain  copy
  1. private void fastRemove(int index) {  
  2.     modCount++;  
  3.     int numMoved = size - index - 1;  
  4.     if (numMoved > 0)  
  5.         System.arraycopy(elementData, index+1, elementData, index,  
  6.                          numMoved);  
  7.     elementData[--size] = null; // clear to let GC do its work  
  8. }  
（18）clear()

清空集合，将所有元素设为null，并把size设为0：

[java]  view plain  copy
  1. public void clear() {  
  2.     modCount++;  
  3.   
  4.     // clear to let GC do its work  
  5.     for (int i = 0; i < size; i++)  
  6.         elementData[i] = null;  
  7.   
  8.     size = 0;  
  9. }  
（19）addAll(Collection<? extends E> c)

添加给定集合中的所有元素到集合中，从末尾开始添加：

[java]  view plain  copy
  1. public boolean addAll(Collection<? extends E> c) {  
  2.     Object[] a = c.toArray();  
  3.     int numNew = a.length;  
  4.     ensureCapacityInternal(size + numNew);  // Increments modCount  
  5.     System.arraycopy(a, 0, elementData, size, numNew);  
  6.     size += numNew;  
  7.     return numNew != 0;  
  8. }  
首先把c集合转为数组，然后确保容量，最后复制。

（20）add(int index,Collection<? extends E> c)

在指定位置开始添加指定集合中的所有元素：

[java]  view plain  copy
  1. public boolean addAll(int index, Collection<? extends E> c) {  
  2.     rangeCheckForAdd(index);  
  3.   
  4.     Object[] a = c.toArray();  
  5.     int numNew = a.length;  
  6.     ensureCapacityInternal(size + numNew);  // Increments modCount  
  7.   
  8.     int numMoved = size - index;  
  9.     if (numMoved > 0)  
  10.         System.arraycopy(elementData, index, elementData, index + numNew,  
  11.                          numMoved);  
  12.   
  13.     System.arraycopy(a, 0, elementData, index, numNew);  
  14.     size += numNew;  
  15.     return numNew != 0;  
  16. }  
原理和上一个一样，不同的是复制的位置。

（21）removeRange(int fromIndex,int toIndex)

删除给定范围内的所有元素：

[java]  view plain  copy
  1. protected void removeRange(int fromIndex, int toIndex) {  
  2.     modCount++;  
  3.     int numMoved = size - toIndex;  
  4.     System.arraycopy(elementData, toIndex, elementData, fromIndex,  
  5.                      numMoved);  
  6.   
  7.     // clear to let GC do its work  
  8.     int newSize = size - (toIndex-fromIndex);  
  9.     for (int i = newSize; i < size; i++) {  
  10.         elementData[i] = null;  
  11.     }  
  12.     size = newSize;  
  13. }  
（22）removeAll和retainAll

这两个函数都给一个集合参数c，removeAll删除集合中所有在集合c中出现过的元素；retainAll保留所有在集合c中出现的元素。两个函数都调用私有函数batchRemove()：

[java]  view plain  copy
  1. public boolean removeAll(Collection<?> c) {  
  2.     Objects.requireNonNull(c);  
  3.     return batchRemove(c, false);  
  4. }  
  5.   
  6. public boolean retainAll(Collection<?> c) {  
  7.     Objects.requireNonNull(c);  
  8.     return batchRemove(c, true);  
  9. }  
batchRemove函数如下：

[java]  view plain  copy
  1. private boolean batchRemove(Collection<?> c, boolean complement) {  
  2.     final Object[] elementData = this.elementData;  
  3.     int r = 0, w = 0;  
  4.     boolean modified = false;  
  5.     try {  
  6.         for (; r < size; r++)  
  7.             if (c.contains(elementData[r]) == complement)  
  8.                 elementData[w++] = elementData[r];  
  9.     } finally {  
  10.         // Preserve behavioral compatibility with AbstractCollection,  
  11.         // even if c.contains() throws.  
  12.         if (r != size) {  
  13.             System.arraycopy(elementData, r,  
  14.                              elementData, w,  
  15.                              size - r);  
  16.             w += size - r;  
  17.         }  
  18.         if (w != size) {  
  19.             // clear to let GC do its work  
  20.             for (int i = w; i < size; i++)  
  21.                 elementData[i] = null;  
  22.             modCount += size - w;  
  23.             size = w;  
  24.             modified = true;  
  25.         }  
  26.     }  
  27.     return modified;  
  28. }  
函数对集合中的元素进行遍历，首先复制集合中的元素，然后检查是否符合complement的要求进行保留。在finally中，复制元素到集合中。并修改相应的size。

（23）ListIterator<E> listIterator()和ListIterator<E> listIterator(int index)

这两个函数返回在集合上的一个迭代器，不同是第一个是关于所有元素的，第二个是从指定位置开始的。这里ArrayList使用了内部类ListItr，


[java]  view plain  copy
  1. public ListIterator<E> listIterator(int index) {  
  2.     if (index < 0 || index > size)  
  3.         throw new IndexOutOfBoundsException("Index: "+index);  
  4.     return new ListItr(index);  
  5. }  
  6.   
  7. public ListIterator<E> listIterator() {  
  8.     return new ListItr(0);  
  9. }  

（24）Iterator<E> iterator()

也返回一个迭代器，使用了内部类Itr，继承于ListItr：

[java]  view plain  copy
  1. public Iterator<E> iterator() {  
  2.     return new Itr();  
  3. }  
（25）List<E> subList(int fromIndex, int toIndex)

返回一个从fromIndex到toIndex的子集合：

[java]  view plain  copy
  1. public List<E> subList(int fromIndex, int toIndex) {  
  2.     subListRangeCheck(fromIndex, toIndex, size);  
  3.     return new SubList(this, 0, fromIndex, toIndex);  
  4. }  
使用了内部类SubList。

3、例子


三种遍历方式：

[java]  view plain  copy
  1. <span style="white-space:pre">    </span>Integer[] nums={2,1,3,6,0,4,5,8,7,9};  
  2.     List<Integer> list=new ArrayList<>();  
  3. <span style="white-space:pre">    </span>list=Arrays.asList(nums);  
  4.     //使用RandomAccess方式：  
  5.     System.out.println("#1:");  
  6.     for(int i=0;i<list.size();i++)  
  7.     {  
  8.         System.out.print((int)list.get(i));  
  9.     }  
  10.     //使用foreach：  
  11.     System.out.println("\n#2:");  
  12.     for (Integer integer : list) {  
  13.         System.out.print(integer);  
  14.     }  
  15.     //使用Iterator：  
  16.     System.out.println("\n#3:");  
  17.     Iterator<Integer> it=list.iterator();  
  18.     while(it.hasNext())  
  19.     {  
  20.         System.out.print((int)it.next());  
  21.     }  
结果：

#1:
2136045879
#2:
2136045879
#3:
2136045879



Java：ArrayList详解
2301_79783967的博客
03-28 2699
在集合框架中，ArrayList是一个普通的类，实现了List接口，具体框架图如下：不带参数 没有初始化，默认为空，只是一个数组引用常量数组，没有分配内存，长度是0 因此不带参数的构造并没有给数组大小 带参数初始化数组大小如果参数是0的情况下，就会是空数组如果是参数小于0就会抛出异常 另一个带一个参数的构造方法参数Collection是一个接口，只要是实现了该接口的都可以进行传递尖括号里的‘？’是通配符，尖括号里面可以写E或者E的子类举例： ArrayList实现了Collection接口，array
Java集合（8）——ArrayList源码解析
想当厨子的程序媛
03-22 808
类图 官方文档 ArrayList成员变量 ArrayList构造函数 ArrayList内部类 ArrayList成员方法 ArrayList成员方法源码解析 1. public ArrayList(int initialCapacity)带参构造方法 public ArrayList(int initialCa...
【Java集合源码剖析】ArrayList源码剖析
热门推荐
兰亭风雨的专栏
06-30 2万+
ArrayList是基于数组实现的，是一个动态数组，其容量能自动增长，类似于C语言中的动态申请内存，动态增长内存。 ArrayList不是线程安全的，只能用在单线程环境下，多线程环境下可以考虑用Collections.synchronizedList(List l)函数返回一个线程安全的ArrayList类，也可以使用concurrent并发包下的CopyOnWriteArrayList类。 ArrayList实现了Serializable接口，因此它支持序列化，能够通过序列化传输，实现了R
ArrayList
weixin_30788239的博客
05-05 204
ArrayList ArrayList 概述 成员变量 构造器 成员方法 Summary 概述 ArrayList是List接口的具体实现类，可以存储任何元素，包括null。这个类与Vector类几乎是一样的，仅有的区别就是Vector类是线程安全的(方法有synchronized关键字)，而ArrayList不是。 关于时间复杂度： con...
精选资源
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类型的变量在声明的同时必须进行实例化(如果初始化至少得初始化数组...
什么是 ArrayList
weixin_33826268的博客
02-24 3078
简介 ArrayList 是 java 集合框架中比较常用的数据结构了。继承自 AbstractList，实现了 List 接口。底层基于数组实现容量大小动态变化。允许 null 的存在。同时还实现了 RandomAccess、Cloneable、Serializable 接口，所以ArrayList 是支持快速访问、复制、序列化的。 成员变量 ArrayList 底层是基于数组来实现容量大小动态...
详解java中ArrayList
最新发布
phone15931168209的博客
01-11 4019
当你看到这篇文章我觉得很好笑，因为我开始也不同ArrayList现在轮到你了，嘻嘻嘻，但是没关系我教你，action!!!一、ArrayList是什么通俗点讲ArrayList就是数组文字解答：ArrayList属于List，List是线性表，线性表有顺序表、链表、栈、队列...，而ArrayList底层代码就是顺序表（数组）//数组// 默认的容量//数组初始化你可能感觉很奇怪，ArrayList底层既然是数组，那为什么不直接写成数组的形式呢，比如这样。
Java集合框架：ArrayList详解
weixin_64874291的博客
06-11 6395
1. ArrayList是以泛型的方式实现的，使用时必须先实例化2. ArrayList实现了randomAccess接口，所以ArrayList支持随机访问3. ArrayList实现了Cloneable接口，ArrayList时可以克隆的4. ArrayList不是线程安全的，（Vector是线程安全的）5. ArrayList是一段连续的空间，可以动态扩容，是动态的顺序表。
java arraylist 用法_Java入门系列：实例讲解ArrayList用法
weixin_39606799的博客
02-12 350
本文通过实例讲解Java中如何使用ArrayList类。Java.util.ArrayList类是一个动态数组类型，也就是说，ArrayList对象既有数组的特征，也有链表的特征。可以随时从链表中添加或删除一个元素。ArrayList实现了List接口。大家知道，数组是静态的，数组被初始化之后，数组长度就不能再改变了。ArrayList是可以动态改变大小的。那么，什么时候使用Array(数组)，什...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值