用Java实现简单的队列和栈（数组形式）

队列

这里用Java实现的是顺序队列，关于链表式队列和循环队列后期再写。
首先写一个接口文件。

public interface Queue_Interface {
	//插入
	public void add_element(Object obj);//void表示无返回值
	//删除
	public Object pop();
	//获取front数
	public Object getfront();
	//判断空
	public boolean isEmpty();
	//显示队列
	public void Display();
	//长度
	public int length();
	//清除队列
	public void clear();
}

然后是队列类，继承接口并实现各个方法。

//顺序队列（即数组方式实现
public class Queue implements Queue_Interface{

	public int front,rear; //定义队头和队尾
	static final int defaultsize = 10;//默认队总长
	public Object Element[]; //数组存放数据
	
	//默认构造函数
	public Queue() {
		front = rear = 0;
		Element = new Object[defaultsize];
	}
	//有参数构造函数
	public Queue(int size) {
		front = rear = 0;
		Element = new Object[size];
	}
	@Override
	public void add_element(Object obj) {
		Element[rear] = obj;
		rear++;  //队尾push进数据后，队尾数加一
	}

	@Override
	public Object pop() {
		Object a = Element[front];
		front++;  //队头加一，然后返回原来队头所指数据
		return a;
	}

	@Override
	public Object getfront() {
		return Element[front];
	}

	@Override
	public boolean isEmpty() {
		if (front == rear) {
			return false;
		}else {
			return true;
		}
	}

	@Override
	public void Display() {
		for(int i = front ; i<rear ; i++)     //从队头开始遍历获取队列内数据
		{
			System.out.println(Element[i]);
		}
	}

	@Override
	public int length() {
		return rear-front;
	}

	@Override
	public void clear() {
		front = rear = 0;
	}	
	
}

最后是测试：

public class TEST_Queue {
	public static void main(String[] args) {
		Queue que1 = new Queue();
		que1.add_element(1);
		que1.add_element("啊");
		que1.add_element("abc");
		que1.add_element(3.1415926);
		System.out.println("添加四个数据后:");
		que1.Display();
		System.out.println("此时队列长度为"+ que1.length());
		System.out.println("弹出front一次后：");
		que1.pop();
		que1.Display();
		System.out.println("此时队列长度为"+ que1.length());
		System.out.println("队列第一位为："+ que1.getfront());
		System.out.println("弹出front两次后：");
		que1.pop();
		que1.Display();
		System.out.println("此时队列长度为"+ que1.length());
		System.out.println("清空队列：");
		que1.clear();
		System.out.println("此时队列内：");
		que1.Display();
		System.out.println("队列长度为："+que1.length());
	}
}

测试效果如下：

栈

接口文件：

public interface Stack_Interface {
	public void push(Object obj);//入栈
	public Object pop();//出栈
	public Object gettop();//获取栈顶元素
	public void clear();//清栈
	public boolean isEmpty();//判断栈是否为空
	public void Display();//显示栈内数据
	
}

接口实现文件：

public class Stack implements Stack_Interface{

	public int top;
	public int maxsize;
	public Object se[];
	public Stack(int size) {
		top = -1;
		maxsize = size;
		se = new Object[maxsize];
	}
	
	@Override
	public void push(Object obj) {
		se[++top] = obj;  //入栈时先自增后赋值，此时栈顶位置在0处。
	}

	@Override
	public Object pop() {
		Object a = se[top];
		top--;               //此处也可以写成  return se[top--]。栈顶数据pop后top值减1
		return a;
	}

	@Override
	public Object gettop() {
		return se[top];
	}


	@Override
	public void clear() {
		int i = -1;
		while (top > i) {
			this.pop();          //清空栈数据实际上就是不断pop掉每个数据
		}
	}

	@Override
	public boolean isEmpty() {
		if (top == -1) {
			return true;
		}else
		{
			return false;
		}
	}

	@Override
	public void Display() {
		for (int i = 0; i <= top; i++) {
			System.out.println(se[i]);
		}
	}
	
}

栈测试：

public class TSET_Stack {
	public static void main(String[] args) {
		Stack stack = new Stack(5);
		stack.push(1);
		stack.push("啊");
		stack.push(3.1415926);
		stack.push("abcd123");
		stack.push(1010608859);
		stack.Display();
		System.out.println("出栈一次后");
		stack.pop();
		stack.Display();
		System.out.println("出栈两次后");
		stack.pop();
		stack.Display();
		System.out.println("获取栈顶数据为："+ stack.gettop());
		System.out.println("清空栈后");
		stack.clear();
		stack.Display();
		System.out.println("清空栈后重新push一个数据");
		stack.push("啦啦");
		stack.Display();
	}
}

测试效果如下：

关于队列和栈的实现里面都还没有用到异常处理，这里仅仅是初步用Java实现了队列和栈的基本功能。