返回的值错误，但在系统中读取结果良好？JAVA

我正在尝试读取此输入：

processcount 2     # Read 2 processes
runfor 15          # Run for 15 time units
use rr             # Can be fcfs, sjf, or rr
quantum 2          # Time quantum – only if using rr
process name P1 arrival 3 burst 5
process name P2 arrival 0 burst 9
end

我的工作是只解析值而不是单词，并保留注释（#）

以下是主文件：

public class main {

static String[] token = new String[10];
static List<Schedule> p;

public static void schedule()
{
    for(Schedule c: p)
    {
         System.out.println("ProcessInfo: " + c.getProcess().processName);
            System.out.println("count: " + c.getProcessCount());
             System.out.println("quant: " + c.getQuantum());
              System.out.println("runtime: " + c.getRunTime());
               System.out.println("Type: " + c.getType());
    }
  }


public static void main(String[] args) throws Exception {
   Scanner sc = new Scanner(System.in);
      // sc = new Scanner(new File("processes.in"));
    p = new ArrayList<>();

    while(sc.hasNextLine() && !sc.equals("end"))
    {

        token = sc.nextLine().replace(" ","-").replace("#", "-").split("-");

        System.out.println(token[0].toString());


        if(!token[0].startsWith("#") || !sc.nextLine().startsWith("end"))
        {
            Schedule s = new Schedule();
            int pCount=0, runfor=0, quantum=0, arrival=0, burst=0;
            String type = null, pName = null;

            if(token[0].startsWith("processcount"))
            {
                 s.setProcessCount(Integer.parseInt(token[1]));
                System.out.println(Integer.parseInt(token[1] +""));
            }


            else if(token[0].startsWith("runfor"))
            {
                  s.setRunTime(Integer.valueOf(token[1].toString()));
                 System.out.println(Integer.parseInt(token[1]) +"");
            }

            else if(token[0].startsWith("use"))
            {
                s.setType(token[1].toString());
                System.out.println(token[1] +"");
            }

            else if(token[0].startsWith("quantum"))
            {
                s.setQuantum(Integer.valueOf(token[1].toString()));
                System.out.println(token[1] + "");
            }

            else if(token[0].startsWith("process"))
            {
                Processes pl = new Processes();
                pl.setProcessName(token[2]);
                System.out.println(token[2]+ "");

                pl.setArrivalTime(Integer.valueOf(token[4].toString()));
                System.out.println(""+ Integer.valueOf(token[4]));

                pl.setBurstTime(Integer.valueOf(token[6].toString()));
                System.out.println("" + token[6]);

                s.setProcess(pl);
                // add info
                p.add(s);

            }

            else if(token[0].startsWith("end"))
            {
                schedule();
            }

        }

    }

}

}

过程如下：

public class Processes {

String processName;
int arrivalTime;
int burstTime;

public String getProcessName() {
    return processName;
}

public void setProcessName(String processName) {
    this.processName = processName;
}
public int getArrivalTime() {
    return arrivalTime;
}

public void setArrivalTime(int arrivalTime) {
   this.arrivalTime = arrivalTime;
}

public int getBurstTime() {
    return burstTime;
}

public void setBurstTime(int burstTime) {
    this.burstTime = burstTime;
}
}

以下是我的代码得到的输出：

ProcessInfo: P1
count: 0
quant: 0
runtime: 0
Type: null
ProcessInfo: P2
count: 0
quant: 0
runtime: 0
Type: null

---

为什么返回了错误的结果？

由于拆分字符串的方式，您遇到了问题。现在的方式首先用破折号替换每个空格。例如，字符串

"processcount 2   # a comment" 

将成为

"processcount-2---#-a-comment"

然后将其拆分，在每对破折号之间提供一个空字符串，这样您将得到

token = ["processcount", "2", "","", ... etc]

我建议你这样做：

