很多大学入门课程似乎都在教授这种风格，有两个原因(根据我的经验):

它不需要理解类或方法。通常，在提到“类”这个词之前就已经教过了——甚至方法调用也没有。所以使用String.valueOf(…)这样的东西会让学生感到困惑。 这是“操作符重载”的一个例子——事实上，这是作为惯用重载操作符卖给我们的(这没什么奇怪的，因为Java不允许自定义操作符重载)。

因此，它可能是出于教学的需要(尽管我认为这只是糟糕的教学)，也可能是用来说明一个很难在Java中演示的原则。

这不是一个好方法。

当进行从int到string的转换时，应该使用这个:

int i = 5;
String strI = String.valueOf(i);

正如已经指出的，Integer.toString()或String.valueOf()是正确的方法。我很好奇，做了一个快速的基准测试:

Integer.toString(i)和String.valueOf(i)在性能上基本相同，Integer.toString(i)稍微快一点。但是i + ""要慢1.7倍。

import java.util.Random;

public class Test {

    public static void main(String[] args) {
        long concat = 0;
        long valueOf = 0;
        long toString = 0;
        
        int iterations = 10000;
        int runs = 1000;
        for(int i = 0; i < runs; i++) {
            concat += concat(iterations);
            valueOf += valueOf(iterations);
            toString += to_String(iterations);
        }
        
        System.out.println("concat: " + concat/runs);
        System.out.println("valueOf: " + valueOf/runs);
        System.out.println("toString: " + toString/runs);
    }
    
    public static long concat(int iterations) {
        Random r = new Random(0);
        long start = System.nanoTime();
        for(int i = 0; i < iterations; i++) {
            String s = r.nextInt() + "";
        }
        return System.nanoTime() - start;
    }
    
    public static long valueOf(int iterations) {
        Random r = new Random(0);
        long start = System.nanoTime();
        for(int i = 0; i < iterations; i++) {
            String s = String.valueOf(r.nextInt());
        }
        return System.nanoTime() - start;
    }
    
    public static long to_String(int iterations) {
        Random r = new Random(0);
        long start = System.nanoTime();
        for(int i = 0; i < iterations; i++) {
            String s = Integer.toString(r.nextInt());
        }
        return System.nanoTime() - start;
    }
}

输出:

concat: 1004109
valueOf: 590978
toString: 587236

尝试简单的类型转换

char c = (char) i;

String strI = String.valueOf(i);

String string = Integer.toString(i);

两种方法都是正确的。

正常的方法是Integer.toString(i)或String.valueOf(i)。

这种连接是有效的，但它是非常规的，可能是一种不好的气味，因为它表明作者不知道上面的两种方法(他们还可能不知道什么?)

Java在与字符串一起使用时对+运算符有特殊的支持(请参阅文档)，它将你发布的代码转换为:

StringBuilder sb = new StringBuilder();
sb.append("");
sb.append(i);
String strI = sb.toString();

在编译时。它的效率略低(sb.append()最终调用Integer.getChars()，这是Integer.toString()本来要做的)，但它是有效的。

回答grorodriguez的评论:**不，编译器在这种情况下不会优化空字符串-看:

simon@lucifer:~$ cat TestClass.java
public class TestClass {
  public static void main(String[] args) {
    int i = 5;
    String strI = "" + i;
  }
}
simon@lucifer:~$ javac TestClass.java && javap -c TestClass
Compiled from "TestClass.java"
public class TestClass extends java.lang.Object{
public TestClass();
  Code:
   0:    aload_0
   1:    invokespecial    #1; //Method java/lang/Object."<init>":()V
   4:    return

public static void main(java.lang.String[]);
  Code:
   0:    iconst_5
   1:    istore_1

初始化StringBuilder:

   2:    new    #2; //class java/lang/StringBuilder
   5:    dup
   6:    invokespecial    #3; //Method java/lang/StringBuilder."<init>":()V

追加空字符串:

   9:    ldc    #4; //String
   11:    invokevirtual    #5; //Method java/lang/StringBuilder.append:
(Ljava/lang/String;)Ljava/lang/StringBuilder;

附加整数:

   14:    iload_1
   15:    invokevirtual    #6; //Method java/lang/StringBuilder.append:
(I)Ljava/lang/StringBuilder;

提取最后的字符串:

   18:    invokevirtual    #7; //Method java/lang/StringBuilder.toString:
()Ljava/lang/String;
   21:    astore_2
   22:    return
}

针对JDK 9，有一个改变这种行为的提议和正在进行的工作。