13518219792
你得明白栈的定义。代码执行的时候是执行一个方法，执行完，返回方法的上一个代码块继续往下执行后面的内容。这样的话是不是就是一个栈结构了？先进后出。方法一边执行，一边往栈里面存数据，等执行完了就取出数据（取出的是返回值，是最后一个存进去的 栈结构是后进先出），然后执行外面的代码。这么说你可能不明白，我给你举个例子。
专注于为中小企业提供做网站、网站设计服务,电脑端+手机端+微信端的三站合一,更高效的管理,为中小企业井陉矿免费做网站提供优质的服务。我们立足成都，凝聚了一批互联网行业人才，有力地推动了上1000家企业的稳健成长，帮助中小企业通过网站建设实现规模扩充和转变。
int sub(int a,int b){
return a+b;
}
int c = sub(2,3);//注意执行这条语句的时候是不是执行了一个方法？
//那么语句执行的时候是要从左往右执行的对吧，但是事实的逻辑却是先算出来sub（2，3）这个方
//法的返回值，然后再把返回值（5）赋值给 c ，那么这个怎么实现，肯定是一个栈的数据结构，编译的时候先把”int c = “入栈，然后再把 sub（2，3），入栈，执行的时候，从栈里面取，取的第一个肯定是sub（2，3）吧？于是就计算出等于5，继续取，取出了int c =，然后就和5对接上了，就把值赋给c了。这只是一个小例子。
道理是这样，但是具体的存取可不是这样的哦。具体的存取应该分的非常细腻，应该是按照java语法的最小单位来往栈里存取的。说白了一句话，程序运行的时候的先后顺序是跟人大脑想问题的顺序一样的，但是代码不是按照这样的顺序写的（从左到右），于是就用栈结构来达到这样的效果。
这么说，明白了吗？
//栈接口
/**
* 2016/10/31 10:19
*
* @author 3306 TODO
*/
public interface StackInterfaceT {
/**
* 压入元素
*
* @param element 元素
*/
void push(T element);
/**
* 弹出栈顶元素
*
* @return T
*/
T pop();
}
//固定长度栈
/**
* 2016/10/31 10:03
*
* @param T 压入元素类型
* @author 3306 TODO 固定长度栈
*/
public class FixedStackT implements StackInterfaceT{
private Object[] objects = new Object[10];
private int index = 0;
/**
* 往固定长度栈压入元素
*
* @param element 元素
* @throws IndexOutOfBoundsException 压缩元素大于栈的容量的时候
*/
public void push(T element) {
if (index objects.length) {
throw new IndexOutOfBoundsException();
}
objects[index++] = element;
}
/**
* 弹出栈顶元素
*
* @return T
*/
public T pop() {
if (index 0) {
throw new IndexOutOfBoundsException();
}
return (T) objects[--index];
}
}
//动态栈
import java.util.ArrayList;
import java.util.List;
/**
* 2016/10/31 10:23
*
* @author 3306 TODO
*/
public class FreeStackT implements StackInterfaceT {
private ListT storage = new ArrayList();
private int index = 0;
@Override
public void push(T element) {
if (null == element) {
throw new IllegalArgumentException();
}
storage.add(element);
index++;
}
@Override
public T pop() {
if (index 0) {
throw new IndexOutOfBoundsException();
}
return storage.get(--index);
}
}
//student类
/**
* 2016/10/31 10:11
*
* @author 3306 TODO
*/
public class Student {
private int studentNo;
private String studentName;
public int getStudentNo() {
return studentNo;
}
public void setStudentNo(int studentNo) {
this.studentNo = studentNo;
}
public String getStudentName() {
return studentName;
}
public void setStudentName(String studentName) {
this.studentName = studentName;
}
@Override
public String toString() {
return "Student{" +
"studentNo=" + studentNo +
", studentName='" + studentName + '\'' +
'}';
}
}
//测试类
/**
* 2016/10/31 10:12
*
* @author 3306 TODO
*/
public class TestStack {
public static void main(String[] args) {
testStableStack();
testFreeStack();
}
private static void testStableStack() {
System.out.println("\n\n----------- fixed ------------");
StackInterfaceStudent myStack = new FixedStack();
int numOfStudent = 3;
for (int index = 0; index numOfStudent; index++) {
Student stu = new Student();
stu.setStudentNo(index);
stu.setStudentName("stu" + index);
myStack.push(stu);
}
for (int index = 0; index numOfStudent; index++) {
System.out.println(myStack.pop());
}
}
private static void testFreeStack() {
System.out.println("\n\n----------- free ------------");
StackInterfaceStudent freeStack = new FreeStack();
int numOfStudent = 5;
for (int index = 0; index numOfStudent; index++) {
Student stu = new Student();
stu.setStudentNo(index);
stu.setStudentName("stu" + index);
freeStack.push(stu);
}
for (int index = 0; index numOfStudent; index++) {
System.out.println(freeStack.pop());
}
}
}
//这是JDK提供的栈
import java.util.Stack;
public class UsingStack {
public static void main(String[] args) {
//构造栈对象，使用类型限制，只能存储Integer数据
StackInteger s = new StackInteger();
//1、2、3依次入栈
s.push(1);
s.push(2);
s.push(3);
//3、2、1依次出栈
System.out.println(s.pop());
System.out.println(s.pop());
System.out.println(s.pop());
}
}
//这是我写的顺序结构的栈
import java.util.EmptyStackException;
import java.util.Vector;
public class UsingStack{
public static void main(String[] args){
//构造栈对象，使用类型限制，只能存储Integer数据
MyStackInteger s = new MyStackInteger();
//1、2、3依次入栈
s.push(1);
s.push(2);
s.push(3);
//3、2、1依次出栈
System.out.println(s.pop());
System.out.println(s.pop());
System.out.println(s.pop());
}
}
/**
* 栈类
* @author developer_05
* @param T
*/
class MyStackT extends VectorT{
/**
* 构造方法
*/
public MyStack(){
}
/**
* 入栈方法
* @param item 待入栈的元素
* @return 返回入栈的元素
*/
public T push(T item) {
addElement(item);
return item;
}
/**
* 出栈方法(同步处理)
* @return 返回出栈元素
*/
public synchronized T pop() {
T obj;
int len = size();
if (len == 0)
throw new EmptyStackException();
obj = elementAt(len - 1);
removeElementAt(len - 1);
return obj;
}
/**
* 判断栈是否为空的方法
* @return 返回true(栈空)或false(栈非空)
*/
public boolean empty() {
return size() == 0;
}
private static final long serialVersionUID = 1L;
}
