"Java result" 是什么意思？

Question

"Java result" 是什么意思？

java

4

在执行我的Java程序后，我看到了以下输出：

Java结果：2147483647

这个数字代表什么意思呢？这段代码实际上应该在ACM问题的解决方案上运行随机测试用例！没有正常停止的方法！当我手动停止它时，我看到了以下输出：

Java结果：2147483647
构建成功（总时间：8分钟49秒）

我只是想知道这个数字代表什么意思？

package acm;
import java.util.Random;
import java.util.Scanner;
import java.util.Vector;
public class mamoth {
static Scanner input = new Scanner(System.in);
public static String planets;
public static int H;
public static int A;
public static Random random = new Random();

public static void main(String []args)
{
    while(!(planets = /*input.nextLine()*/Integer.toString(random.nextInt(10)+1) + " " + Integer.toString(random.nextInt(10)+1)).equals("0 0")){
        System.out.println(planets);
    //while(!(planets = input.nextLine()).equals("0 0")){
        int index;
        index = planets.indexOf(' ');
        H = Integer.valueOf(planets.substring(0, index));
        A = Integer.valueOf(planets.substring(index+1));
        Vector<Integer> humanPlanets = new Vector<Integer>();

        String temp = "1 0";
        for(int i=0;i<H-1;i++){
            temp += " 1 0";
        }

        planets = /*input.nextLine()*/temp;
        System.out.println(planets);
        //planets = input.nextLine();
       int index1 = 0;
       int index2;
       while((index2 = planets.indexOf(' ',index1))!=-1){
           humanPlanets.addElement(Integer.valueOf(planets.substring(index1, index2)));
           index1= index2+1;
       }
       humanPlanets.addElement(Integer.valueOf(planets.substring(index1)));

       Vector<Integer> aliasPlanets = new Vector<Integer>();

       temp = "0 0";
        for(int i=0;i<A-1;i++){
            temp += " 0 0";
        }

       planets = /*input.nextLine()*/temp;
        System.out.println(planets);
       //planets = input.nextLine();
       index1 = 0;
       while((index2 = planets.indexOf(' ',index1))!=-1){
           aliasPlanets.addElement(Integer.valueOf(planets.substring(index1, index2)));
           index1= index2+1;
       }
       aliasPlanets.addElement(Integer.valueOf(planets.substring(index1)));

       int[][] distance = new int[H][A];
       for(int i=0;i<H;i++){

           temp = Integer.toString(random.nextInt(100)+1);
        for(int b=0;b<A-1;b++){
            temp += " " + Integer.toString(random.nextInt(100)+1);
        }

           planets = /*input.nextLine()*//*Integer.toString(random.nextInt(100)+1) + " " + Integer.toString(random.nextInt(100)+1) + " " + Integer.toString(random.nextInt(100)+1)*/temp;

           //planets = input.nextLine();
           index1 = 0;
           int j =0;
           while((index2 = planets.indexOf(' ',index1))!=-1){
               distance[i][j] = Integer.valueOf(planets.substring(index1, index2));
               index1= index2+1;
               j++;
           }
           distance[i][j] = Integer.valueOf(planets.substring(index1));

       }
        if(H>=A){

       int[][] minimumYearsToDefeat = new int[H][A];
       for(int i=0;i<H;i++){
           for(int j=0;j<A;j++){
               double x,y,z;
               y = aliasPlanets.elementAt(j*2) + humanPlanets.elementAt(i*2+1)*distance[i][j]-humanPlanets.elementAt(i*2);
               z = humanPlanets.elementAt(i*2+1) - aliasPlanets.elementAt(j*2+1);
               if(z==0){
                   if(y<=0)
                       x = distance[i][j];
                   else
                       x = Integer.MAX_VALUE;
               }
               else{
               x = y/z;
               }
               if(x==0){
                   x=1;
               }
               else if(x<0){
                   x= Integer.MAX_VALUE;
               }
               minimumYearsToDefeat[i][j] = (int)Math.ceil(x);
           }
       }

       for(int i=0;i<H;i++){
           for(int j=0;j<A;j++)
               System.out.print(minimumYearsToDefeat[i][j]+" ");
           System.out.println();
       }

       int[] mins = new int[A];//meqdar dehi ba big integer
       for(int i=0;i<A;i++){
           mins[i] = Integer.MAX_VALUE;
       }
       int[] minsWith = new int[A];//meqdar dehi ba -1
       for(int i=0;i<A;i++){
           minsWith[i] = -1;
       }

       for(int i=0;i<A;i++){
           for(int j=0;j<H;j++){
               if(minimumYearsToDefeat[j][i]<mins[i]){
                   mins[i] = minimumYearsToDefeat[j][i];
                   minsWith[i] = j;
               }
           }


           for(int p=0;p<A;p++){
               if(minsWith[i]==minsWith[p]&&p!=i&&mins[i]!=Integer.MAX_VALUE){
                   correctingConflict(minimumYearsToDefeat, mins, minsWith, i, p, new Vector<Integer>());
               }
           }


       }
       int result = 0;
       for(int i=0;i<A;i++){
           if (mins[i]>result)
               result = mins[i];

       }
       if(result==Integer.MAX_VALUE){
           System.out.println("IMPOSSIBLE");
       }
       else{
           System.out.println(result);
       }
    }
        else{
            System.out.println("IMPOSSIBLE");
        }
    }
}

public static void correctingConflict(int[][] W, int[] mins, int[] minsWith, int i, int p, Vector<Integer> vector){
    /*for(int v=0;v<A;v++){
    System.out.print(minsWith[v]+" ");
    }
    System.out.println();
    for(int v=0;v<vector.size();v++){
    System.out.print(vector.elementAt(v)+" ");
    }
    System.out.println();*/
    int nextMin1 = Integer.MAX_VALUE;
    int nextMin2 = Integer.MAX_VALUE;
    int nextMinWith1 = minsWith[i];
    int nextMinWith2 = minsWith[p];

    for(int q=0;q<H;q++){
        if(W[q][i]<nextMin1 && W[q][i]>=mins[i] && q!=minsWith[i] && !vector.contains(q)){
            nextMin1 = W[q][i];
            nextMinWith1 = q;
        }

    }
    for(int q=0;q<H;q++){
        if(W[q][p]<nextMin2 && W[q][p]>=mins[p] && q!=minsWith[p] && !vector.contains(q)){
            nextMin2 = W[q][p];
            nextMinWith2 = q;
        }
    }

    if(nextMin1<=nextMin2){
        if (nextMin1==mins[i]) {
            vector.addElement(minsWith[p]);
        } else {
            vector.removeAllElements();
        }
        mins[i] = nextMin1;
        minsWith[i] = nextMinWith1;

        //conflict checking
        for(int s=0;s<A;s++){
               if(minsWith[i]==minsWith[s]&&s!=i&&mins[i]!=Integer.MAX_VALUE){
                   correctingConflict(W, mins, minsWith, i, s, vector);
                   return;
               }
        }

    }
    else if(nextMin2<nextMin1){
        if (nextMin2==mins[p]) {
            vector.removeAllElements();
            vector.addElement(minsWith[p]);
        } else {
            vector.removeAllElements();
        }
        mins[p] = nextMin2;
        minsWith[p] = nextMinWith2;

        //conflict checking
        for(int s=0;s<A;s++){
               if(minsWith[p]==minsWith[s]&&s!=p&&mins[p]!=Integer.MAX_VALUE){
                   correctingConflict(W, mins, minsWith, p, s, vector);
                   return;
               }
        }
    }




}

}

