Java - 有没有理由使用这种格式:(长）0;而不是这一个：0L;？

Question

I couldn't find any information about this when searching StackOverflow or Google, and I've got some coworkers who disagree with my preference for how to initialize a simple Long variable.

Is there any reason to use one of these formats over the other?

Long foo = (long) 0; // First way of doing it
Long bar = 0L; // Second way of doing it

I'm most interested if anyone knows if there is an efficiency difference here.

The reason I prefer the second way is because you can specify values less than Integer.MIN_VALUE and greater than Integer.MAX_VALUE , whereas Eclipse would complain with something along the lines of "The literal 10000000000 of type int is out of range" if you used the first way here.

Answer 1

There is no difference (except you mentioned) . Compiler is smart enough. If I compile following class:

public class Test {
    public static void main(String[] args) {
        Long foo = (long) 0;
        Long bar = 0L;
    }
}

And then decompile them:

$ javap -c Test.class

Compiled from "Test.java"
public class Test {
  public Test();
    Code:
       0: aload_0       
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return        

  public static void main(java.lang.String[]);
    Code:
       0: lconst_0      
       1: invokestatic  #2                  // Method java/lang/Long.valueOf:(J)Ljava/lang/Long;
       4: astore_1      
       5: lconst_0      
       6: invokestatic  #2                  // Method java/lang/Long.valueOf:(J)Ljava/lang/Long;
       9: astore_2      
      10: return        
}

I don't see any difference. Use one which is look better for you or corresponds to the conventions.

To verify decompiler I compile this two lines independent and then calculate checksums:

$ sha1sum Test.class_L Test.class_long
292a93b6433b5a451afdb41bd957667c91eebf23  Test.class_L
292a93b6433b5a451afdb41bd957667c91eebf23  Test.class_long

Answer 2

Long foo = (long) 0; // First way of doing it

This way will create an int then cast it to a long .

Long bar = 0L; // Second way of doing it

This is a long literal, so it will only create a long .

I imagine the difference is negligible, but it would be quicker to create a long than to create an int then cast to long .

Edit

As you correctly said, the first way will only allow you to convert an int to a long , which means that in one line, you can only ever create a long the size of an int .. which is pointless and a waste of memory.

Answer 3

(long) 0 casts an int to a long . 0L is a long . So if you want to use a long , use one.

Answer 4

One difference which isn't mentioned is that the compiler will reject a numeric literal which is larger than 2147483647 but doesn't have an L suffix. If there are semantic reasons why one needs a literal to be processed as type long rather than int , but the code would malfunction if given any value larger than 2147483647, casting an unsuffixed literal would retain the constraint on the value while forcing the type to be processed as long . Such a thing might be appropriate, for example, if a value would be multiplied by 256 and then later divided by 256, and if the result of such division would need to fit in an int .