Java Double.valueOf

At my work, all developer use Double.valueOf instead of new Double constructor. In every case. For Integer or Short I can understand it for cache values but for not for double and float.

I look Double.valueOf in OpenJDK sources :

 /**
 * Returns a {@code Double} instance representing the specified
 * {@code double} value.
 * If a new {@code Double} instance is not required, this method
 * should generally be used in preference to the constructor
 * {@link #Double(double)}, as this method is likely to yield
 * significantly better space and time performance by caching
 * frequently requested values.
 *
 * @param  d a double value.
 * @return a {@code Double} instance representing {@code d}.
 * @since  1.5
 */
public static Double valueOf(double d) {
    return new Double(d);
}

So it just calls Doubles constructor.
I can understand why the method exist for be coherent with Integer/Short…

But the comment on the method:

this method should generally be used in preference to the constructor

After i see its the same comment on every valueOf() method. (Integer,Short …)

The comment is false? Or an other process meddle?

I heard about intrinsic methods in Java, next step was search in hotspot code and in vmSymbol.hpp

/* boxing methods: */                                                                                                 
   do_name(    valueOf_name,              "valueOf")                                                                    
  do_intrinsic(_Boolean_valueOf,          java_lang_Boolean,      valueOf_name, Boolean_valueOf_signature, F_S)         
   do_name(     Boolean_valueOf_signature,                       "(Z)Ljava/lang/Boolean;")                              
  do_intrinsic(_Byte_valueOf,             java_lang_Byte,         valueOf_name, Byte_valueOf_signature, F_S)            
   do_name(     Byte_valueOf_signature,                          "(B)Ljava/lang/Byte;")                                 
  do_intrinsic(_Character_valueOf,        java_lang_Character,    valueOf_name, Character_valueOf_signature, F_S)       
   do_name(     Character_valueOf_signature,                     "(C)Ljava/lang/Character;")                            
  do_intrinsic(_Short_valueOf,            java_lang_Short,        valueOf_name, Short_valueOf_signature, F_S)           
   do_name(     Short_valueOf_signature,                         "(S)Ljava/lang/Short;")                                
  do_intrinsic(_Integer_valueOf,          java_lang_Integer,      valueOf_name, Integer_valueOf_signature, F_S)         
   do_name(     Integer_valueOf_signature,                       "(I)Ljava/lang/Integer;")                              
  do_intrinsic(_Long_valueOf,             java_lang_Long,         valueOf_name, Long_valueOf_signature, F_S)            
   do_name(     Long_valueOf_signature,                          "(J)Ljava/lang/Long;")                                 
  do_intrinsic(_Float_valueOf,            java_lang_Float,        valueOf_name, Float_valueOf_signature, F_S)           
   do_name(     Float_valueOf_signature,                         "(F)Ljava/lang/Float;")                                
  do_intrinsic(_Double_valueOf,           java_lang_Double,       valueOf_name, Double_valueOf_signature, F_S)          
   do_name(     Double_valueOf_signature,                        "(D)Ljava/lang/Double;")       

So after I grep Double.valueOf in source and I found withebox.cpp

static jobject doubleBox(JavaThread* thread, JNIEnv* env, jdouble value) {
  return box(thread, env, vmSymbols::java_lang_Double(), vmSymbols::Double_valueOf_signature(), value);
}

and box method code :

template <typename T>
static jobject box(JavaThread* thread, JNIEnv* env, Symbol* name, Symbol* sig, T value) {
  ResourceMark rm(thread);
  jclass clazz = env->FindClass(name->as_C_string());
  CHECK_JNI_EXCEPTION_(env, NULL);
  jmethodID methodID = env->GetStaticMethodID(clazz,
        vmSymbols::valueOf_name()->as_C_string(),
        sig->as_C_string());
  CHECK_JNI_EXCEPTION_(env, NULL);
  jobject result = env->CallStaticObjectMethod(clazz, methodID, value);
  CHECK_JNI_EXCEPTION_(env, NULL);
  return result;
}

and this code …

Ok, I’m not advanced yet. This method box() is really called in server mode?

3 questions for resume 😀

1. JVM intercept Double.valueOf() for call this box method?

2. Double.valueOf doesn’t use JDK source and dont do a new Double()?

3. The comment on Double.valueOf() is just a dump copy/paste, Double.valueOf and new Double have same effect?