在Java中以“长”数据类型打印出每个数字

Question

I tried printing out every individual number in a long datatype but I get this error message after about 1,000,000,000 numbers:

IllegalArgumentException: Illogical text range from 1072890159 to -1072593439

How can I continue past this point?

long tot = 0;
while (tot < 9223372036854775807L)
{
    //This for loop makes sure that instead of printing out 200 000 numbers in 27 sec it
    //will take less than 3 seconds to print out about 500 000 numbers
    for (int i = 0; i < 10000; i++)
    {
        tot = tot + 10; 
        System.out.print(tot+" "+(tot+1)+" "+(tot+2)+" "+(tot+3)+" "+(tot+4)+" "+(tot+5)
                            +" "+(tot+6)+" "+(tot+7)+" "+(tot+8)+" "+(tot+9)+" "); 
    }

    System.out.println("");
}

Answer 1

You're NOT „ printing out every individual number in a long datatype “ with this code snippet.

Firstly, you start printing positive numbers from 10 on. Try it with byte to check but be prepared to abort the run quickly, since...

Secondly, the while loop never ends. Why this?

Well, once you have spent appx. 150 years (according to Oliver Charlesworth 's calculation mentioned in the comments) tot in the while header becomes 9,223,372,036,854,700,000 .
( tot is always a multiple of 100,000 after the for loop due to the ‹0..9,999› < 10000 and the + 10 therein.)

The following will be printed in that while cycle (line breaks and formatting added for easier reading):

 ...
 9223372036854775800  9223372036854775801  9223372036854775802
 9223372036854775803  9223372036854775804  9223372036854775805
 9223372036854775806  9223372036854775807 -9223372036854775808
-9223372036854775807 -9223372036854775806 -9223372036854775805
-9223372036854775804 -9223372036854775803 -9223372036854775802
 ...

This is known as (arithmetic) overflow .

Such tot will be less, since negative, than 9223372036854775807L , aka Long.MAX_VALUE , for another appx. 150 years until it becomes positive again and then the whole cycle starts again, over and over.

Why does this happen?

Well, there is one and only one value of tot that can make (tot < 9223372036854775807L) evaluate to false to leave the while loop: exactly this 9_223_372_036_854_775_807L , aka Long.MAX_VALUE , since there is no bigger long value than this.

But you are "hiding" this number inside the for loop (see output above and remember that tot is always a multiple of 100,000 outside the for loop) so that (tot < 9223372036854775807L) never gets the chance to evaluate against it.

I'd implement it as follows:

public class Integers {

    public static void main(final String[] args) {

        printNumbersBetween(Byte.MIN_VALUE, Byte.MAX_VALUE);
        printNumbersBetween(Short.MIN_VALUE, Short.MAX_VALUE);
        printNumbersBetween(Character.MIN_VALUE, Character.MAX_VALUE);
        // printNumbersBetween(Integer.MIN_VALUE, Integer.MAX_VALUE);
        // printNumbersBetween(Long.MIN_VALUE, Long.MAX_VALUE);

    } // main(...)

    public static void printNumbersBetween(final long minValue, final long maxValue) {

        long n = minValue;
        while (n < maxValue) {
            // Count of numbers to be printed at once is preferably a power of two,
            // since the counts of numbers in the domains of all primitives divide nicely by it.
            // Such avoiding having to extra handle the last print cycle which is not "full".
            // E.g.: byte -> 256 numbers -> (discouraged) chunks of 10 -> 25 * 10 + 6[!].
            System.out.printf("%d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d%n",
                n++, n++, n++, n++, n++, n++, n++, n++, n++, n++, n++, n++, n++, n++, n++, n++);
        }

    } // printNumbersBetween(...)

} // Integers

---

Apart from the above let me leave some comments concerning your coding style:

• 9223372036854775807L is as bad as magic numbers can be. 9_223_372_036_854_775_807L (since Java 7) would be slightly better but Long.MAX_VALUE is provided by the Java API exactly for this.
• I agree, one can argue whether tot += 10 or tot = tot + 10; is preferred. I don't cling on that.

• The lines:

   System.out.printf("%d %d %d %d %d %d %d %d %d %d ", tot, tot+1, tot+2, tot+3, tot+4, tot+5, tot+6, tot+7, tot+8, tot+9);` 

  compared to:

   System.out.print(tot+" "+(tot+1)+" "+(tot+2)+" "+(tot+3)+" "+(tot+4)+" "+(tot+5) +" "+(tot+6)+" "+(tot+7)+" "+(tot+8)+" "+(tot+9)+" "); 

  are much easier to read and comprehend, aren't they? And it's shorter, too.

• Creating an implicite instance of (an empty) String in System.out.println(""); is pointless.