Java数组实现自定义栈

栈是一种“后进先出（LIFO）”的数据结构，最后压入的数据项总是位于栈顶的位置，下面是维基百科中对栈的定义：

堆栈（英语：stack），也可直接称栈。台湾作堆叠，在计算机科学中，是一种特殊的串行形式的数据结构，它的特殊之处在于只能允许在链结串行或阵列的一端（称为堆叠顶端指标，英语：top）进行加入资料（英语：push）和输出资料（英语：pop）的运算。另外堆叠也可以用一维阵列或连结串行的形式来完成。堆叠的另外一个相对的操作方式称为伫列。

由于堆叠数据结构只允许在一端进行操作，因而按照后进先出（LIFO, Last In First Out）的原理运作。

堆叠数据结构使用两种基本操作：推入（push）和弹出（pop）：

推入：将数据放入堆叠的顶端（阵列形式或串行形式），堆叠顶端top指标加一。
弹出：将顶端数据资料输出（回传），堆叠顶端资料减一。

实际应用：

a、在我们熟悉的图形化界面编程中，例如那种撤销操作，撤销最近一次执行的操作，大多数情况下就是使用栈这种特殊的数据结构来实现的，当然使用其他的方式也可以实现。

b、可以实现对一个字符串进行反转操作，当然这里是可以实现，但是并不推荐这样去做，实际上直接使用数组反序输出更加方便快捷，效率也更高。

1、首先我们先定义一个Stack Interface,我们把他定义成泛型的.

package com.stack;
/**
* 栈接口
* @author feizi
* @time 2015-1-12下午3:23:32
*/
public interface StackInterface<E> {

//获取堆栈长度
public int size();

//入栈
public void push(E element) throws Exception;

//出栈
public E pop() throws Exception;

//获取栈顶元素
public E peek() throws Exception;

//获取栈中元素个数
public int getElementCount();

//判断是否当前栈顶指针没有到达栈底
public boolean hasMoreElement();

//判断栈空
public boolean isEmpty();

//判断栈溢
public boolean isFull();

//清空栈
public void clear();
}

2、然后，利用数组实现堆栈，

package com.stack;

import java.util.Arrays;

/**
* 栈接口的具体实现类
* @author feizi
* @time 2015-1-12下午3:44:36
*/
public class ArrayStack<E> implements StackInterface<E> {

private final int DEFAULT_SIZE = 3;//堆栈初始化时缺省大小
private int maxSize;//堆栈的最大容量
private E[] arrayObj;//数组

private int top;//栈顶指针

@SuppressWarnings("unchecked")
public ArrayStack(){
this.maxSize = DEFAULT_SIZE;
this.arrayObj = (E[]) new Object[this.maxSize];
top = -1;
}

@SuppressWarnings("unchecked")
public ArrayStack(int size){
this.maxSize = size;
this.arrayObj = (E[]) new Object[this.maxSize];
top = -1;
}

/**
* 获取堆栈长度
* @return
*/
public int size(){
return this.maxSize;
}

/**
* 获取堆栈中元素个数
*/
public int getElementCount() {
return this.top;
}

/**
* 入栈,
* @throws Exception
*/
public void push(E element) throws Exception {
if(null == element){
throw new Exception("入栈的元素不能为空！");
}
if(isFull()){
//如果栈满，就扩容
extendSize();

//或者如果不想扩容的话，可以在此处抛出异常
//throw new Exception("栈满不能入栈！");
}
this.arrayObj[++top] = element;
}

/**
* 出栈
* @throws Exception
*/
public E pop() throws Exception {
if(isEmpty()){
throw new Exception("栈空不能出栈");
}

//先保存栈顶元素
E element = (E) arrayObj[top];
//然后清空栈顶元素
arrayObj[top] = null;
//栈顶指针下移，栈中元素减少一个
top--;
return element;

//或者
//		return (E) this.arrayObj[top--];
}

/**
* 获取栈顶元素，先判空
* @throws Exception
*/
public E peek() throws Exception {
if(isEmpty()){
throw new Exception("栈为空！");
}
return (E) this.arrayObj[getElementCount()];
}

/**
* 判断是否当前栈顶指针没有到达栈底
*/
public boolean hasMoreElement() {
return getElementCount() >= 0 ? true : false;
}

/**
* 扩容，通常是在栈满以后才会扩充
*/
@SuppressWarnings("unchecked")
public void extendSize(){
this.maxSize = this.maxSize + this.DEFAULT_SIZE;
Object[] newArray = new Object[this.maxSize];

//使用java.lang包中提供的system.arrcopy()方法复制数组
System.arraycopy(arrayObj, 0, newArray, 0, arrayObj.length);
//将原数组置空
Arrays.fill(arrayObj, null);

this.arrayObj = (E[]) newArray;
}

/**
* 判断栈空
*/
public boolean isEmpty() {
return this.top == -1;
}

/**
* 判断栈溢
*/
public boolean isFull() {
return this.top + 1 == this.maxSize;
}

/**
* 清空栈
*/
@SuppressWarnings("unchecked")
public void clear() {
//将数组置空
Arrays.fill(arrayObj, null);
//栈顶指针重置
this.top = -1;
this.maxSize = this.DEFAULT_SIZE;
this.arrayObj = (E[]) new Object[this.maxSize];
}

public static void main(String[] args) throws Exception {
StackInterface<Object> myStack = new ArrayStack<Object>();
System.out.println("==栈的总容量："+myStack.size());
System.out.println("==堆栈的元素个数："+myStack.getElementCount());

myStack.push(1);
myStack.push("root");
myStack.push(2);
myStack.push(3);
myStack.push("admin");
myStack.push(4);
myStack.push("feizi");

System.out.println("==栈的总容量："+myStack.size());
System.out.println("==堆栈的元素个数："+myStack.getElementCount());
System.out.println("栈顶元素为："+myStack.peek());

while (myStack.hasMoreElement()) {
System.out.println("栈指针："+myStack.getElementCount()+",栈元素："+myStack.pop());
}

//清空栈
myStack.clear();
System.out.println("==栈的总容量："+myStack.size());
System.out.println("==堆栈的元素个数："+myStack.getElementCount());

while (myStack.hasMoreElement()) {
System.out.println("================栈顶元素为："+myStack.peek());
System.out.println("栈指针："+myStack.getElementCount()+",栈元素："+myStack.pop());
}
}
}