面试题：ArrayList和LinkedList

ArrayList的相关知识

底层实现原理
（1）ArrayList是一个动态类型的顺序表，它完全实现了List的全部接口功能，是基于数组实现的List类，内部封装了一个Object[]类型的数组，长度可以动态增长；
（2）如果在创建时没有指定长度，他默认创建了一个长度为10的数组，当新添加的元素已经没有位置存放的时候，ArrayList会自动扩容，扩容后的长度为原来的1.5倍；
（3）支持随机访问，但插入删除效率较低；
（4）线程是不安全的。

实现接口
Serializable, Cloneable, Iterable, Collection, List, RandomAccess

ArrayList的实现

class MyArrayList {
    Object[] array;
    int capacity;//空间总容量
    int size;//空间中有效元素的个数
    public MyArrayList(int capacity){
        array = new Object[capacity];
        size = 0;
        this.capacity = capacity;
    }
    void add(Object e){
        if(size > capacity - 1){
            capacity = capacity +capacity/2;
        }
        array[size++] = e;
    }
    int size(){
        return size;
    }
    Object get(int index){
        if(index < 0 || index > capacity){
            return -1;
        }else{
            return array[size];
        }
    }
    boolean isEmpty(){
        return 0 == size;
    }
}

LinkedList的相关知识

底层实现原理
（1）LinkedList是一个链式结构，底层是基于双向循环链表实现的，也是list接口的实现类，除了可以当做链表来操作外，它还可以当做栈、队列和双端队列来使用；
（2）LinkedList实现了Serializable接口，因此它支持序列化，能够通过序列化传输，实现了Cloneable接口，能被克隆；
（3）随机访问速度较差，但插入删除速度会很快；
（4）线程也是不安全的。

实现接口
Serializable, Cloneable, Iterable, Collection, Deque, List, Queue

LinkedList的实现

public class MyLinkedList {
    public Node head;
    public int size;
    //结点类
    private class Node{
        int val;
        Node next;
        public Node(int val){
            val = val;
            next = null;
        }
    }
    public MyLinkedList() {
        head = null;
        size = 0;
    }

    public int get(int index) {
        if(index >= size || index < 0)
        {
            return -1;
        }
        Node cur = head;
        int i = -1;
        while(i < index){
            cur = cur.next;
            i++;
        }
        return cur.val;
    }

    public void addAtHead(int val) {
        addAtIndex(0,val);
    }

    public void addAtTail(int val) {
        addAtIndex(size,val);
    }

    public void addAtIndex(int index, int val) {
        Node cur = head;
        int i = -1;
        if(index >= 0 && index <= size){
            Node node = new Node(val);
            if(index == 0){
                node.next = head;
                head = node;
            }else{
                while(i < index-1){
                    cur = cur.next;
                    i++;
                }
                node.next = cur.next;
                cur.next = node;
            }
            size++;
        }
    }

    public void deleteAtIndex(int index) {
        if(index >= 0 && index < size){
            if(index == 0){
                head.next = head.next.next;
            }else{
                Node cur = head;
                int i = -1;
                while(i < index - 1){
                    cur = cur.next;
                    i++;
                }
                cur.next = cur.next.next;
            }
            size--;
        }
    }

ArrayList与LinkedList的异同

相同点
（1）都是Java集合框架所提供的两种结构；
（2）都实现了List接口；
（3）都是线性结构

区别
（1）ArrayList是连续的存储空间，而LinkedList是链式结构；
（2）ArrayList支持随机访问且效率较高，LinkedList不支持；
（3）ArrayList插入其间可能需要扩容，LinkedList则不需要；
（4）应用场景不同： ArrayList适合存储需要大量访问的元素，LinkedList则适合大量任意位置元素插入和删除的情况；
（5）迭代器实现方式不同：ArrayList去下一个元素对索引进行++操作，而LinkedList则需要next指针域。