十多年前，我在一门本科水平的java入门课程中教授了这种技术。但是，我应该指出，IIRC，我们还没有接触到String和Integer类方法。

这种技术很简单，打字也很快。如果我所做的只是打印一些东西，我将使用它(例如，System.out。Println ("" + i);。然而，我认为这不是进行转换的最佳方式，因为当它以这种方式使用时，需要考虑一下才能意识到发生了什么。此外，如果性能是一个问题，它似乎更慢(下文以及其他答案)。

就我个人而言，我更喜欢Integer.toString()，因为它很明显会发生什么。String.valueOf()将是我的第二选择，因为它似乎令人困惑(看看darioo回答后的评论)。

我写了一些类来测试这三种技术:"" + I，整数。toString和String.ValueOf。每个测试只是将整数从1到10000转换为字符串。然后，我分别用Linux time命令运行了五次。Integer.toString()比String.valueOf()稍微快一次，他们捆绑了三次，String.valueOf()更快一次;然而，这种差异从来没有超过几毫秒。

“”+ i技术在每个测试中都比这两者都慢，除了一个测试，它比Integer.toString()快1毫秒，比String.valueOf()慢1毫秒(显然是在同一个测试中，String.valueOf()比Integer.toString()快)。虽然它通常只慢了几毫秒，但有一个测试慢了大约50毫秒。YMMV。

就我个人而言，我没有看到这段代码有什么不好的地方。

当您想记录一个int值，而记录器只接受一个字符串时，它非常有用。我想说，当你需要调用一个接受String的方法，但你有一个int值时，这样的转换是很方便的。

至于整数之间的选择。toString或String。这完全是个人品味的问题。 .．.内部是字符串。valueOf调用Integer。顺便说一下toString方法。：）

有三种转换为字符串的方法

字符串字符串= "" + i; String String = String. valueof (i); String String = Integer.toString(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

这不仅仅是优化。我不喜欢

"" + i

因为它没有表达出我真正想做的事情。

我不想将一个整数附加到一个(空)字符串。我想把一个整数转换成字符串:

Integer.toString(i)

或者，不是我的首选，但仍然比串联更好，获得一个对象的字符串表示(整数):

String.valueOf(i)

1. 对于经常调用的代码，比如在循环中，优化当然也是不使用串联的一个原因。

2. 这对于在System.out中使用真正的连接是无效的。println("Index: " + i);or String id = " id " + i;

Mostly ditto on SimonJ. I really dislike the ""+i idiom. If you say String.valueOf(i), Java converts the integer to a string and returns the result. If you say ""+i, Java creates a StringBuilder object, appends an empty string to it, converts the integer to a string, appends this to the StringBuilder, then converts the StringBuilder to a String. That's a lot of extra steps. I suppose if you do it once in a big program, it's no big deal. But if you're doing this all the time, you're making the computer do a bunch of extra work and creating all these extra objects that then have to be cleaned up. I don't want to get fanatic about micro-optimization, but I don't want to be pointlessly wasteful either.