ArrayList和LinkedList

    在平时的编程中经常用到ArrayList和LinkedList,它的区别在于效率方面的问题，ArrayList中是以数组为基础的存储方式，而LinkedList是以链表为基础的存储方式。当我们要获取一个数据时ArrayList效率比LinedList高,当要增加和删除数据时除了对末端的数据进行操作效率相等外，其它的都是LinkedList的效率要高。

    自己实现ArrayList代码:

package com.example.arze.tree;

import java.util.Iterator;

/**
 * Created by arze on 2015/11/27.
 */
public class MyListView<E>   {
    private static final int DEFAULT_SIZE =  10;
    private E [] arr;
    private int size;
    public MyListView () {
        size = 0;
        arr = (E[]) new Object[DEFAULT_SIZE];
    }

    public int size () {
        return size;
    }

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

    private void  judgementSize (int newSize ) {
        if (newSize < size) {
            return;
        } else {
            E[] oldArr = arr;
            arr = (E[]) new Object[newSize];
            for (int i = 0 ;i < size (); i++) {
                arr[i] = oldArr[i];
            }
        }
    }

    public void  add (int index,E data) {
        if (arr.length == size) {
            judgementSize(size * 2 +1);
        }
        for (int i = size ; i > index;i++) {
             arr[i] = arr[i-1];
        }
        arr[index] = data;
        size++;
    }

    public void remove (int index) {
        if (index < 0 || index >= size)
            new IndexOutOfBoundsException("error");
        for (int i = index ; i < size -1 ; i ++) {
            arr[i] = arr [i+1];
        }
        size--;
    }

    public void clean () {
        size = 0;
        arr = (E[]) new Object[DEFAULT_SIZE];
    }

    public void add (E data) {
        if (arr.length == size) {
            judgementSize(size * 2 +1);
        }
        arr[size] = data;
        size++;
    }

    public E get(int index) {
        if (index >= size)
            new IndexOutOfBoundsException("error");
        return  arr[index];
    }
    public MyIterator iterator () {
        return new MyIterator();
    }
  private class MyIterator implements Iterator<E> {
     private int current = 0;
     @Override
     public boolean hasNext() {
         return current < size();
     }

     @Override
     public E next() {
         if (!hasNext()) {
             new Exception("error");
         }
         return arr[current++];
     }

     @Override
     public void remove() {
        MyListView.this.remove(current-- );
     }
 }

}

  自己实现LinkedList代码：

package com.example.arze.tree;

import java.util.Iterator;

/**
 * Created by arze on 2015/11/28.
 */
public class MyLinkedList<E> {
    //采用双链表
    private int size = 0;

    private class Node<E> {
        private E data;
        private Node next;
        private Node prev;
    }

    private Node head;
    private Node tail;

    public MyLinkedList() {
        clean();
    }

    public int size() {
        return size;
    }

    private boolean isEmpty() {
        return 0 == size();
    }

    public void clean() {
        size = 0;
        head = new Node();
        tail = new Node();
        head.next = tail;
        tail.prev = head;
    }

    public void add(E data) {
     /*   if (size == 0) {
            Node node = new Node();
            node.data = data;
            node.prev = head;
            node.next = tail;
            head.next  = node;
            tail.prev = node;
        } else { */
         /*   Node node = getNode(size - 1);
            Node newNode = new Node();
            node.next = newNode;
            newNode.data = data;
            newNode.prev = node;
            newNode.next = tail;
            tail.prev = newNode; */
            Node node = new Node();
            node.data = data;
            node.prev = tail.prev;
            node.next = tail;
            tail.prev.next = node;
            tail.prev = node;
            size++;
    }

    public void add(int index, E data) {
        if (index >= size) {
            add(data);
        } else {
            Node node = getNode(index);
            Node newNode = new Node();
            newNode.data = data;
            newNode.next = node;
            newNode.prev = node.prev;
            node.prev.next = newNode;
            node.prev = newNode;
            size++;
        }
    }

    public void remove(int index) {
        Node node = getNode(index);
        node.prev.next = node.next;
        node.next.prev = node.prev;
        size--;
    }

    private Node<E> getNode(int index) {
        if (index < 0 || index >= size())
            new IndexOutOfBoundsException("error");
        Node<E> node ;
        if (index < size() / 2) {
            node = head;
            for (int i = 0; i <= index; i++)
                node = node.next;
        } else {
            node = tail;
            for (int i = size(); i > index; i--) {
                node = node.prev;
            }
        }
        return node;
    }

    public E get(int index) {
        return getNode(index).data;
    }

    public Iterator iterator() {
        return new MyIterator();
    }

    private class MyIterator implements Iterator<E> {
        private int currentIndex = 0;

        @Override
        public boolean hasNext() {
            return currentIndex < size();
        }

        @Override
        public E next() {
            if (hasNext())
                new Exception("error");
            return getNode(currentIndex++).data;
        }

        @Override
        public void remove() {

        }
    }
}

       对于栈，能实现链表的模型都能实现栈，限制链表加入和移除只在末端操作。队列也是一样加入的时候只在前段加入，获取的时候只在末端获取。