使用java.util包中的Stack类创建一个栈对象
为北仑等地区用户提供了全套网页设计制作服务，及北仑网站建设行业解决方案。主营业务为成都做网站、成都网站制作、北仑网站设计，以传统方式定制建设网站，并提供域名空间备案等一条龙服务，秉承以专业、用心的态度为用户提供真诚的服务。我们深信只要达到每一位用户的要求，就会得到认可，从而选择与我们长期合作。这样，我们也可以走得更远！
public Object push(Object data);输入数据，实现压栈
public Object pop();输出数据，实现弹栈
public boolean empty()判空
public Object peek();查看栈顶元素
可以去查查API嘛
我也是学java的，大家一起进步。
用顺序栈实现数制转换的Java程序如下:
import java.util.Scanner;
import java.util.Stack;
public class jinzhi3 {
public static void main(String arg[]){
Scanner y=new Scanner(System.in);
System.out.println("请输入十进制数");
int b=y.nextInt();
jinzhi3 j=new jinzhi3();
j.ErJinZhi(b);
j.BaJinZhi(b);
j.ShiLiuJinZhi(b);
}
//转化成二进制
void ErJinZhi(int a){
StackInteger s=new StackInteger();
String str="";
while(a0)
{
s.push(a%2);
a=a/2;
}
while(!s.isEmpty()){
str=str+s.pop();
}
System.out.println("二进制是"+str);
}
//转化成八进制
void BaJinZhi(int a){
StackInteger s=new StackInteger();
String str="";
while(a0)
{
s.push(a%8);
a=a/8;
}
while(!s.isEmpty()){
str=str+s.pop();
}
System.out.println("八进制是"+str);
}
//转化成十六进制
void ShiLiuJinZhi(int a){
int c=0;
String str="";
StackCharacter s=new StackCharacter();
while(a0)
{
c=a%16;
switch(c){
case(10):s.push('A');break;
case(11):s.push('B');break;
case(12):s.push('C');break;
case(13):s.push('D');break;
case(14):s.push('E');break;
case(15):s.push('F');break;
default:s.push((char)(a%16+48));
}
a=a/16;
}
while(!s.isEmpty()){
str=str+s.pop();
}
System.out.println("十六进制是"+str);
}
}
运行结果:
请输入十进制数
28
二进制是11100
八进制是34
十六进制是1C
描述栈抽象数据类型的SStack接口的声明
public interfaceSStackE //栈接口
{
boolean isEmpty(); //判断是否空栈，若空栈返回true
boolean push(E element); //元素element入栈，若操作成功返回true
E pop(); //出栈，返回当前栈顶元素，若栈空返回null
E get(); //取栈顶元素值，未出栈，若栈空返回null
}
顺序栈类具体操作方法的声明：
importdataStructure.linearList.SStack;
public classSeqStackE implements SStackE
//顺序栈类
{
private Object value[]; //存储栈的数据元素
private int top; //top为栈顶元素下标
public SeqStack(int capacity) //构造指定容量的空栈
{
this.value = newObject[Math.abs(capacity)];
this.top=-1;
}
public SeqStack() //构造默认容量的空栈
{
this(10);
}
public boolean isEmpty() //判断是否空栈，若空栈返回true
{
return this.top==-1;
}
public boolean push(E element) //元素element入栈，若操作成功返回true
{
if (element==null)
return false; //空对象（null）不能入栈
if (this.top==value.length-1) //若栈满，则扩充容量
{
Object[] temp = this.value;
this.value = newObject[temp.length*2];
for (int i=0; itemp.length;i++)
this.value[i] = temp[i];
}
this.top++;
this.value[this.top] = element;
return true;
}
public E pop() //出栈，返回当前栈顶元素，若栈空返回null
{
if (!isEmpty())
return (E)this.value[this.top--];
else
return null;
}
public E get() //取栈顶元素值，未出栈，栈顶元素未改变
{
if (!isEmpty())
return (E)this.value[this.top];
else
return null;
}
public String toString() //返回栈中各元素的字符串描述
{
String str="{";
if (this.top!=-1)
str +=this.value[this.top].toString();
for (int i=this.top-1; i=0; i--)
str += ","+this.value[i].toString();
return str+"} ";
}
实例引用public static void main(String args[])
{
SeqStackString stack = newSeqStackString(20);
System.out.print("Push: ");
char ch='a';
for(int i=0;i5;i++)
{
String str =(char)(ch+i)+"";
stack.push(str);
System.out.print(str+" ");
}
System.out.println("\n"+stack.toString());
System.out.print("Pop : ");
while(!stack.isEmpty()) //全部出栈
System.out.print(stack.pop().toString()+" ");
System.out.println();
}
这确实有点奇葩，要么修改resize方法，在进行复制的时候，先判断一下front和rear的值，如果front不为0，说明进行过出队列操作，再判断rear与front的值：
if(front rear ){ //copy from front to rear 这样就可以去除多余的空位置，让front从0开始}
if(front rear ){
//先复制后半段到新的数组，然后复制前半段到新数组的后面，这就保证0位置的就是队列的头
}
这样的话，就可以理解为什么resize之后将front置为0,。
不知道这样的解释对不对，我看完上面的代码觉得就是这样的。
首先看你的顺序表是个什么结构 ，是数组结构的话，一般是创建新数组 size是原有数组的2倍，然后用array copy的方法将原有数据copy到新数组上 ，
如果是链表结构 ，可以动态扩展 ，只需要增加链表节点即可，并不需要特殊做resize
