Why do these two multiplication operations give different results?

by 
long oneYearWithL = 1000*60*60*24*365L;
long oneYearWithoutL = 1000*60*60*24*365;

Your first value is actually a long (Since 365L is a long, and 1000*60*60*24 is an integer, so the result of multiplying a long value with an integer value is a long value.

But 2nd value is an integer (Since you are mulitplying an integer value with an integer value only. So the result will be a 32-bit integer. Now the result obtained for that multiplication is outside the actual range of integer. So, before getting assigned to the variable, it is truncated to fit into valid integer range.

Take a look at the following print statement: – 

System.out.println(1000*60*60*24*365L);
System.out.println(1000*60*60*24*365);
System.out.println(Integer.MAX_VALUE);

When you run the above code: –

Output: – 

31536000000
1471228928
2147483647

So, you can see the difference..

011101010111101100010010110000000000 -- Binary equivalent of 1000*60*60*24*365L
    01111111111111111111111111111111 -- Binary equivalent of Integer.MAX_VALUE

So, if you don’t add that L at the end of your number, the 4 most significant bit is removed from the first binary string..

So, the string becomes..

(0111)01010111101100010010110000000000 -- Remove the most significant bits..
      01010111101100010010110000000000 -- Binary equivalent of 1471228928

(which you get as output)

UPDATE: –
From the above explanation, you can also understand that, even in the first assignment, if the result of your multiplication of integers before multiplying it with 365L goes out of range, then again it will be truncated to fit in integer range, or converted to 2's complement representation if required, and then only it will be multiplied with the long value - 365L.

For e.g: –

long thirtyYearWithL = 1000*60*60*24*30*365L;

In the above example, consider the first part – 1000*60*60*24*30. The result of this multiplication is: – 2592000000. Now lets’ see how it is represented in binary equivalent: –

2592000000 = 10011010011111101100100000000000  -- MSB is `1`, a negative value
             01100101100000010011100000000001  -- 2's complement representation

Decimal representation of the 2's complement representation is 1702967297. So, 2592000000 is converted to -1702967297, before getting multiplied to 365L. Now since, this value fits in the integer range which is : – [-2147483648 to 2147483647], so it will not be truncated further.

So, the actual result will be: – 

long thirtyYearWithL = 1000*60*60*24*30*365L;
                     = 2592000000 * 365L;
                     = -1702967297 * 365L = -621583063040

So, all these stuffs just considers the actual type of final result on applying the arithmetic operation. And this check is performed on each temporary result of operations moving from left to right(considering operators with left-to-right associativity). If any temporary result is found to be out of range, then that is converted accordingly to fit in the required range, before moving forward with next operation.

UPDATE 2: –

So, instead of: –

long thirtyYearWithL = 1000*60*60*24*30*365L;

if you move your 365L at the start, then you will get the correct result: –

long thirtyYearWithL = 365L*1000*60*60*24*30; // will give you correct result

Because, now your temporary result will be of type long, and is capable of holding that value.

More Related Contents:

  1. The literal xyz of type int is out of range
  2. How do I convert from int to Long in Java?
  3. How do I add an "L" to the end of an integer?
  4. Why is 08 not a valid integer literal in Java?
  5. Java – Convert integer to string [duplicate]
  6. What is the difference between Integer and int in Java?
  7. Java Array Sort descending?
  8. Java – char, int conversions
  9. How to convert float to int with Java
  10. “int cannot be dereferenced” in Java
  11. In java, is it more efficient to use byte or short instead of int and float instead of double?
  12. Java, Simplified check if int array contains int
  13. Java Round up Any Number
  14. How are integers cast to bytes in Java?
  15. Converting an int to a binary string representation in Java?
  16. Rounding a double to turn it into an int (java)
  17. Integer vs int: with regard to memory
  18. Is it valid to compare a double with an int in java?
  19. How to convert a Byte Array to an Int Array
  20. Return first digit of an integer
  21. Splitting String and put it on int array
  22. Java: Checking if a bit is 0 or 1 in a long
  23. How does subtracting the character ‘0’ from a char change it into an int?
  24. Bitwise Multiply and Add in Java
  25. How can I convert a char to int in Java? [duplicate]
  26. Adding char and int
  27. Wrong result by Java Math.pow
  28. int[] and Integer[] arrays – What is the difference?
  29. Integer division in Java [duplicate]
  30. (a * b) / c MulDiv and dealing with overflow from intermediate multiplication

Leave a Comment