使用java实现后进先出的堆栈功能【笔试题】

今天看到某公司的笔试题，题目如下：

1.      请编写代码实现Stack类，该类能够实现后进先出的堆栈功能，要求实现的方法包括：

------Stack(int) –实例化指定深度的栈

------ boolean push(E item) – 向栈顶压入对象，成功返回true，栈已满返回false

------ E pop() – 从栈顶移除对象并返回，如栈为空返回null

------ E peek() – 查看并返回栈顶的对象，如栈为空返回null

------ int size() – 返回堆栈中当前的元素数量

------ int depth() –返回当前堆栈深度

实现时无需考虑线程安全性，不可借助Java集合框架实现。

以下代码均为个人理解，欢迎吐槽。

Stack类：

package Stack;

public class Stack<E> {

	/**
	 * 模拟栈对象
	 */
	private Object[] elementData;

	/**
	 * 模拟栈大小值
	 */
	private int elementSize;

	/**
	 * 模拟向栈中增加对象的个数。
	 */
	private static int modCount = 0;

	/**
	 * 实例化指定深度的栈
	 * 
	 * @param elementSize
	 *            栈的深度
	 */
	public Stack(int elementSize) {
		if (elementSize < 0) {
			throw new IllegalArgumentException("输入有误,elementSize: "
					+ elementSize + "必须大于0");
		} else {
			this.elementData = new Object[elementSize];
			this.elementSize = elementSize;
		}
	}

	/**
	 * 默认栈的深度为5
	 */
	public Stack() {
		this(5);
	}

	/**
	 * 向栈顶压入对象，成功返回true，栈已满返回false
	 * 
	 * @param item
	 *            要压入栈的对象
	 * @return
	 */
	public boolean push(E item) {
		boolean returnType;
		// 每当进行入栈操作时，先给计数器自增。
		modCount++;
		if (modCount <= elementSize) {
			elementData[modCount-1] = item;
			returnType = true;
		} else {
			// 堆栈已满，返回false
			returnType = false;
		}
		return returnType;
	}

	/**
	 * 从栈顶移除对象并返回 如栈为空返回null
	 * 
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public E pop() {
		if (modCount != 0) {
			// 当modCount不等于0即堆栈不为空的时候，返回元素并且移除元素
			E e = (E) elementData[modCount-1];
			elementData[modCount-1] = null;
			modCount--;
			return e;
		} else {
			return null;
		}
	}

	/**
	 * 查看并返回栈顶的对象，如栈为空返回null
	 * 
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public E peek() {
		// 当modCount不等于0即堆栈不为空的时候，返回元素
		if (modCount != 0) {
			return (E) elementData[modCount-1];
		} else {
			return null;
		}
	}

	/**
	 * 返回当前堆栈中元素数量
	 * 
	 * @return
	 */
	public int size() {
		return modCount;
	}

	/**
	 * 返回当前堆栈的深度
	 * 
	 * @return
	 */
	public int depth() {
		return elementSize;
	}
}

测试类：

package Stack;

import java.util.Scanner;

public class StackTest {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入想要创建的栈的深度，仅限数字输入，默认深度为5...");
		String elementSize = scanner.nextLine();
		System.out.println("请输入想要添加的元素个数，仅限数字输入...");
		String addSize = scanner.nextLine();
		numberOf(Integer.parseInt(elementSize), Integer.parseInt(addSize));
	}

	/**
	 * 
	 * @param elementSize
	 *            栈的深度
	 * @param addSize
	 *            增加元素的个数
	 */
	private static void numberOf(int elementSize, int addSize) {
		Stack<Object> stack = new Stack<Object>(elementSize);
		// 如果新增的元素小于堆栈深度
		if (addSize <= elementSize) {
			for (int i = 1; i <= addSize; i++) {
				boolean type = stack.push("测试数据" + i);
				if (type == true) {
					System.out.println("成功新增第" + i + "个元素！");
				} else {
					System.out.println("新增第" + i + "个元素时，堆栈已满！");
				}
			}
			System.out.println("*********************************");
			System.out.println("当前堆栈的深度为：" + stack.depth());
			System.out.println("当前堆栈中元素的个数为：" + stack.size());
			System.out.println("当前堆栈中栈顶的元素为：" + stack.peek());
			System.out.println("当前堆栈中从栈顶移除的元素为：" + stack.pop());
			System.out.println("移除后，当前堆栈中栈顶的元素为：" + stack.peek());
			System.out.println("移除后，当前堆栈中元素的个数为：" + stack.size());
		} else {
			for (int i = 1; i <= addSize; i++) {
				boolean type = stack.push("测试数据" + i);
				if (type == true) {
					System.out.println("成功新增第" + i + "个元素！");
				} else {
					System.out.println("新增第" + i + "个元素时，堆栈已满！");
				}
			}
		}
	}
}

运行结果：

具体可参考

参照jdk1.7中，java.util.Stack包 、java.util.Vector包 及相关实现类完成。如果有更好的解法可以改进或者留言博主。