- Kamran

6个回答

2

你在代码中的五个不同位置都赋值了Integer.MAX_VALUE，其中一个位置是mins数组中的元素。

你的main()方法末尾的这段代码可以打印出mins数组中的值：

   int result = 0;
   for(int i=0;i<A;i++){
       if (mins[i]>result)
           result = mins[i];

   }
   if(result==Integer.MAX_VALUE){
       System.out.println("IMPOSSIBLE");
   }
   else{
       System.out.println(result);
   }
}
    else{
        System.out.println("IMPOSSIBLE");
   }

这是一个小测试程序，用于查找 Integer.MAX_VALUE 实际的值：

$ cat test.java ; javac test.java ; java sars
class sars {
    public static void main(String args[]) {
            System.out.println("Integer.MAX_VALUE: " + Integer.MAX_VALUE);
    }
}
Integer.MAX_VALUE: 2147483647

我之前的评论有误，关于-1泄漏的问题 -- 你已经把有趣的值五次嵌入到你的代码中。 :) 我不知道哪一个正在泄漏，或者你的算法是否确实像它应该做的那样工作。祝你好运寻找:)但是至少有了你的完整代码，有人可能会帮你找到我们都错过的东西。

- sarnold

我确信这个程序并没有明确地打印MAX_VALUE，因为它知道无论是什么代码在打印它，都不是我的！它的颜色是红色，意味着它不是用户编写的！ - Kamran

