为什么使用Long.valueOf（...）而不是长文字？

Question

Recently I stumbled over code where people write stuff like

Long myLong = Long.valueOf(42);

// instead of

Long myLong = 42L;

I have no clue why one would do this, except for personal taste regarding readability.

Am I missing something?

Answer 1

with direct assignment you are required to cast if assigning int to Long ( int to primitive long is implicit) and they get autoboxed automatically using Long.valueOf

    Long myLong1 = Long.valueOf(42);
    Long myLong2 = Long.valueOf(42L);
    Long myLong3 = 42L;
    Long myLong4 = (long) 42;

otherwise they are all same See bytecode output from javap

  public static void main(java.lang.String[]);
    Code:
       0: ldc2_w        #16                 // long 42l
       3: invokestatic  #18                 // Method java/lang/Long.valueOf:(J)Ljava/lang/Long;
       6: astore_1      
       7: ldc2_w        #16                 // long 42l
      10: invokestatic  #18                 // Method java/lang/Long.valueOf:(J)Ljava/lang/Long;
      13: astore_2      
      14: ldc2_w        #16                 // long 42l
      17: invokestatic  #18                 // Method java/lang/Long.valueOf:(J)Ljava/lang/Long;
      20: astore_3      
      21: ldc2_w        #16                 // long 42l
      24: invokestatic  #18                 // Method java/lang/Long.valueOf:(J)Ljava/lang/Long;
      27: astore        4
      29: return        

However using new Long(42L) should be avoided if not absolutely necessary and one of above statement needs to be used in favor of this as valueOf methods normally cache a range of values ( FlyWeight Design Pattern ) by JVM internally

Trivia: In case of integers & Oracle JVM the range can be controlled using -XX:AutoBoxCacheMax=

Answer 2

The snippet

Long myLong = 42L;

is internally the same as

Long myLong = Long.valueOf(42);

The compiler will generate the same bytecode.

Answer 3

I also think it's a reminder of java before java5, where there was no autoboxing, and where

Long l = 42L; 

could not be compiled.

Answer 4

它们是等价的，编译器将为两者构建相同的字节码

Answer 5

valueOf takes a primitive long . For literals, I'd agree that 42L is better, but if you have an int or long variable, Long.valueOf is a good way to get a Long . valueOf also uses a cache of values from -128 to 127, which gives it a slight performance edge over new Long(long) for common values.

Answer 6

People who don't realize you can do it the other way?

I have to wonder if the compiler is smart enough to convert the Long.valueOf to the same bytecode, for constant calls. Otherwise there would be a tiny performance hit (not significant, but you might notice it heavily-run, tight loops).

The valueOf version is useful for casting primitive values safely, handy if you're doing a bunch of casts between primitive types and don't want to (for example) cause problems doing: (int)longBiggerThanIntCanHandle

(You wouldn't care about doing (long)intValue, but if you're doing a bunch of conversions both ways, it's good to use valueOf as a convention, for safety.)