自己用java实现LinkList和arrayList

为了加深理解，我就自己写了下LinkList和arrayList。
下面贴下代码

链表代码

public class MyTwoLinkedList<AnyType> implements Iterable<AnyType> {
    private int theSize;
    private int modCount = 0;
    private Node<AnyType> beginMarker;
    private Node<AnyType> endMarker;

    private static class Node<AnyType> {
        public AnyType data;
        public Node<AnyType> prev;
        public Node<AnyType> next;

        public Node(AnyType d, Node<AnyType> p, Node<AnyType> n) {
            data = d;
            prev = p;
            next = n;
        }
    }

    public MyTwoLinkedList() {
        clear();
    }

    public void clear() {
        beginMarker = new Node<AnyType>(null, null, null);
        endMarker = new Node<AnyType>(null, beginMarker, null);
        beginMarker.next = endMarker;

        theSize = 0;
        modCount++;
    }

    public int size() {
        return theSize;
    }

    public Boolean add(AnyType x) {
        add(size(), x);
        return true;
    }

    public void add(int idx, AnyType x) {
        addBefore(getNode(idx), x);
    }

    //搜索节点，先判断节点在前半段还是后半段，略提高效率，双链表可以从两个方向查找
    private Node<AnyType> getNode(int idx) {
        Node<AnyType> p;//一个引用

        if (idx < 0 || idx > size())
            throw new 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 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++;
        //修改次数+1
        modCount++;
    }

    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 AnyType remove(Node<AnyType> p) {
        p.next.prev = p.prev;
        p.prev.next = p.next;
        theSize--;
        //修改次数仍+1
        modCount++;
        return p.data;
    }


    public java.util.Iterator<AnyType> iterator() {
        //返回一个实例化的内部类，该类是迭代器，内部实现
        return new MyTwoLinkedList.LinkedListIterator();
    }

    //实现Iterator接口
    private class LinkedListIterator implements java.util.Iterator<AnyType> {
        //在内部指向第一个元素
        private Node<AnyType> current = beginMarker.next;

        //检测在迭代期间集合被修改的情况，分别在next()和迭代器自己的remove()中检查，如果修改次数不同说明在迭代器迭代之外发生了修改行为
        //迭代器自己的remove()调用外层类的remove,其中有modCount++,迭代器做出remove()动作后将expectecModCount++,保证迭代期间二者保持一致
        private int expectedModCount = modCount;

        //okToRemove在next()执行后被置为true,在迭代器自己的remove()执行完后置为false,迭代器自己的remove()执行前检查其是否为true才执行，保证迭代一次才能删除一个，没有其他迭代时删除的方式
        private boolean okToRemove = false;

        public boolean hasNext() {
            return current != endMarker;
        }

        public AnyType next() {
            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();
            //不是迭代期间调用此迭代器remove()方法
            if (!okToRemove)
                throw new IllegalStateException();
            //调用外部类方法
            //next()使current先指向下一元素，这里移除current前一个元素，这样边迭代边移除，先后移后删除前一个元素


            MyTwoLinkedList.this.remove(current.prev);
            okToRemove = false;
            expectedModCount++;
        }
    }
}

双链表头尾放置两个值为null的Node对象，这样使头尾节点的处理也正常化，不会是删除头尾元素成为特别的情况存在。双链表还有就是每个节点存储上下两个节点的信息。删除的开销，在链表来，只是修改删除元素首尾节点的指向而已。而且由于是双链表可以从两端开始遍历，这样，用getNode方法，确认元素是在哪个半段。这样能用最快的速度来遍历。后面的迭代器实现，主要是用modcount参数，来保证链表的一致性的。

ArrayList代码

public class MyTestArrayList<AnyType> implements Iterable<AnyType> {
    //

    //默认容器
    private static final int DEFAULT_CAPACITY = 10;

    private int theSize;
    private AnyType[] theItems;

    public MyTestArrayList() {
        clear();
    }

    public void clear() {
        theSize = 0;
        ensureCapacity(DEFAULT_CAPACITY);
    }

    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 (idx > size()) {
            throw new IndexOutOfBoundsException("Index:" + idx + "  Size :" + size());
        }
        if (theItems.length == size())
            ensureCapacity(size() * 2);
        for (int i = theSize; i > idx; i--)
            theItems[i] = theItems[i - 1];
        theItems[idx] = x;
        theSize++;
    }

    public AnyType get(int idx) {
        if (idx < 0 || idx > size())
            throw new ArrayIndexOutOfBoundsException();
        return theItems[idx];
    }

    public AnyType set(int idx, AnyType x) {
        if (idx < 0 || idx > size())
            throw new ArrayIndexOutOfBoundsException();
        AnyType oldValue = theItems[idx];
        theItems[idx] = x;
        return oldValue;
    }

    public Boolean isEmpty() {
        return size() == 0;
    }

    public int size() {
        return theSize;
    }

    public AnyType remove(int idx) {
        AnyType deleteItem = theItems[idx];
        for (int i = idx; i < size() - 1; i++) {
            theItems[i] = theItems[i + 1];
        }
//        theSize--;
        theItems[--theSize] = null;
        return deleteItem;
    }

    public java.util.Iterator<AnyType> iterator(){
        return new ArrayListIterator();
    }

    public class ArrayListIterator implements java.util.Iterator<AnyType> {
        private int current = 0;

        public boolean hasNext() {
            return current < size();
        }

        public AnyType next(){
            if(!hasNext())
                throw new java.util.NoSuchElementException();

            return theItems[current++];
        }

        public void remove(){
            //MyArraList.this代表外层类MyArrayList的对象
            //--current这里暂解释为remove在next方法后调用，next让current++,
            //这里让current回到原来位置，删除它
            //因为如果不调用next直接remove,current会出现<0情况
            MyTestArrayList.this.remove(--current);
        }
    }

}

数组相较于上面的链表感觉删除就比较坑了，毕竟不知道要删除哪个元素。如果删除头元素，那么整个数组都要进行一次循环赋值，很坑的。其他的两者基本上都有点类似了。