你可以使用其他整数作为哨兵值吗？尝试使用16000代替Integer.MAX_VALUE，看看你的红色数字是否仍然是2147483647还是变成了16000？ - sarnold

是的！我尝试过了，数字仍然是2147483647。还有一件事要提到的是，当我想尝试你说的时候，我启动和停止程序多次以获取输出！我不知道它何时会出现？！ - Kamran

1

这是由于日期和时间引起的。这意味着您有一些文件在当前日期和时间之后进行了编辑。将您的日期和时间设置为有效日期，然后运行程序。

- Mohammad Esfandiari

1

这是(JVM)进程的退出代码。具体而言，当你杀死进程时，会得到这个代码。未知Java结果消息

- Carlos Felipe Silva Espinoza

1

如果您有一个默认的NetBeans项目，并且在NetBeans中启动它，那么它是由Ant启动的，使用生成的构建脚本，该脚本位于项目目录中。为了缩小问题范围，请尝试从命令行自己启动程序：

java acm.mamoth

- Mike Baranczak

0

让Java代码显式地以System.exit(0)结束。

- Thorbjørn Ravn Andersen

其实对我来说如何退出并不是问题，我只是想知道这个数字代表什么意思。 - Kamran

2

Thorbjørn的回答表明，如果没有明确的退出值，可能会使用该数字代替。这绝对值得尝试：很容易发现这是它，还是排除它。 - sarnold

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- Jon Skeet · Accepted Answer

4

嗯，您没有展示您如何执行程序或者程序的功能。我猜测这可能是进程的退出码，尽管通常如果没有错误的话，退出码为0。

如果您想要更好的答案，请在问题中提供更多信息。

- Jon Skeet

我正在NetBeans中执行它。该程序是一个简单的程序，实现了ACM问题的算法，它具有输入和输出，还具有递归函数。我忘记说的是，当代码正常结束时，代码为0，但是当我手动使用停止按钮强制停止它时，我会看到这样的输出：Java Result: 2147483647 BUILD SUCCESSFUL（总时间：8分钟49秒）我在想的是，这个数字和内存之间是否有任何关系？ - Kamran

3

2的31次方等于2147483648。我猜可能有一个-1被损坏了。 - sarnold

啊！所以结果要么是0，要么是-1？:-? - Kamran

@sarnold：发现得好。但我仍然不确定是什么导致了非0的退出代码。@Kamran：你确定这不是你的程序实际上正在打印的内容吗？ - Jon Skeet

是的Jon，文本的颜色是红色！这意味着它不是用户打印的！ - Kamran