public class Stack {
成都创新互联公司成立于2013年，我们提供高端网站建设、成都网站制作公司、成都网站设计、网站定制、全网整合营销推广、微信小程序、微信公众号开发、成都网站营销服务，提供专业营销思路、内容策划、视觉设计、程序开发来完成项目落地，为成都垃圾桶企业提供源源不断的流量和订单咨询。
private Object[] stack;
//这个不需要;
//private int top = 0; //初始化栈顶
//这个也不需要;
//写一个栈出来,最好是可以动态的,可以自己改变大小的,即数组的长度;
//private int size = 0; // 初始化大小
//元素个数;
private int size;
//默认长度为10;
public Stack(){
this(10);
}
//也可以自己设置长度,即容量;
public Stack(int len){
stack = new Object[len];
}
//返回元素个数;
public int size(){
return size;
}
//返回数组长度,即容量;
public int capacity(){
return stack.length;
}
//实现动态的数组;
public void ensureCapacity(){
if(size() == capacity()){
Object[] newStack = new Object[size() * 3 / 2 + 1];
System.arraycopy(stack, 0, newStack, 0, size());
stack = newStack;
}
}
//入栈;
public void push(Object o){
size++;
ensureCapacity();
stack[size - 1] = o;
}
/*
public void push(Object object) {
if (isFull()) {
System.out.println("栈满! 入栈失败");
}
stack[top++] = object;
}
*/
//判空;
public boolean isEmpty(){
return size == 0;
}
//出栈;
public Object pop(){
//首先要判空;
if(isEmpty()){
throw new ArrayIndexOutOfBoundsException("不能为空");
}
Object o = stack[--size];
stack[size] = null;
return o;
}
/*
// 出栈
public Object pop() {
Object object = stack[--top];
stack[top] = null;
return object;
}
*/
/*
// 计算栈当前大小
public int size() {
return top;
}
// 判断是否是空栈
public boolean isEmpey() {
return top == 0;
}
// 判断是否栈满
public boolean isFull() {
return top = size;
}
public Stack(int size) {
this.size = size;
}
*/
public static void main(String[] args) {
Stack stack = new Stack(3);
String[] data = new String[] { "a", "b", "c" };
for (int i = 0; i data.length; i++) {
stack.push(data[i]);
System.out.println(data[i] + "");
}
System.out.println("***********");
while (!stack.isEmpty()) {
System.out.println(stack.pop() + "");
}
//}
}
}
你自己对比一下,我是在你的里面修改的
import java.util.Stack;
public class Translate {
//程序入口
public static void main(String[]args){
int n = Translate.translate(3467,8);
System.out.println("结果是："+n);
}
public static int translate(int number, int base_num) {
//使用栈
StackIntegerstack = new StackInteger();
while(number0){
//压栈
stack.push(number % base_num);
number /= base_num;
}
int n = stack.size();
int val=0;
//依次出栈并合成结果（用我们熟悉的十进制表示，所以乘以10）
for(int i=0;in;i++){
val=val*10+stack.pop();
}
return val;
}
}
可以利用LinkedList 来写一个栈. 例如
import java.util.* ;
public class testStack{
private LinkedList list = new LinkedList() ;
public void push(Object o ){
try{
list.addFirst( o ) ;
}catch(Exception e){
}
}
public Object pop(){
return list.removeFirst() ;
}
public Object top() {
return list.getLast() ;
}
public static void main(String[] args){
//code here
testStack s = new testStack() ;
for( int i = 0 ; i10 ;i++){
s.push( i );
}
System.out.println ( s.pop());
System.out.println(s.top());
}
}
你可以好好看看Thinking in JAVA中对集合的讲解。。
使用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
//这是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;
}