Java 使用堆栈计算分子质量

我的任务是使用一堆整数来计算给定分子的分子质量。我应该自己使用数组实现IntStack类。然后我应该创建一个类，以字符串作为输入并计算分子。输入中唯一的字符是开括号和闭括号、数字2-9以及H（氢）、C（碳）和O（氧）。我得到了三种元素的分子质量，分别为1，12和16

public class IntStack
{
private int[] stack;
public int index;

public IntStack()
{
    stack = new int[100];
    index = -1;
}

public void push(int x)
{
    stack[index + 1] = x;
    index++;
}

public int pop()
{
    if (index == -1)
    {
        return -1;
    }
    int num = stack[index];
    index--;
    return num;
}

public int peek()
{
    if (index == -1)
    {
        return 0;
    }
    return stack[index];
}
}


import java.util.Scanner;

public class MolecularMass
{
 private static IntStack stack;

public static void main(String[] args)
{
stack = new IntStack();
Scanner kb = new Scanner(System.in);
System.out.print("Enter the molecule: ");
String input = kb.nextLine();
int result = evaluate(input);
System.out.println("The Molecular Mass of " + input +  " is " + result);
}

public static int evaluate(String s)
{
int answer = 0;
int num = 0;

for(int i = 0; i < s.length(); i++)
{
  char c = s.charAt(i);
  switch(c)
  {
    case '2':
      num = stack.pop();
      num *= 2;
      stack.push(num);
      break;
    case '3':
      num = stack.pop();
      num *= 3;
      stack.push(num);
      break;
    case '4':
      num = stack.pop();
      num *= 4;
      stack.push(num);
      break;
    case '5':
      num = stack.pop();
      num *= 5;
      stack.push(num);
      break;
    case '6':
      num = stack.pop();
      num *= 6;
      stack.push(num);
      break;
    case '7':
      num = stack.pop();
      num *= 7;
      stack.push(num);
      break;
    case '8':
      num = stack.pop();
      num *= 8;
      stack.push(num);
      break;
    case '9':
      num = stack.pop();
      num *= 9;
      stack.push(num);
      break;
    case 'C':
      stack.push(12);
      break;
    case 'H':
      stack.push(1);
      break;
    case 'O':
      stack.push(16);
      break;
    case '(':
      stack.push(0);
      break;
    case ')':
      int result = 0;
      while(stack.peek() != 0)
      {
        result += stack.pop();
      }
      int throwaway = stack.pop();
      stack.push(result);
      break;
    default:
      break;
  }
}

for(int i = 0; i < stack.index; i++)
{
  answer += stack.pop();
}

return answer;
}
}

公共类IntStack
{
私有int[]堆栈；
公共整数指数；
公共IntStack（）
{
堆栈=新整数[100]；
指数=-1；
}
公共无效推送（int x）
{
堆栈[索引+1]=x；
索引++；
}
公共int-pop（）
{
如果（索引==-1）
{
返回-1；
}
int num=堆栈[索引]；
索引--；
返回num；
}
公共int peek（）
{
如果（索引==-1）
{
返回0；
}
返回堆栈[索引]；
}
}
导入java.util.Scanner；
公共级分子量
{
私有静态IntStack；
公共静态void main（字符串[]args）
{
stack=新的IntStack（）；
扫描仪kb=新扫描仪（System.in）；
系统输出打印（“输入分子：”；
字符串输入=kb.nextLine（）；
int结果=评估（输入）；
System.out.println（“输入+的分子量为结果+的分子量）；
}
公共静态整型求值（字符串s）
{
int-answer=0；
int num=0；
对于（int i=0；i

它应该按如下方式运行：

输入分子：（（CH）2（OH2H）（C（H））O）3

（（CH）2（OH2H）（C（H））O）3的分子量为222

我一直得到分子质量为0或1

编辑：以下是我的评估方法算法： 如果字符是化学元素，程序会推动元素的分子量。 如果字符是开括号，则程序将0推送到堆栈上。 如果字符是一个右括号，则程序将括号内的所有内容相加，直到到达开括号（存储为0） 如果字符是一个数字，它会在堆栈上弹出该数字，将其乘以输入数字，然后将其推回堆栈

---

最后，它将堆栈中的所有内容相加并返回结果。

假设您正在学习编码，我建议您自己遵循查找错误的过程。以下是我建议您的做法：

编写一组单元测试，以确保您的

IntStack

完全符合您的预期

将

evaluate

逻辑移动到单独的类中（该类使用

IntStack

作为隐藏的实现细节）

提供几种方法来执行

评估的各个部分，例如
元素（字符）
，
计数（字符）
，
开始组（）
，
结束组（）

在创建这些方法时，请创建单元测试，以确保它们完全符合您的预期
一旦它们都工作正常，就编写代码来读取输入并调用所编写的各种方法
这比我们指出错误的时间要长，但我保证您会学到更多。
假设您正在学习编码，我建议您自己遵循查找错误的过程。以下是我建议您的做法：

编写一组单元测试，以确保您的
IntStack
完全符合您的预期
将
evaluate
逻辑移动到单独的类中（该类使用
IntStack
作为隐藏的实现细节）
提供几种方法来执行
评估的各个部分，例如
元素（字符）
，
计数（字符）
，
开始组（）
，
结束组（）

在创建这些方法时，请创建单元测试，以确保它们完全符合您的预期
一旦它们都工作正常，就编写代码来读取输入并调用所编写的各种方法
这比我们指出错误的时间要长，但我保证你会学到更多。
或者你能做的就是使用字符串堆栈

遍历给定字符串的长度。如果第i个索引处的字符为“（”，则将其推送到堆栈


然后，当我们看到一个“'）”时，我们定义了一个变量来存储左括号和右括号之间的元素之和


我们通过弹出堆栈直到找到“（”，然后将所有弹出的元素添加到变量中，最后将该变量推送到堆栈中


如果你找到一个“H”，按1键，如果你得到一个氧原子，按16键，如果你得到一个汽车，按12键