java stack 堆栈类实现_Java堆栈Stack类的使用

栈的官方概念 栈是java存放内存的两种结构之一。栈是限定仅在表尾进行插入或删除操作的线形表。

通俗的讲，往栈里面存数据，就是先进后出。最先存入的数据在最底部，取出的时候最后被取出。可以理解为吃饱了就吐.

在Java里面根据栈的这种概念提供了一个Stack类和相关的方法，可以很容易的实现栈的这些特性。

下面是几个主要特性的方法:

isEmpty(): 测试堆栈是否为空。

search(): 返回指定对象在堆栈中的位置。

firstElement(): 查看堆栈中最底部的对象。

peek(): 查看堆栈中最顶部的对象。

pop(): 移除堆栈中最顶部的对象，并返回该对象。

通过代码简单测试一下这几个方法

package _3_5_test;

import java.util.Iterator;

import java.util.Stack;

public class SeventyThreeTest {

public static void main(String[] args) {

// TODO Auto-generated method stub

Stack stack = new Stack<>();

boolean flag1 = stack.isEmpty();

System.out.println("未添加数据前，对栈是否为空进行判断："+flag1);

//向栈中存入数据

for(int i=0;i<10;i++) {

stack.push(i+1);

}

//查看栈中的所有对象

Iterator iterator = stack.iterator();

System.out.print("栈中所有对象：");

while (iterator.hasNext()) {

System.out.print(iterator.next()+" ");

}

System.out.println();

int index = stack.search(2);

System.out.println("返回对象2在栈中的位置："+index);

int bottom = stack.firstElement();

System.out.println("查看栈底部的对象："+bottom);

int peek1 = stack.peek();

System.out.println("查看栈顶部的对象(不从栈中移除)："+peek1);

int pop1 = stack.pop();

System.out.println("移除栈顶部的对象，并返回该对象："+pop1);

int peek2 = stack.peek();

System.out.println("重新查看栈顶部的对象(不从栈中移除)："+peek2);

boolean flag2 = stack.isEmpty();

System.out.println("添加数据后，对栈是否为空进行判断："+flag2);

}

}

实现效果

堆栈的实际应用

看概念不知道堆栈有什么用，做个题目就可以很直观的看出堆栈的作用了。

对表达式的计算是堆栈的经典应用

题目要求:

package _3_5_test;

import java.util.Scanner;

import java.util.Stack;

/*表达式计算

* 先分割表达式，根据运算符号进行分割

* 有乘除的先进行运算

* 有括号的先进行运算

* */

public class SeventyThree {

public static void main(String[] args) {

// TODO Auto-generated method stub

Scanner scanner = new Scanner(System.in);

String s = scanner.nextLine();

Stack nums = new Stack(); // 保存数字

Stack opes = new Stack(); // 保存操作符

// 将字符串转换成字符数组，便于后面进行遍历操作

char cs[] = s.toCharArray();

// 用于存放数字

int n = 0;

// 遍历一遍字符串中所有的字符：分为以下几种情况进行处理

for (int i = 0; i < cs.length; i++) {

char temp = cs[i];

if (Character.isDigit(temp)) {// 如果当前的字符是数字，存入n中，要考虑大于10的数字的进位情况

n = n * 10 + Integer.parseInt(String.valueOf(temp));

} else {// 如果当前的字符不是数字，进行字符判断，区分是四则运算符号还是括号

if (n != 0) {// 如果n不等于0，说明已经取了运算符号左边的值，将这个值放进栈中

nums.push(n);

n = 0;

}

if (temp == '(') {// 如果当前字符是左括号，将字符存入栈中，再取下一个字符

opes.push(temp);

} else if (temp == ')') {// 计算括号中的内容

while (opes.peek() != '(') {

// 从数字栈和操作符栈取出顶部的值，进行运算，并将最终结果存进数字栈中

int t = cal(nums.pop(), nums.pop(), opes.pop());

nums.push(t);

}

opes.pop();//括号内运算完毕，取出左括号

} else if (pre(temp) > 0) {// 如果当前符号是四则运算符

if (opes.isEmpty()) {// 如果当前的符号栈中没有运算符号，则将当前的预算符号直接加进栈中

opes.push(temp);

} else {// 如果栈中已经存在的运算符号，则要进行优先级的判断

if (pre(opes.peek()) >= pre(temp)) {

int t = cal(nums.pop(), nums.pop(), opes.pop());

nums.push(t);

}

opes.push(temp);

}

}

}

}

if (n != 0) {

nums.push(n);

}

while (!opes.isEmpty()) {

int t = cal(nums.pop(), nums.pop(), opes.pop());

nums.push(t);

}

System.out.println(nums.pop());

}

// 自定义一个符号优先级判断方法

public static int pre(Character c) {

if (c == '+' || c == '-') {

return 1;

} else if (c == '*' || c == '/') {

return 2;

} else {

return 0;

}

}

// 自定义一个四则运算方法，因为栈先进后出的特性，所以b是在前面的数值，a是在后面的数值

public static int cal(int a, int b, Character sign) {

switch (sign) {

case '+':

return b + a;

case '-':

return b - a;

case '*':

return b * a;

case '/':

return b / a;

}

return 0;

}

}