String str = (sc.nextLine().split("#"))[0]; //get the string before the pound sign 
str = str.trim(); //remove the leading/trailing whitespace
token = str.split("\\s+"); //split the string by the whitespaces

---

您遇到问题是因为您拆分字符串的方式。现在的方式首先用破折号替换每个空格。例如，字符串

"processcount 2   # a comment" 

将成为

"processcount-2---#-a-comment"

然后将其拆分，在每对破折号之间提供一个空字符串，这样您将得到

token = ["processcount", "2", "","", ... etc]

我建议你这样做：

String str = (sc.nextLine().split("#"))[0]; //get the string before the pound sign 
str = str.trim(); //remove the leading/trailing whitespace
token = str.split("\\s+"); //split the string by the whitespaces

---

这里有两个问题。在while循环的每个迭代中创建一个新的计划；在新的迭代之前，您没有获得当前行的所有相关值，而且在创建一个覆盖以前收集的值的新Schedule（）之后，您有两个无用的变量。 此外，在数组的字符串元素上使用toString，这是没有意义的。我不会尝试不使用过滤器，你也不需要任何过滤器。总是尝试（保持简单愚蠢）

下面是我将如何在不使用过滤器的情况下进行操作

public static void main (String args [])
{
     // Will help us identify the key words
     String current_token;

     Scanner sc = new Scanner(System.in);

     String input = sc.nextLine();
     //Remove spaces at the beginning and end of the string
     input = input.trim();

     Schedule s = new Schedule();

     // New source for the scanner
     sc =new Scanner(input);

     p = new ArrayList<>();

     while(sc.hasNext())
     {
          current_token = sc.next();

          if(current_token.equals("end"))
            {schedule(); break;}

          switch(current_token)
          {
                case "processcount":
                    s.setProcessCount(sc.nextInt());
                    System.out.println(s.getProcessCount()+ " ");
                    break;

                case "runfor":
                    s.setRunTime(sc.nextInt());
                    System.out.println(s.getRuntime +" ");

                case "use":
                    s.setType(sc.next());
                    System.out.println(s.getType() +" ");
                    break;

                case "quantum":
                    s.setQuantum(sc.nextInt());
                    System.out.println(s.getQuantum + " ");
                    break;

                case "process":
                    Processes pl = new Processes();

                    pl.setProcessName(sc.next());
                    System.out.println(pl.GetProcessName()+ " ");

                    pl.setArrivalTime(sc.nextInt());
                    System.out.println(" "+ pl.getArrivalTime());

                    pl.setBurstTime(sc.nextInt());
                    System.out.println(" " + pl.getBurstTime());

                    s.setProcess(pl);
                    // add info
                    p.add(s);

                    break;

                default:
                    // the current_token is not what we are looking for
                    break;
           }
      }
}

publicstaticvoidmain（字符串参数[]）
{
//将帮助我们识别关键词
字符串当前_令牌；
扫描仪sc=新的扫描仪（System.in）；
字符串输入=sc.nextLine（）；
//删除字符串开头和结尾的空格
input=input.trim（）；
附表s=新附表（）；
//扫描仪的新来源
sc=新扫描仪（输入）；
p=新的ArrayList（）；
while（sc.hasNext（））
{
当前_令牌=sc.next（）；
if（当前符号等于（“结束”））
{schedule（）；break；}
交换机（当前令牌）
{
案例“processcount”：
s、 setProcessCount（sc.nextInt（））；
System.out.println（s.getProcessCount（）+“”）；
打破
案例“runfor”：
s、 setRunTime（sc.nextInt（））；
System.out.println（s.getRuntime+“”）；
案例“使用”：
s、 setType（sc.next（））；
System.out.println（s.getType（）+）；
打破
案例“quantum”：
s、 setQuantum（sc.nextInt（））；
System.out.println（s.getQuantum+“”）；
打破
案例“过程”：
流程pl=新流程（）；
pl.setProcessName（sc.next（））；
System.out.println（pl.GetProcessName（）+）；
pl.setArrivalTime（sc.nextInt（））；
System.out.println（“+pl.getArrivalTime（））；
pl.setBurstTime（sc.nextInt（））；
System.out.println（“+pl.getBurstTime（））；
s、 setProcess（pl）；
//添加信息
p、 添加（s）；
打破
违约：
//当前的_令牌不是我们正在寻找的
打破
}
}
}

