使用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包 及相关实现类完成。如果有更好的解法可以改进或者留言博主。