Java 为什么可以'；打印最大长值吗？

我正在编译一个Java程序，使用for循环找出long的最大值。但是，当我运行程序时，没有打印任何内容。为什么?

这是我的密码：

class LongMaxMin {
public static void main(String args[]) {

    long i = 0L;
    long result = 0L;

    for (; ; ) {
        result = i++;
        if (i<0) 
            break;
    }
    System.out.println("The biggest integer:" + result);
  }

类LongMaxMin{
公共静态void main（字符串参数[]）{
长i=0L；
长结果=0L；
对于（；；）{
结果=i++；
if（i主要是因为时间

一个
long
将有大约9.22亿次循环。你从零开始递增。这意味着在循环结束和中断之前，你需要经历9亿次循环。我刚刚尝试在javascript控制台中运行20亿次操作，并在强制退出前超时几分钟

如果你坐在那里，让它运行足够长的时间，你就会得到你的输出。或者，从接近最大值的地方开始，比如9223372036854700000，看看它是否仍然会给你同样的问题。在Java 8中，是允许的。初始化
i
到类似于
9_223; u 372_036_854_700_l的东西将给你以更及时的方式做某事

最大长度明显很高，为9.223372e+18
，
9223372036854775807
是一个有争议的数字。这也促成了整个“这很有效，只会花很长时间”理论的形成。
主要是因为时间

一个
long
将有大约9.22亿次循环。你从零开始递增。这意味着在循环结束和中断之前，你需要经历9亿次循环。我刚刚尝试在javascript控制台中运行20亿次操作，并在强制退出前超时几分钟

如果你坐在那里，让它运行足够长的时间，你就会得到你的输出。或者，从接近最大值的地方开始，比如9223372036854700000，看看它是否仍然会给你同样的问题。在Java 8中，是允许的。初始化
i
到类似于
9_223; u 372_036_854_700_l的东西将给你以更及时的方式做某事

最大长度明显很高，在
9.223372e+18
，
9223372036854775807
是一个有问题的数字。这也有助于整个“这很有效，只会花很长时间”理论的形成。
我认为你的逻辑是正确的，只是需要很多时间才能达到这个值

可容纳的最大长值为Long.MAX_值，即9223372036854775807L

为了加速逻辑，我修改了程序如下，得到了预期的结果

public static void main(String args[]) {
        long i = 9223372036854775806L;
        long result = 0L;

        for (; ; ) {
            result = i++;
            if (i<0) {
              System.out.println("result"+result);
             System.out.println("i"+i);

             break;
            }
        }
        System.out.println("The biggest integer: is" + result);

}

publicstaticvoidmain（字符串参数[]）{
长i=9223372036854775806L；
长结果=0L；
对于（；；）{
结果=i++；
如果（i我认为你的逻辑是正确的，那么要达到这个值需要很多时间

可容纳的最大长值为Long.MAX_值，即9223372036854775807L

为了加速逻辑，我修改了程序如下，得到了预期的结果

public static void main(String args[]) {
        long i = 9223372036854775806L;
        long result = 0L;

        for (; ; ) {
            result = i++;
            if (i<0) {
              System.out.println("result"+result);
             System.out.println("i"+i);

             break;
            }
        }
        System.out.println("The biggest integer: is" + result);

}

publicstaticvoidmain（字符串参数[]）{
长i=9223372036854775806L；
长结果=0L；
对于（；；）{
结果=i++；
如果（i我想知道需要多长时间，所以我写了一个类来做同样的事情。用一个单独的线程来写它，每1秒更新一次控制台的结果

“int”结果

“长期”结果

1362032,97-第二和第三个值之间的差值（1秒）

6771768529秒-达到long的最大值（long.max_值/2nd3rdDifference）需要多少秒

6771768529秒=214.73年（按谷歌搜索转换）

因此，如果我的计算是正确的…当一台普通计算机通过递增和检查长的最大值是否溢出来计算长的最大值时，你已经老死了。你的孩子会死的。你的孙子，当它完成时他们可能在附近

最大值计算代码

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.NumberFormat;

public class MainLongMaxTest {

    // /*
    public static final long MAX_VALUE = Long.MAX_VALUE;
    public static long value = 0;
    public static long previousValue = 0;
    // */

    /*
    public static final int MAX_VALUE = Integer.MAX_VALUE;
    public static int value = 0;
    public static int previousValue = 0;
    */

    public static boolean done;
    public static BigDecimal startTime;
    public static BigDecimal endTime;

    public static void main(String[] args) {

        Runnable task = new StatusPrinterRunnable();
        new Thread(task).start(); // code waits 1 second before result printing loop

        done = false;
        startTime = new BigDecimal(System.currentTimeMillis());

        while(value >= 0) {
            previousValue = value;
            value += 1;
        }

        endTime = new BigDecimal(System.currentTimeMillis());
        done = true;
    }
}

class StatusPrinterRunnable implements Runnable {

    public static final NumberFormat numberFormat = NumberFormat.getNumberInstance();
    private static long SLEEP_TIME = 1000;

    @Override
    public void run() {

        try { Thread.sleep(SLEEP_TIME); } catch (InterruptedException e) { throw new RuntimeException(e);   }
        while(!MainLongMaxTest.done) {  
            long value                  = MainLongMaxTest.value;
            //long valuesLeft           = MAX_VALUE - value;

            BigDecimal maxValueBd       = new BigDecimal(MainLongMaxTest.MAX_VALUE);
            BigDecimal valueBd          = new BigDecimal(value);
            BigDecimal differenceBd     = maxValueBd.subtract(valueBd);
            BigDecimal percentLeftBd    = differenceBd.divide(maxValueBd, 25, RoundingMode.HALF_DOWN);
            percentLeftBd               = percentLeftBd.multiply(new BigDecimal(100));
            String numberAsString       = numberFormat.format(value);
            String percentLeftAsString  = percentLeftBd.toString();
            String message = "" + numberAsString + "\t" + percentLeftAsString + " % left";
            System.out.println(message);

            try { Thread.sleep(SLEEP_TIME); } catch (InterruptedException e) { throw new RuntimeException(e);   }
        }

        BigDecimal msTaken = MainLongMaxTest.endTime.subtract(MainLongMaxTest.startTime);
        BigDecimal secondsTaken = msTaken.divide(new BigDecimal("1000"));

        System.out.println();
        System.out.println("Max Value: " + numberFormat.format(MainLongMaxTest.previousValue));
        System.out.println("Time Taken (seconds): " + secondsTaken);
    }
}

我很好奇要花多长时间，所以我写了一个类来做同样的事情。用一个单独的线程来写它，每1秒更新一次控制台的结果

“int”结果

“长期”结果

1362032,97-第二和第三个值之间的差值（1秒）

6771768529秒-达到long的最大值（long.max_值/2nd3rdDifference）需要多少秒

6771768529秒=214.73年（按谷歌搜索转换）

因此，如果我的计算是正确的…当一台普通计算机通过递增和检查长的最大值是否溢出来计算长的最大值时，你已经老死了。你的孩子会死的。你的孙子，当它完成时他们可能在附近

最大值计算代码

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.NumberFormat;

public class MainLongMaxTest {

    // /*
    public static final long MAX_VALUE = Long.MAX_VALUE;
    public static long value = 0;
    public static long previousValue = 0;
    // */

    /*
    public static final int MAX_VALUE = Integer.MAX_VALUE;
    public static int value = 0;
    public static int previousValue = 0;
    */

    public static boolean done;
    public static BigDecimal startTime;
    public static BigDecimal endTime;

    public static void main(String[] args) {

        Runnable task = new StatusPrinterRunnable();
        new Thread(task).start(); // code waits 1 second before result printing loop

        done = false;
        startTime = new BigDecimal(System.currentTimeMillis());

        while(value >= 0) {
            previousValue = value;
            value += 1;
        }

        endTime = new BigDecimal(System.currentTimeMillis());
        done = true;
    }
}

class StatusPrinterRunnable implements Runnable {

    public static final NumberFormat numberFormat = NumberFormat.getNumberInstance();
    private static long SLEEP_TIME = 1000;

    @Override
    public void run() {

        try { Thread.sleep(SLEEP_TIME); } catch (InterruptedException e) { throw new RuntimeException(e);   }
        while(!MainLongMaxTest.done) {  
            long value                  = MainLongMaxTest.value;
            //long valuesLeft           = MAX_VALUE - value;

            BigDecimal maxValueBd       = new BigDecimal(MainLongMaxTest.MAX_VALUE);
            BigDecimal valueBd          = new BigDecimal(value);
            BigDecimal differenceBd     = maxValueBd.subtract(valueBd);
            BigDecimal percentLeftBd    = differenceBd.divide(maxValueBd, 25, RoundingMode.HALF_DOWN);
            percentLeftBd               = percentLeftBd.multiply(new BigDecimal(100));
            String numberAsString       = numberFormat.format(value);
            String percentLeftAsString  = percentLeftBd.toString();
            String message = "" + numberAsString + "\t" + percentLeftAsString + " % left";
            System.out.println(message);

            try { Thread.sleep(SLEEP_TIME); } catch (InterruptedException e) { throw new RuntimeException(e);   }
        }

        BigDecimal msTaken = MainLongMaxTest.endTime.subtract(MainLongMaxTest.startTime);
        BigDecimal secondsTaken = msTaken.divide(new BigDecimal("1000"));

        System.out.println();
        System.out.println("Max Value: " + numberFormat.format(MainLongMaxTest.previousValue));
        System.out.println("Time Taken (seconds): " + secondsTaken);
    }
}

如果利用二元代数，您可以通过以下方式一步获得结果：

结果=-1L>>>1；
如果您利用二元代数的优势，您可以通过以下方式一步获得结果：

result=-1L>>>1；
因为它会永远运行。它可以工作，只是需要太长的时间。
；）@肉桂：评论应该是答案：D@CodeRunner“循环不会根据条件而中断。”错误，即使是
long
也会溢出。这绝对是一种查找最小或最大范围值的错误方法。您可以通过long.min_值查找最小值，通过long.max_值查找最大值。因为它会永远运行。它可以工作，只不过需要太长的时间即可。@肉桂评论应该是答案：D@CodeRunner “循环不会根据条件而中断。”错误，即使是
long
也会溢出。这绝对是一种查找最小或最大范围值的错误方法。您可以通过long.min\u值查找最小值，通过long.max\u值查找最大值。非常详细的解释！谢谢；）嗨，DummyMe，我也试着修改一下你的逻辑，看看结果。请在下面的线程中找到我的答案