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<Integer> 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<Integer> nums = new Stack<Integer>(); // 保存数字
		Stack<Character> opes = new Stack<Character>(); // 保存操作符

		// 将字符串转换成字符数组，便于后面进行遍历操作
		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;
	}

}