ArrayList和LinkedList深度解析

ArrayList和LinkedList深度解析

  • ArrayList解析
      • 简介
      • 源码赏析(基于JDK1.8.0_191)
      • ArrayList类的简单实现
  • LinkedList解析
      • 简介
      • 源码赏析(基于JDK1.8.0_191)
      • LinkedList类的简单实现
  • ArrayList 和 LinkedList 的比较

ArrayList解析

简介

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将自动增加其容量以保证它至少具有表的大小。一般扩大为原来的两倍。

源码赏析(基于JDK1.8.0_191)

/**
 * 它继承于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类的简单实现

在这里,博主提供便于使用的 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解析

简介

LinkedList 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。

(1)LinkedList 实现 List 接口,能对它进行队列操作。
(2)LinkedList 实现 Deque 接口,即能将LinkedList当作双端队列使用。
(3)LinkedList 实现了Cloneable接口,即覆盖了函数clone(),能克隆。
(4)LinkedList 实现java.io.Serializable接口,这意味着LinkedList支持序列化,能通过序列化去传输。
(5)LinkedList 是非同步的。

源码赏析(基于JDK1.8.0_191)

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类的简单实现

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++;
    }
}

ArrayList 和 LinkedList 的比较

(1)ArrayList 支出随机访问,而 LinkedList 不能随机访问;
(2)ArrayList 对于 get 和 set 的调用花费常数时间,然而对于新项的插入和现有项的删除代价昂贵,不易于进行;而 LinkedList 对于新项的插入和现有项的删除均开销很小,然而对于 get 的调用确实昂贵的。

欢迎各位大佬指正。

你可能感兴趣的:(Java)