Java: String s = "" + myInteger; - how to mentor away from that pattern?

Question

I am looking for arguments that would allow me to show the light that in Java

int myInt = 1;
...
String s = "" + myInt;

is indeed a perfectly correct and compiling implementation of String.valueOf(myInt) but that doing that "is not the canonical way it's done in Java".

"it looks nicer" is the argument that I am getting, and "I expect the compiler to deal with that".

I have tried sending a link to https://godbolt.org/ (Compiler Explorer) which shows the generated JVM instructions; arguing about "canonical ways" or "least surprise" or "implementation patterns" or "maintainability" will not be effective.

I am lost - any suggestions?

Answer 1

In matters of style (and this is a matter of style; run a micro-benchmark to prove and quantify run-time performance differences) I would follow these rules:

1. if your project has a style guide that recommends one particular choice, follow the style guide
2. if it has existing code that consistently follows one choice, follow that choice
3. if neither applies, make a choice and stick to it

The source for the JDK is freely available. In Java 8, I count 276 files with one or more occurrences of "" + (and in the ones that I looked at, numbers often followed). Of course, there are >3k files with calls to .toString, and I have not looked at .valueOf at all, so this is hardly conclusive. Therefore, use of "" + number-to-string conversion does not appear to be uncommon or frowned upon in well-written Java code.

Not that good Java developers would concatenate strings inside loops; a frequent use seems to be generating error messages for exceptions.

Oracle's ancient Java style guide, and the more recent ones by Google and Spring do not appear to have a say on the matter. Therefore, I feel that there is no right answer, and if coding together on a project, and you care enough about this, you should apply Rule 3: iron out a compromise, document it in your project's style guide, and stick to it.

On a personal note, I find "" + o easier to read than many of the alternatives, as syntactic sugar for a call to toString() that works regardless of the type of o (and even when o is null).

---

I actually tried this out using caliper on JDK 11, and results show minimal run-time difference, and no memory or object-count difference, when performing 1k int-to-string conversions by these 3 methods:

 t (ms)   method

 12,30    "" + j
 12,57    Integer.toString(j)
 12.58    String.valueOf(j)

Code to reproduce:

package org.example;

import com.google.caliper.BeforeExperiment;
import com.google.caliper.Benchmark;
import com.google.caliper.Param;
import com.google.caliper.runner.CaliperMain;

public class Main {

    @Param({"10", "100", "1000"})
    int size;

    private String[] output;

    @BeforeExperiment
    void setUp() {
        output = new String[size];
    }

    @Benchmark void quote(int reps) {
        for (int i = 0; i < reps; i++) {
            for (int j = 0; j < size; j++) {
                output[j] = "" + j;
            }
        }
    }

    @Benchmark void toString(int reps) {
        for (int i = 0; i < reps; i++) {
            for (int j = 0; j < size; j++) {
                output[j] = Integer.toString(j);
            }
        }
    }

    @Benchmark void valueOf(int reps) {
        for (int i = 0; i < reps; i++) {
            for (int j = 0; j < size; j++) {
                output[j] = String.valueOf(j);
            }
        }
    }

    public static void main(String[] args) {
        CaliperMain.main(Main.class, args);
    }
}

Answer 2

In it current form, it is OK, but add a little change

    int myInt = 1;
    int myInt2 = 2;
    String s = "" + myInt + myInt2;

    System.out.println(s);

vs.

    System.out.println(String.format("%d", myInt + myInt2));

is this what you are asking

Answer 3

Yould show the evaluation happening.

String s = String.valueOf(myInt);      // 1

String s = "" + myInt;                 // 1
String s = "" + String.valueOf(myInt); // 2
String s = result of plus;             // 3

• "" + int is an extra artifact.

• One would also not write 0.0 + n instead of (double) nto convert int n to a double.

• The compiler is allowed to generate dumb java byte code:

    public class IntToString {
        public String intToStringConverting(int n) {
            return String.valueOf(n);
        }
        public String intToStringWithPlus(int n) {
            return "" + n;
        }
    }
  

  javap -c IntToString.class

  public java.lang.String intToStringConverting(int);
    Code:
       0: iload_1
       1: invokestatic  #7 // Method java/lang/String.valueOf:(I)Ljava/lang/String;
       4: areturn
  
  public java.lang.String intToStringWithPlus(int);
    Code:
       0: iload_1
       1: invokedynamic #13,  0 // InvokeDynamic #0:makeConcatWithConstants:(I)Ljava/lang/String;
       6: areturn
  

As one sees extra code, first calling makeConcatWithConstants.

Answer 4

You may use the form, according to the context. In my experience, I use String.valueOf() and Integer.toString(). I think the implementation is similar, but I like the second one. Using String.format, it's a bit slow because you must parse the expression.

int myInt = 1;
...
String s1 = String.format("%d", myInt);
String s2 = String.valueOf(myInt);
String s3 = Integer.toString(myInt);  // I use this