这里有几个问题。在while循环的每个迭代中创建一个新的计划；在新的迭代之前，您没有获得当前行的所有相关值，而且在创建一个覆盖以前收集的值的新Schedule（）之后，您有两个无用的变量。 此外，在数组的字符串元素上使用toString，这是没有意义的。我不会尝试不使用过滤器，你也不需要任何过滤器。总是尝试（保持简单愚蠢）

下面是我将如何在不使用过滤器的情况下进行操作

public static void main (String args [])
{
     // Will help us identify the key words
     String current_token;

     Scanner sc = new Scanner(System.in);

     String input = sc.nextLine();
     //Remove spaces at the beginning and end of the string
     input = input.trim();

     Schedule s = new Schedule();

     // New source for the scanner
     sc =new Scanner(input);

     p = new ArrayList<>();

     while(sc.hasNext())
     {
          current_token = sc.next();

          if(current_token.equals("end"))
            {schedule(); break;}

          switch(current_token)
          {
                case "processcount":
                    s.setProcessCount(sc.nextInt());
                    System.out.println(s.getProcessCount()+ " ");
                    break;

                case "runfor":
                    s.setRunTime(sc.nextInt());
                    System.out.println(s.getRuntime +" ");

                case "use":
                    s.setType(sc.next());
                    System.out.println(s.getType() +" ");
                    break;

                case "quantum":
                    s.setQuantum(sc.nextInt());
                    System.out.println(s.getQuantum + " ");
                    break;

                case "process":
                    Processes pl = new Processes();

                    pl.setProcessName(sc.next());
                    System.out.println(pl.GetProcessName()+ " ");

                    pl.setArrivalTime(sc.nextInt());
                    System.out.println(" "+ pl.getArrivalTime());

                    pl.setBurstTime(sc.nextInt());
                    System.out.println(" " + pl.getBurstTime());

                    s.setProcess(pl);
                    // add info
                    p.add(s);

                    break;

                default:
                    // the current_token is not what we are looking for
                    break;
           }
      }
}

publicstaticvoidmain（字符串参数[]）
{
//将帮助我们识别关键词
字符串当前_令牌；
扫描仪sc=新的扫描仪（System.in）；
字符串输入=sc.nextLine（）；
//删除字符串开头和结尾的空格
input=input.trim（）；
附表s=新附表（）；
//扫描仪的新来源
sc=新扫描仪（输入）；
p=新的ArrayList（）；
while（sc.hasNext（））
{
当前_令牌=sc.next（）；
if（当前符号等于（“结束”））
{schedule（）；break；}
交换机（当前令牌）
{
案例“processcount”：
s、 setProcessCount（sc.nextInt（））；
System.out.println（s.getProcessCount（）+“”）；
打破
案例“runfor”：
s、 setRunTime（sc.nextInt（））；
System.out.println（s.getRuntime+“”）；
案例“使用”：
s、 setType（sc.next（））；
System.out.println（s.getType（）+）；
打破
案例“quantum”：
s、 setQuantum（sc.nextInt（））；
System.out.println（s.getQuantum+“”）；
打破
案例“过程”：
流程pl=新流程（）；
pl.setProcessName（sc.next（））；
System.out.println（pl.GetProcessName（）+）；
pl.setArrivalTime（sc.nextInt（））；
System.out.println（“+pl.getArrivalTime（））；
pl.setBurstTime（sc.nextInt（））；
System.out.println（“+pl.getBurstTime（））；
s、 setProcess（pl）；
//添加信息
p、 添加（s）；
打破
违约：
//当前的_令牌不是我们想要的