LinkedList与ArrayList的对比分析

突然想到ArrayList与LinkedList在java中的底层实现，以及他们的用法区别，这里做一下小小的总结。

实现的接口

ArrayList

ArrayList类是一个可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，我们可以添加或删除元素。

从上面的图中我们可以看到ArrayList实现List接口与AbstractCollection接口，List接口继承了Collection接口，而AbstractCollection实现了Collection接口

• Collection 接口
• Collection 是最基本的集合接口，一个 Collection 代表一组 Object，即 Collection 的元素, Java不提供直接继承自Collection的类，只提供继承于的子接口(如List和set)。
• Collection 接口存储一组不唯一，无序的对象。
• List 接口
  List接口是一个有序的
  Collection，使用此接口能够精确的控制每个元素插入的位置，能够通过索引(元素在List中位置，类似于数组的下标)来访问List中的元素，第一个元素的索引为 0，而且允许有相同的元素。List 接口存储一组不唯一，有序（插入顺序）的对象。

从上面的描述我们可以知道ArrayList是对象数据，具有插入有序的的特点，它可以以O(1)时间复杂度对元素进行随机访问,而且是动态数组(底层是由一个grow()函数来进行扩容操作，源码如下)

//ArrayList扩容的核心方法，此方法用来决定扩容量
    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);
    }
 
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }
 
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

LinkedList

链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址，与 ArrayList 相比，LinkedList 的增加和删除对操作效率更高，而查找和修改的操作效率较低。这让我想起字节面试中，问到字典底层解决hash地址冲突中的拉链法建立链表，链表过长的情况，会导致查找和修改的操作效率变低，在java8之前，字典的底层实现的都是用数组＋链表实现，而在java8中引出了数组加红黑树(类似平衡二叉树)的数据结构，从而优化了查找和修改的效率过低情况。

从上图我们可以看到LinkedList继承了AbstractList的子类AbstractSequentialList，从UML图中看出

• LinkedList 继承了 AbstractSequentialList 类。

• LinkedList 实现了 Queue 接口，可作为队列使用。

• LinkedList 实现了 List 接口，可进行列表的相关操作。

• LinkedList 实现了 Deque 接口，可作为队列使用。

• LinkedList 实现了 Cloneable 接口，可实现克隆。

• LinkedList 实现了 java.io.Serializable 接口，即可支持序列化，能通过序列化去传输。

LinkedList的底层实现与手撕链表

LinkedList的底层实现是由双向链表实现

• 手撕单链表

package com.ll.singleLinkedList;


public class SingleLinkedListDemo1{
    public static void main(String[] args) {
        SingleLinkedList list = new SingleLinkedList();
        System.out.println(list.size());
        list.add(new Node("aaa"));
        System.out.println(list.size());
        list.add(new Node("bbb"));
        list.show();
        System.out.println();
        list.add(new Node("ccc"));
        list.add(new Node("ddd"));
        System.out.println("删除前长度为: " + list.size());
        list.show();
        System.out.println("\n删除ccc后的结果");
        System.out.println(list.delete("ccc") + "长度为：" + list.size());
        list.show();
        list.delete("ddd");
        System.out.println("\n删除ddd后的结果");
        list.show();
        System.out.println(list.search("bbb"));


    }
}

