栈和队列的java实现

栈是先进后出的数据结构，队列是先进先出的数据结构，都有用数组和用链表的两种实现方式，我这里写的Stack1是用数组实现，Stack2和Queue是用链表实现，比较简单，直接看代码。

package simpleStructure;

import java.util.Iterator;

public class Stack1<Item> implements Iterable<Item>
{



    private Item[] items;

    // size是items中实际元素的个数，与items.length不同
    private int size;

    public Stack1()
    {
        items = (Item[]) new Object[1];
        size = 0;
    }

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

    public int size()
    {
        return size;
    }

    // 重新分配数组空间以max大小
    public void resize(int max)
    {
        Item[] temp = (Item[]) new Object[max];
        for (int i = 0; i < size; i++)
        {
            temp[i] = items[i];
        }
        items = temp;
        temp = null;
    }

    public void push(Item i)
    {
        if (size == items.length)
        {
            resize(size * 2);
        }
        items[size++] = i;
    }

    public Item pop()
    {
        if (size > 0)
        {
            if (size == items.length / 4)
            {
                resize(items.length / 2);
            }

            Item temp = items[--size];
            items[size] = null;

            return temp;
        }
        return null;
    }

    private class MyIterator<Item> implements Iterator<Item>
    {
        private int s = size;

        @Override
        public boolean hasNext()
        {
            return s > 0;
        }

        @Override
        public Item next()
        {
            return (Item) items[--s];
        }

        @Override
        public void remove()
        {
        }

    }

    @Override
    public Iterator<Item> iterator()
    {
        return new MyIterator<Item>();
    }

}

下面是stack2

package simpleStructure;

import java.util.Iterator;

public class Stack2<Item> implements Iterable<Item>
{
    private class Node
    {
        Item item;
        Node next;
    }

    private Node first;
    private int size;


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

    public int size()
    {
        return size;
    }

    public void push(Item i)
    {
        Node oldFirst = first;
        first = new Node();
        first.item = i;
        first.next = oldFirst;
        oldFirst = null;
        size++;
    }

    public Item pop()
    {
        if (size > 0)
        {
            Item i = first.item;
            first = first.next;
            size--;

            return i;
        }
        return null;
    }

    private class MyIterator<Item> implements Iterator<Item>
    {
        private Node current = first;


        @Override
        public boolean hasNext()
        {
            // TODO Auto-generated method stub

            return current != null;
        }

        @Override
        public Item next()
        {
            // TODO Auto-generated method stub
            Item i = (Item) current.item;
            current = current.next;
            return i;
        }

        @Override
        public void remove()
        {
            // TODO Auto-generated method stub

        }

    }

    @Override
    public Iterator<Item> iterator()
    {
        // TODO Auto-generated method stub
        return new MyIterator<Item>();
    }

}

下面是Queue

package simpleStructure;

import java.util.Iterator;


public class Queue<Item> implements Iterable<Item>
{
    private class Node
    {
        Item item;
        Node next;
    }

    private Node first;
    private Node last;
    private int size;

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

    public int size()
    {
        return size;
    }

    public void enqueue(Item i)
    {
        Node oldLast = last;
        last = new Node();
        last.item = i;
        if (oldLast == null)
        {
            first = last;
        } else
        {
            oldLast.next = last;
        }

        size++;
    }

    public Item dequeue()
    {
        if(size > 0)
        {
            Item i = first.item;
            first = first.next;
            if(first == null) last = null;
            size--;
            return i;
        }
        return null;
    }

    private class MyIterator<Item> implements Iterator<Item>
    {
        private Node current = first;


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

        @Override
        public Item next()
        {
            // TODO Auto-generated method stub
            Item i = (Item) current.item;
            current = current.next;
            return i;
        }

        @Override
        public void remove()
        {
            // TODO Auto-generated method stub

        }

    }

    @Override
    public Iterator<Item> iterator()
    {
        // TODO Auto-generated method stub
        return new MyIterator<Item>();
    }


}

写了这两个结构其实我还是有几点疑问的，希望大神帮我解答一下。
1、队列用数组怎么实现呢，不是固定数量的队列。
2、items = (Item[]) new Object[1];会报警告，因为不能直接实例化泛型数组，有没有更好的办法来实例化，从而消除警告。
3、链表单元Node是不是写成静态内部类更好，因为普通的内部类会持有外部类的引用，造成资源浪费，这里并不需要。