how to get number of micro seconds in a day

I want to get the number of micro seconds in a day

so I tried as per below

long microDay = 24 * 60 * 60 * 1000 * 1000;

for which I am expecting value as 86400000000 but when I print it

System.out.println(microDay);

The value is 500654080

After spending 3 hours and breaking my head to know the reason,final I found that java think 24,60 and 1000 as int values and int*int =int but the maximum value of int is 2147483647 so it cant store 86400000000 and hence it the output is 500654080 (but I am not sure)

In the second case I wanted to calculate miliseconds in a day and the formula goes like this

long miliDay = 24 * 60 * 60 * 1000;
System.out.println(miliDay );

output 86400000

now when I did 

System.out.println(microDay/ miliDay);

output 5

but when I tried this in a calculator 500654080/86400000= 5.794607407407407 why there is different in result?

Jon Skeet
people
quotationmark

You're performing 32-bit integer arithmetic, as every operand in 24 * 60 * 60 * 1000 * 1000 is an int... but the result is bigger than Integer.MAX_VALUE, so it's overflowing (just as you suspected). (This is actually happening at compile-time in this case, because it's a compile-time constant, but the effect is the same as if it happened at execution time.)

Effectively, each operation is truncated to 32 bits. As it happens, only the final multiplication by 1000 takes the result over 231 - 86400000 is fine.

86400000000 in binary is:

1010000011101110101110110000000000000
    ^
    \- Bit 33

So after overflow, we just chop any leading bits until we've got 32:

     00011101110101110110000000000000

And that value is 500654080.

Just use long instead, e.g.

long microDay = 24L * 60L * 60L * 1000L * 1000L;

(You definitely don't need all those constants to be of type long, but being consistent means it's obvious that all the operations will be performed using 64-bit arithmetic, with no need to consider associativity etc.)

A better approach, however, would be to use TimeUnit:

long microDay = TimeUnit.DAYS.toMicroseconds(1);

As for the division part, you're performing integer division - so the result is the integer part, rounded towards 0. If you want floating point arithmetic, you need to cast one of the operands to float or double... although if you start off with the right values, of course, you should get an exact integer anyway (1000).

people

See more on this question at Stackoverflow