package MyArrayList;



public class MyLinkList <AnyType> implements Iterable<AnyType> {
    
    //内嵌类node，指向LinkList的头结点(header_node)与尾部结点(tail_node)；
    //父亲查看私有类的属性，但是外部不知道有这样私有元素
    private int theSize;
    private int modCount=0;
    private Node<AnyType> beginMaker;
    private Node<AnyType> endMaker;
    private static class Node<AnyType>
    {
        @SuppressWarnings("unused")
        public AnyType data;
        @SuppressWarnings("unused")//你从没有使用这个变量
        public Node<AnyType> prev;
        @SuppressWarnings("unused")
        public Node<AnyType> next;
        //构造函数初始化
        @SuppressWarnings("unused")
        public Node(AnyType data,Node<AnyType>p,Node<AnyType>q)
        {
            this.data=http://www.mamicode.com/data;
            this.prev=p;
            this.next=q;
        }
    }
    public void cLear()
    {
        //申请Node结点同时初始化，后面建立初始链表
        doClear();
    }
    private void doClear()
    {
         beginMaker=new Node<AnyType>(null,null,null);
         endMaker=new Node<AnyType>(null,beginMaker,null);
        beginMaker.next=endMaker;
        
        theSize=0;
        modCount++;
    }
    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,0,size()),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 AnyType remove(Node<AnyType> p)
    {
        p.next.prev=p.prev;
        p.prev.next=p.next;
        theSize--;
        modCount++;
        return p.data;
    }
    private void addBefore ( Node<AnyType> p,AnyType x)
    {
        //P的前面插入
        Node<AnyType>newNode=new Node<>(x,p.prev,p);
        
        p.prev.next=newNode;
        p.prev=newNode;
        theSize++;
        modCount++;
    }
    private Node<AnyType> getNode(int idx)
    {
        return getNode(idx,0,size()-1);
    }
    private Node<AnyType> getNode(int idx,int lower,int upper)
    {
        Node<AnyType>p;
        if(idx<lower || idx> upper)
            throw new IndexOutOfBoundsException();
        if(idx<size()/2)
        {
            p=beginMaker.next;
            for(int i=0;i<idx;i++)
                p=p.next;
        }
        else
        {
            p=endMaker;
            for(int i=size();i>idx;i--)
                p=p.prev;
        }
        return p;
    }
    //采用Iterator接口
    public java.util.Iterator<AnyType> iterator()
    {
        return new LinkedListIterator();
    }
    public class LinkedListIterator implements java.util.Iterator<AnyType>
    {
        private Node<AnyType> current =beginMaker.next;
        private int expectedModCount=modCount;//记录迭代器在迭代的期间被修改的次数
        private boolean okToremove=false;//判断是否已经执行移除操作

        @Override
        public boolean hasNext() {
            // TODO Auto-generated method stub
            return current!=endMaker ;
        }

        @Override
        public AnyType next() {
            // TODO Auto-generated method stub
            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()
        {
            // TODO Auto-generated method stub
                        if(modCount!=expectedModCount)
                            throw new java.util.ConcurrentModificationException();
                        if(!okToremove)
                            throw new java.util.NoSuchElementException();
            MyLinkList.this.remove(current.prev);
            expectedModCount++;
            okToremove=false;
        }
        
    }
    
    
}

package MyArrayList;
import 自己包下的MyLinkList
import java.util.Iterator;

//使用泛型类,实现Iterator的接口，必须实现Iterator中iterator方法
public class MyArrayList <AnyType> implements Iterable<AnyType>{
    private static final int DEFAULT_CAPACITY=10;//ArryList中默认的容量10
    
    private int theSize;
    private AnyType [] theItems;//Number of elements
    public MyArrayList()
    {//构造函数初始化
        doClear();
    }
    
    private void doClear()
    {
        theSize=0;
        //开辟一个默认为10的数组
        enSureCapacity(DEFAULT_CAPACITY);
    }
    
    /*****为了外部调用内部方法****/
    public int size()
    {
        return theSize;
    }
    public boolean isEmpty()
    {
        return size()==0;
    }
    public void trimToSize()
    {
        enSureCapacity(size());
    }
    @SuppressWarnings("unchecked")
    public void enSureCapacity(int newCapacity)
    {
        if(newCapacity<theSize)
            return;
        //如果发现要的容量大于theSize,必须开辟更多空间
        AnyType [] old=theItems;
        theItems=(AnyType[]) new Object[newCapacity];
        for(int i=0;i<theSize;i++)
            theItems[i]=old[i];
        
    }
    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 add(int idx,AnyType x)
    {//防止是否在数组满情况下相加
        if(size()==theItems.length)
        {
            enSureCapacity(size()*2+1);
        }
        //在idx位置上插入一个数，将idx右侧数据向右边移动，腾出插入位置
        for(int i=theSize;i>idx;i--)
            theItems[i]=theItems[i-1];
        theItems[idx]=x;
        theSize++;
        
        
    }
    public AnyType remove(int idx)
    {
        //与插入相反，将右侧位置覆盖就行
        AnyType removeItem=theItems[idx];
        for(int i=idx;i<size();i++)
            theItems[i]=theItems[i++];
        theSize--;
        return removeItem;
    }
    //对ArrayList数组数进行遍历：
    public void access()
    {  AnyType val=null;
    
        for(int i=0;i<size();i++)
        {
            val=theItems[i];
            System.out.print(val+" ");
        }
    }
    //实现Iterator下iterator方法
    @Override
    public    java.util.Iterator<AnyType>  iterator() {
        // TODO Auto-generated method stub
        return new ArrayListIterator();
        //这个实列实现Iterator接口
    }
    private class ArrayListIterator implements java.util.Iterator<AnyType>
    {
        private int current=0;
        @Override
        public boolean hasNext() {
            // TODO Auto-generated method stub
            
            return current<size();
        }

        @Override
        public AnyType next() {
            // TODO Auto-generated method stub
            if(!hasNext())
                throw new java.util.NoSuchElementException();
            return theItems[current++];
        }
        public void remove()
        {
            MyArrayList.this.remove(--current);
        }
        
    }
    public static  void main(String[] args)
    {
        MyArrayList<Integer> test=new MyArrayList<Integer>();
        test.enSureCapacity(10);
        test.add(0, 1);
        test.access();
        
    }

    
}

*****测试自己编写的LinkList*********
current val3
push stack top is c
After pop 2
pop stack top b
*****测试jdk的LinkList*********
2
1
*****测试自己编写的LinkList*********
显示队列中顶元素a
删除队列中元素a
显示队列中顶元素b
*****测试jdk的LinkList*********
queue.element():20
queue.remove():20