//定义单链表的方法
class SingleLinkedList{
    //定义头结点
    private Node head = new Node();
    private int size = 0;//定义节点个数
    //返回节点个数， 即LinkedList长度
    public int size(){
        return size;
    }
    //打印链表
    public void show(){
        Node temp = head;
        while (temp.next!=null){
            temp = temp.next;
            System.out.print(temp.toString() + " ");
        }

    }
    //添加元素
    public void add(Node node){
        Node temp = head;
        //找到末尾位置，添加元素
        while (temp.next!=null){
            temp = temp.next;
        }
        //将元素添加到链表末尾
        temp.next = node;
        temp.next.data = node.data;
        size ++;
    }
    //删除元素
    public boolean delete(Object data){
        Node temp = head;
        while (temp.next!=null && !temp.next.data.equals(data)){
            temp = temp.next;
        }
        if(temp.next==null && !temp.data.equals(data)){
            return false;//没有找到该元素无法删除
        }else if(temp.next==null && temp.data.equals(data)){
            temp.next = null;
            return true;//最后一个元素
        }
        else{
            Node curNode = temp.next;//指向要删除的节点
            //删除节点
            temp.next = curNode.next;
            curNode.next = null;
            curNode = null;//销毁
            size --;
        }
        return true;
    }
    //修改元素
    //查找元素
    public boolean search(Object data){
        Node temp = head;
        while (temp.next!=null && !temp.next.equals(data)){
            temp = temp.next;
        }
        if(temp.next == null && !temp.data.equals(data)){
            return false;//未找到该元素
        }
        else {
            return true;
        }
    }

}

/**
 * 单链表节点定义
 */
 class Node{
    Object data;//存储数据
    Node next;//指向下个节点的指针

    //构造方法
    public Node(){
        super();
    }

    public Node(Object data){
        super();
        this.data = data;
    }
    public Node(Object data, Node next) {
        this.data = data;
        this.next = next;
    }

    @Override
    public String toString() {
        return "Node{" +
                "data=" + data +
                '}';
    }
}

• 手撕双链表及LinkedList实现

package com.ll.doubleLinkedList;

import java.util.LinkedList;

public class Demo1 {
    public static void main(String[] args) {
        DoubleLinkedList linkedList = new DoubleLinkedList();
        linkedList.add(new Node("aaa"));
        linkedList.add(new Node("bbb"));
        linkedList.add(new Node("ccc"));
        linkedList.show();
        System.out.println(linkedList.size);
        System.out.println(linkedList.get(2));
        linkedList.remove(1);
        linkedList.show();
        linkedList.remove(1);
        linkedList.show();
    }
}
class DoubleLinkedList {
    Node head = new Node();
    int size = 0;//定义链表长度

    //长度
    public int size() {
        return size;
    }

    /**
     * 利用索引获取元素
     */
    public Object get(int i) {
        if (i < 0 || i >= size) {
            throw new IndexOutOfBoundsException("下标越界" + i);
        }
        int j = 0;
        Node temp = head;
        while (j < i) {
            temp = temp.next;
            j++;
        }
        return temp.data;
    }

    /**
     * 添加元素
     */
    public void add(Node node) {
        Node temp = head;
        while (temp.next != null) {
            temp = temp.next;
        }
        temp.next = node;
        node.perior = temp;
        node.next = null;//将元素添加到双链表末尾
        size++;
    }

    public void show() {
        Node temp = head.next;
        while (temp.next != null) {
            System.out.print(temp.toString() + " ");
            temp = temp.next;
        }
        System.out.println(temp.toString());

    }

    /**
     * 删除元素
     */
    public void remove(int i) {//按数值来删除
        Node temp = head;
        int j = 0;
        while (j < i) {
            temp = temp.next;
            j++;
        }
        Node delNode = temp.next;//delNode指向要删除的元素
        if(delNode.next!=null){
            delNode.next.perior = temp;
            temp.next = delNode.next;
            delNode.next = null;
            delNode.perior = null;
            delNode = null;//销毁
        }else {
            temp.next=null;
            delNode.perior=null;
            delNode = null;
        }

        size--;
    }

}
class Node{
    Object data;//数据
    Node perior;//向前指针
    Node next;//向后指针

    //构造函数
    public Node() {
    }

    public Node( Object data, Node perior, Node next) {
        this.data = data;
        this.perior = perior;
        this.next = next;
    }

    public Node( Object data) {
        this.data = data;
    }

    @Override
    public String toString() {
        return "Node{" +
                "data=" + data +
                '}';
    }
}