什么是；“java结果”；方法

在执行用java编写的程序后，我看到以下输出：

java结果：2147483647

这个数字到底是什么意思？这是代码。Tt实际上应该在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;
               }
        }
    }




}

}

封装acm；
导入java.util.Random；
导入java.util.Scanner；
导入java.util.Vector；
公共类mamoth{
静态扫描仪输入=新扫描仪（System.in）；
公共静态字符串；
公共静态inth；
公共静态INTA；
公共静态随机=新随机（）；
公共静态void main（字符串[]args）
{
而（！（planets=/*input.nextLine（）*/Integer.toString（random.nextInt（10）+1）+“+Integer.toString（random.nextInt（10）+1））.equals（“0”））{
系统输出打印LN（行星）；
//而（！（planers=input.nextLine（））.equals（“0”））{
整数指数；
指数=行星。指数（“”）；
H=整数.valueOf（行星.子串（0，索引））；
A=整数.valueOf（行星.子字符串（索引+1））；
向量=新向量（）；
字符串temp=“1 0”；
对于（int i=0；i那么，您还没有展示如何执行您的程序或程序的功能。我猜它可能是进程的退出代码，尽管通常如果没有任何错误，退出代码是0

如果您想得到更好的答案，请在问题中提供更多信息。
让Java代码以系统显式结束。退出（0）
您可以在代码中的五个不同位置分配
Integer.MAX_值；其中一个位置是
mins
数组中的元素

main（）
方法末尾的这段代码可以从
mins
数组中打印出值：

我之前关于a-1某处泄漏的评论是错误的——您已经在代码中嵌入了五次有趣的值我不知道是哪一个泄露出去了，或者你的算法是否真的像它应该的那样工作。祝你好运：）但至少在你的完整代码发布后，有人可能会帮助你找到我们都缺少的东西。
如果你有一个默认的NetBeans项目，并且你从NetBeans启动它，那么它将由Ant使用生成的生成脚本位于项目目录中。若要缩小问题范围，请尝试从命令行自己启动程序：

java acm.mamoth

这是因为日期和时间。
这意味着您有一些文件在当前日期和时间之后的某个日期或时间进行了编辑。请将日期和时间设置为有效日期，然后运行程序。
这是（JVM）进程的退出代码。特别是，当您杀死它时，将得到该代码。
I
m在NetBeans中执行它。该程序是一个简单的程序，它实现了一个acm问题的算法，它有输入和输出，还有一个递归函数。我忘记说的是，当它正常结束时，代码是0，但当我手动使用停止按钮强制它停止时，我看到这样的输出：Java结果：2147483647生成成功（总时间：8分49秒）我想的是，这个数字和内存之间是否有任何关系？2^31==2147483648。我猜a-1被破坏了。啊！所以结果可能是0或-1？：-？@sarnold:很好。我仍然不确定是什么给了它一个非0退出代码。@Kamran:你确定这不是你的程序真正想要的吗正在打印吗？是的，Jon，文本的颜色是红色！这意味着它不是用户打印的！事实上，如何退出对我来说不是问题。我只是想知道数字的含义是什么。Horbjørn的回答是，如果没有明确的退出值，可能会使用这个数字。这绝对值得一试：无论是迪斯科还是迪斯科，它都是快速且容易的我确信程序没有显式打印最大值，因为它确信打印它的代码不是我的！它的颜色是红色表示它不是用户编码的！你能用其他整数作为你的哨兵值吗？用16000而不是
整数。最大值
，看看你的红色数字是否仍然是2147483647或者如果它是16000？是的！我试过了，但数字仍然是2147483647。另一件要提及的是，当我想尝试你所说的时，我启动和停止程序几次以获得输出！我不知道它想什么时候出现？！
$ 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

java acm.mamoth