ArrayList 类提供了 List ADT 的一种可增长的一个数组队列的实现,相当于 动态数组。与Java中的数组相比,它的容量能动态增长。它继承于AbstractList,实现了List, RandomAccess, Cloneable, java.io.Serializable这些接口。
(1)ArrayList 继承了AbstractList,实现了List。它是一个数组队列,提供了相关的添加、删除、修改、遍历等功能。
(2)ArrayList 实现了RandmoAccess接口,即提供了随机访问功能。
(3)RandmoAccess是Java中用来被List实现,为List提供快速访问功能的。在ArrayList中,我们可以通过元素的序号快速获取元素对象,这就是随机访问。
(4)ArrayList 实现了Cloneable接口,即覆盖了函数clone(),能被克隆。
(5)ArrayList 实现java.io.Serializable接口,这意味着ArrayList支持序列化,能通过序列化去传输。
强调:
(1)和Vector不同,ArrayList中的操作不是线程安全的!所以,建议在单线程中才使用ArrayList,而在多线程中可以选择Vector或者CopyOnWriteArrayList。
(2)在ArrayList 中有一个容量的概念,它表示基础数组的大小。在需要的时候, ArrayList将自动增加其容量以保证它至少具有表的大小。一般扩大为原来的两倍。
/**
* 它继承于AbstractList,实现了List, RandomAccess, Cloneable,
* java.io.Serializable这些接口
*/
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
//设置初始数组大小
private static final int DEFAULT_CAPACITY = 10;
//ArrayList中所含元素的多少
private int size;
//收缩ArrayList的容量为目前所含元素的个数
public void trimToSize() {
modCount++;
if (size < elementData.length) {
elementData = (size == 0)
? EMPTY_ELEMENTDATA
: Arrays.copyOf(elementData, size);
}
}
//增加ArrayList的容量以保证它至少具有表的大小
public void ensureCapacity(int minCapacity) {
int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
? 0
: DEFAULT_CAPACITY;
if (minCapacity > minExpand) {
ensureExplicitCapacity(minCapacity);
}
}
//返回当前状态此ArrayList的大小
public int size() {
return size;
}
//如果此ArrayList为空,则为true,判断是否为空
public boolean isEmpty() {
return size == 0;
}
//判断此ArrayList中是否包含此元素
public boolean contains(Object o) {
return indexOf(o) >= 0;
}
//返回此ArrayList的副本,但元素本身并未复制
public Object clone() {
try {
ArrayList<?> v = (ArrayList<?>) super.clone();
v.elementData = Arrays.copyOf(elementData, size);
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {
throw new InternalError(e);
}
}
}
除此之外,还有常用的get,set,add方法等。
在这里,博主提供便于使用的 ArrayList 泛型类的实现。为避免与类库中的类相混,这里将此类叫做 MyArrayList ,以此来细细体会 ArrayList 的神奇魅力。
(1)MyArrayList 将保持基础数组,数组的容量,以及存储在 MyArrayList 中的当前项数。
(2)MyArrayList 将提供一种机制以改变基础数组的容量。通过获得一个新数组,将老数组拷贝到新数组中来改变数组的容量,允许虚拟机回收老数组。
(3)MyArrayList 将提供 get 和 set 的实现。
(4)MyArrayList 将提供基本的例程, 如 size、 isEmpty 和 clear ,还提供 remove,以及两种不同版本的 add。如果数组的大小和容量相同,那么这两个 add 例程将增加容量。
(5)MyArrayList 将提供一个实现 Iterator 接口的类。这个类将存储迭代序列中的下一项的下标,并提供 next、hasNext 和 remove 等方法的实现。
public class MyArrayList<AnyType> implements Iterable<AnyType>
{
private static final int DEFAUTL_CAPACITY = 10;
private int theSize;
private AnyType [] theItems;
public MyArrayList()
{
clear();
}
public void clear()
{
theSize = 0;
ensureCapacity(DEFAUTL_CAPACITY);
}
public int size()
{
return theSize;
}
public boolean isEmpty()
{
return size() == 0;
}
public void trimToSize()
{
ensureCapacity(size());
}
public AnyType get(int idx)
{
if(idx < 0 || idx >= size())
throw new ArrayIndexOutOfBoundsException();
return theItems[idx];
}
public AnyType set(int idx, AnyType newVal)
{
if(idx < 0 || idx >= size())
throw new ArrayIndexOutOfBoundsException();
AnyType old = theItems[idx];
theItems[idx] = newVal;
return old;
}
public void ensureCapacity(int newCapacity)
{
if(newCapacity < theSize)
return;
AnyType [] old = theItems;
theItems = (AnyType []) new Object[newCapacity];
for(int i = 0; i < size(); i++)
theItems[i] = old[i];
}
public boolean add(AnyType x)
{
add(size(), x);
return true;
}
public void add(int idx, AnyType x)
{
if(theItems.length == size())
ensureCapacity(size() * 2 + 1);
for(int i = theSize; i > idx; i--)
theItems[i] = theItems[i - 1];
theItems[idx] = x;
theSize++;
}
public AnyType remove(int idx)
{
AnyType removedItem = theItems[idx];
for(int i = idx; i < size() - 1; i++)
theItems[i] = theItems[i + 1];
theItems[idx] = x;
theSize--;
return removedItem;
}
public java.util.Iterator<AnyType> iterator()
{
return new ArrayListIterator();
}
private class ArrayListIterator implements java.util.Iterator<AnyType>
{
private int current = 0;
public boolean hasNext()
{
return current < size();
}
public AnyType next()
{
return theItems[current++];
}
public void remove()
{
MyArrayList.this.remove(--current);
}
}
}
在此注意Java内部类和嵌套类的区别与使用。
LinkedList 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。
(1)LinkedList 实现 List 接口,能对它进行队列操作。
(2)LinkedList 实现 Deque 接口,即能将LinkedList当作双端队列使用。
(3)LinkedList 实现了Cloneable接口,即覆盖了函数clone(),能克隆。
(4)LinkedList 实现java.io.Serializable接口,这意味着LinkedList支持序列化,能通过序列化去传输。
(5)LinkedList 是非同步的。
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
transient int size = 0;
// 首指针
transient Node<E> first;
// 尾指针
transient Node<E> last;
//节点定义
private static class Node<E> {
E item;
Node<E> next;
Node<E> prev;
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
//返回此 LinkedList 的副本,但元素本身并未复制
public Object clone() {
LinkedList<E> clone = superClone();
clone.first = clone.last = null;
clone.size = 0;
clone.modCount = 0;
for (Node<E> x = first; x != null; x = x.next)
clone.add(x.item);
return clone;
}
LinkedList将作为双链表来实现,而且我们还需要保留到该表两端的引用。在考虑设计方面,我们将需要提供三个类:
(1)MyLinkedList 类本身,它包含到两端的链、表的大小以及一些方法。
(2)Node 类,它可能是一个私有的嵌套类。一个节点包含数组以及到前一个节点的链和到下一个节点的链,还有一些适当的构造方法。
(3)LinkedListIterator 类,该类抽象了位置的概念,是一个私有类,并实现接口 Iterator。它提供了方法 next、hasNext 和 remove 的实现。
public class MyLinkedList<AnyType> implements Iterable<AnyType>
{
private static class Node<AnyType>
public MyLinkedList()
{
clear();
}
public void clear(){}
public int size()
{
return theSize;
}
public boolean isEmpty()
{
return size() == 0;
}
public boolean add(AnyType x)
{
add(size(), x);
return true;
}
public void add(int idx, AnyType x)
{
addBefore(getNode(idx), x);
}
public AnyType get(int idx)
{
return getNode(idx).data;
}
public AnyType set(int idx, AnyType newVal)
{
Node<AnyType> p = getNode(idx);
AnyType oldVal = p.data;
p.data = newVal;
return oldVal;
}
public AnyType remove(int idx)
{
return remove(getNode(idx));
}
private void addBefore(Node<AnyType> p, AnyType x){}
private AnyType remove(Node<AnyType> p){}
private Node<AnyType> getNode(int idx){}
public java.util.Iterator<AnyType> iterator()
{
return new LinkedListIterator();
}
private class LinkedListIterator implements java.util.Iterator<AnyType>{}
private int theSize;
// modCount 代表自从构造以来对链表所做改变的次数。每次对add或remove的调用都将更新modCount。
private int modCount = 0;
private Node<AnyType> beginMarker;
private Node<AnyType> endMarker;
}
private static class Node<AnyType>
{
public Node(AnyType d, Node<AnyType> p, Node<AnyType> n)
{
data = d;
prev = p;
next = n;
}
public AnyType data;
public Node<AnyType> prev;
public Node<AnyType> next;
}
public void clear()
{
beginMarker = new Node<AnyType>(null, null, null);
endMarker = new Node<AnyType>(null, null, null);
beginMarker.next = endMarker;
theSize = 0;
modCount++;
}
private void addBefore(Node<AnyType> p, AnyType x)
{
Node<AnyType> newNode = new Node<AnyType>(x, p.prev, p);
newNode.prev.next = newNode;
p.prev = newNode;
theSize++;
modCount++;
}
public AnyType remove(Node<AnyType> p)
{
p.next.prev = p.prev;
p.prev.next = p.next;
theSize--;
modCount++;
return p.data;
}
private Node<AnyType> getNode(int idx)
{
Node<AnyType> p;
if(idx < 0 || idx > size())
throw new java.util.IndexOutOfBoundsException();
if(idx < size() / 2)
{
p = beginMarker.next;
for(int i = 0; i < idx; i++)
p = p.next;
}
else
{
p = endMarker;
for(int i = size(); i > idx; i--)
p = p.prev;
}
return p;
}
private class LinkedListIterator implements java.util.Iterator<ArrayListIterator>
{
private Node<AnyType> current = beginMarker.next;
private int expectedModCount = modCount;
private boolean okToRemove = false;
public boolean hasNext()
{
return current != endMarker;
}
public AnyType next()
{
// 每次对迭代器next或remove的调用都将用该链表内的当前modCount检测
//在迭代器内存储的modCount,如果不等,则抛出异常。
if(modCount != expectedModCount)
throw new java.util.ConcurrentModificationException();
if(!hasNext())
throw new java.util.NoSuchElementException();
AnyType nextItem = current.data;
current = current.next;
okToRemove = true;
return nextItem;
}
public void remove()
{
if(modCount != expectedModCount)
throw new java.util.ConcurrentModificationException();
if(!okToRemove)
throw new IllegalStateExeption();
MyLinkedList.this.remove(current.prev);
okToRemove = false;
expectedModCount++;
}
}
(1)ArrayList 支出随机访问,而 LinkedList 不能随机访问;
(2)ArrayList 对于 get 和 set 的调用花费常数时间,然而对于新项的插入和现有项的删除代价昂贵,不易于进行;而 LinkedList 对于新项的插入和现有项的删除均开销很小,然而对于 get 的调用确实昂贵的。
欢迎各位大佬指正。