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();
	}
}

你可能感兴趣的:(数据结构,#,队列,java数据结构,队列)