java言語は配列行列を実現します(詳細な注釈を添付します).

public class Array<E> {
	int size;  //        
	E[] data;  //      
	
	/**
	 *        ，        
	 * @param capacity     
	 */
	public Array(int capacity) {
//		data=new E[capacity];      new    
		data=(E[])new Object[capacity];  //   new  object         
		size=0;
	}
	
	/**
	 *        ，        10
	 */
	public Array() {
		data=(E[])new Object[10];
		size=0;
	}
	
	/**
	 *          
	 * @return size       
	 */
	public int getSize() {
		return size;
	}
	
	/**
	 *        
	 * @return capacity     
	 */
	public int getCapacity() {
		return data.length;
	}
	
	/**
	 *         
	 * @return   
	 */
	public boolean isEmpty() {
		return size==0;
	}
	
	/**
	 *      index ，      
	 * @param index         
	 * @param e    
	 */
	public void add(int index,E e) {
		if (size==getCapacity())
//			throw new IllegalArgumentException("      ");
			resize(2*data.length);  //              ，    
		if (index<0||index>size)  //index    ，            ， index=size ，       
			throw new IllegalArgumentException("index  ");
		for (int i = data.length-1; i >=index; i--) {
			data[i+1]=data[i];
		}
		data[size]=e;
		size++;
	}

	/**
	 *               
	 * @param e
	 */
	public void addLast(E e) {
//		if (size==getCapacity()) 
//			throw new IllegalArgumentException("      ");
//		data[size]=e;
//		size++;   //data[size++]=e;
		add(size, e);
	}
	
	/**
	 *           
	 * @param e
	 */
	public void addFirst(E e) {
		add(0, e);
	}
	
	/**
	 *   index    
	 * @param index
	 * @return
	 */
	public E get(int index) {
		if (index<0||index>size)  //index    ，            ， index=size ，       
			throw new IllegalArgumentException("index  ");
		return data[index];
	}
	
	/**
	 *         
	 */
	public E getLast() {
		return get(data.length);
	}
	
	/**
	 *   index    
	 * @param index
	 * @return
	 */
	public void set(int index,E e) {
		if (index<0||index>size)  //index    ，            ， index=size ，       
			throw new IllegalArgumentException("index  ");
		data[index]=e;
	}
	
	/**
	 *         e
	 * @param e
	 * @return
	 */
	public boolean contains(E e) {
		for (int i = 0; i < size; i++) {
			if (data[i]==e) {
				return true;
			}
		}
		return false;
	}
	
	/**
	 *        e      
	 * @param e
	 * @return           ，     -1
	 */
	public int find(E e) {
		for (int i = 0; i < size; i++) {
			if (data[i]==e) {
				return i;
			}
		}
		return -1;
	}
	
	/**
	 *   index    
	 * @param index
	 * @return       
	 */
	public E remove(int index) {
		if (index<0||index>=size)  //index    ，          
			throw new IllegalArgumentException("index  ");
		E res=data[index];
		for (int i = index+1; i < data.length; i++) {
			data[i-1]=data[i];
		}
		size--;
		data[size]=null;  //          ，             GC  。    ！=    
//		if (size==data.length/2) {
//			resize(data.length/2);  //        ，       
//		}
		if (size==data.length/4) {  //     ，      1/4 ，       ，         ，  O(1)    
		resize(data.length/2);  //        ，       
	}
		return res;
	}

	/**
	 *         
	 */
	public E removeFirst() {
		return remove(0);
	}
	
	/**
	 *         
	 */
	
	public E removeLast() {
		return remove(data.length);
	}
	/**
	 *        e        
	 * @param e
	 * @return     
	 */
	public boolean removeElement(E e) {
		int res = find(e);
		if (res!=-1) {
			remove(res);
			return true;
		}
		return false;
	}

	/**
	 *     （   private       ）
	 * @param newCapacity
	 */
	private void resize(int newCapacity) {
		E[] newdata=(E[])new Object[newCapacity];
		for (int i = 0; i < data.length; i++) {
			newdata[i]=data[i];
		}
		data=newdata;
	}
}

public class Queue<E> {
	Array<E> array;
	
	public Queue() {
		array=new Array<E>();
	}
	
	public Queue(int capacity) {
		array=new Array<E>(capacity);
	}	
	
	/**
	 *   ，       
	 */
	void enqueue(E e) {
		array.addLast(e);
	}
	
	/**
	 *   ，      
	 */
	void dequeue(E e) {
		array.removeFirst();
	}
	
	/**
	 *     
	 */
	void getFront(E e) {
		array.get(0);
	}
	
	/**
	 *        
	 */
	int getSize() {
		return array.getSize();
	}	
	
	/**
	 *       
	 */
	boolean isEmpty(){
		return array.isEmpty();
	}
}