如何从 int 转换为 String？答案

【问题标题】：How do I convert from int to String?如何从 int 转换为 String？
【发布时间】：2011-05-05 13:19:56
【问题描述】：

我正在做一个项目，从int 到String 的所有转换都是这样完成的：

int i = 5;
String strI = "" + i;

我不熟悉 Java。

我认为这是惯常做法还是有什么问题？

【问题讨论】：

“傻，简单”的方式是string = "" + integer;
好文档：[javarevisited.blogspot.de/2011/08/…example
我的意思是，这是一种“快速、简单”的方法。这有点傻，但它有效！
我的一位同事做了Integer.valueOf(i).toString()。他一定很喜欢物品。虽然它非常清楚地表明了他的意图，但我的口味有点长。
只需要45行代码，实现7个接口即可。

标签： java string type-conversion

【解决方案1】：

正如已经指出的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

【讨论】：

【解决方案2】：

转成字符串的三种方式

String string = "" + i;
String string = String.valueOf(i);
String string = Integer.toString(i);

【讨论】：

【解决方案3】：

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

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

至于Integer.toString或String.valueOf的选择，全凭个人喜好。
...在内部，String.valueOf 顺便调用了Integer.toString 方法。 :)

【讨论】：

【解决方案4】：

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

"" + i

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

我不想将整数附加到（空）字符串。我想将整数转换为字符串：

Integer.toString(i)

或者，不是我喜欢的，但仍然比串联更好，获取对象的字符串表示（整数）：

String.valueOf(i)

^{1. 对于经常被调用的代码，比如在循环中，优化当然也是不使用连接的一个点。}

^{2。这对于使用真正的连接无效 System.out.println("Index: " + i); 或 String id = "ID" + i;}

【讨论】：

在这种情况下谈论性能的人会分心。远，远，远，远，远，远，更重要的是可读性。

【解决方案5】：

使用Integer.toString(tmpInt).trim();

【讨论】：

trim() 在这里真的没有任何用处。

【解决方案6】：

整数转字符串的方法有很多：

1)

Integer.toString(10);

2)

 String hundred = String.valueOf(100); // You can pass an int constant
 int ten = 10;
 String ten = String.valueOf(ten)

3)

String thousand = "" + 1000; // String concatenation

4)

String million = String.format("%d", 1000000)

【讨论】：

String.format("%d", 1000000) ... 这并不是真正的 Int>>String 转换，而是这里的 String>>String 处理，尽管重载。所以我不推荐这个。绝对不只是为了转换。

【解决方案7】：

String strI = String.valueOf(i);

String string = Integer.toString(i);

这两种方法都是正确的。

【讨论】：

【解决方案8】：

这项技术是在我十多年前参加的本科级别的 Java 入门课程中教授的。但是，我应该注意到，IIRC，我们还没有接触到 String 和 Integer 类方法。

该技术简单且易于打字。如果我正在做的只是打印一些东西，我会使用它（例如，System.out.println("" + i);。但是，我认为这不是进行转换的最佳方式，因为需要仔细考虑才能意识到什么时候发生了什么它正在以这种方式使用。此外，如果性能是一个问题，它似乎更慢（更多如下，以及其他答案）。

就个人而言，我更喜欢 Integer.toString()，因为很明显发生了什么。 String.valueOf() 将是我的第二选择，因为它似乎令人困惑（在 darioo 的回答之后见证 cmets）。

只是为了笑 :) 我编写了类来测试三种技术：“” + i、Integer.toString 和 String.ValueOf。每个测试只是将整数从 1 转换为 10000 到字符串。然后我通过 Linux time 命令运行了五次。 Integer.toString() 比 String.valueOf() 稍微快了一次，他们并列了 3 次，String.valueOf() 快了一次；但是，差异永远不会超过几毫秒。

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

【讨论】：

不要忘记将 JIT 考虑在内 - 前几次转换会慢得多并且会扭曲时间。在我的 MacBook 上，连接所需的时间比其他两种方法长约 20ns（每次转换都需要约 50ns），因此您看到的毫秒级差异可能是由于随机错误（调度、中断等）造成的。跨度>

【解决方案9】：

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

串联会起作用，但它是非常规的并且可能是一种难闻的气味，因为它表明作者不知道上述两种方法（他们可能不知道什么？）。

当与字符串一起使用时，Java 对 + 运算符具有特殊支持（请参阅 the documentation），它将您发布的代码转换为：

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

在编译时。它的效率稍微低一些（sb.append() 最终会调用 Integer.getChars()，这是 Integer.toString() 无论如何都会做的），但它确实有效。

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

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
}

a proposal 正在努力改变这种行为，目标是 JDK 9。

【讨论】：

jvm中的jit编译器呢？ :-) javac 没有做任何花哨的优化。
谁知道 :) javac 确实在使用数字文字时优化了这类表达式（例如，"" + 5 变为 "5"）。
是的，但你为什么要"" + 5 而不是"5"？
不错！ +1 他们可能不知道什么？
"" + integer 方法用于one of the official oracle tutorials。

【解决方案10】：

这取决于你想如何使用你的字符串。这会有所帮助：

String total =  Integer.toString(123) + Double.toString(456.789);

【讨论】：

【解决方案11】：

尝试简单的类型转换

char c = (char) i;

【讨论】：

这不是将 int 转换为字符串的好方法。实际上，您不是将 int 转换为字符串，而是将 int 转换为 char。这会将 int 解释为 ASCII 字符代码并为您提供该字符。这很危险（负值等），而且总体上是完全错误的。
请把上面的问题搞清楚，char和String都不一样...！
但这有效（ASCII 字符集“偏移”）：char c = (char) (i + 48);

【解决方案12】：

转成字符串有多种方式：

StringBuilder string = string.append(i).toString();
String string = String.valueOf(i);
String string = Integer.toString(i);

【讨论】：

StringBuilder 字符串 = string.append(i).toString(); ...嗯，它是 StringBuilder 还是 String？这里有些乱...

【解决方案13】：

我个人认为 "" + i 确实看起来像原始问题海报所说的“臭”。除了 Java，我还使用了很多面向对象的语言。如果该语法是合适的，那么 Java 将只解释 i 而不需要根据需要将 "" 转换为字符串并执行此操作，因为目标类型是明确的，并且右侧只会提供一个值.另一个似乎是欺骗编译器的“技巧”，如果需要移植代码，则考虑其他制造商或其他平台制造的不同版本的 Javac 时，这是一个糟糕的魔力。为了我的钱，它应该像许多其他 OOL 一样进行类型转换：（字符串）i. winks

鉴于我的学习方式以及在快速阅读其他代码时易于理解这种结构，我投票支持 Integer.toString(i) 方法。忘记一两个关于 Java 如何在后台实现事物与 String.valueOf(i) 这种方法对我来说是正确的，并准确地说明了正在发生的事情：我有整数，我希望它转换为字符串。

多次提出的一个好点是，也许只是在前面使用 StringBuilder 是构建混合了文本和整数或其他对象的字符串的一个很好的答案，因为无论如何这将在后台使用，对吗？

只要我的两分钱投入到 Mans 问题的答案已经很丰厚的小猫中...... 微笑

经过一些思考后编辑我自己的答案：

好的，好的，我在想这个，String.valueOf(i) 也非常好，它说：我想要一个代表整数值的字符串。大声笑，英语比 Java 更难解析！但是，我留下我的答案/评论的其余部分......我总是被教导尽可能使用方法/函数链的最低级别并且仍然保持可读性所以如果 String.valueOf 调用 Integer.toString 那么为什么使用整个橙色如果你还是要剥它，嗯？

为了澄清我对 StringBuilder 的评论，我构建了很多字符串，其中大部分是文字文本和 int 的组合，它们最终变得又长又丑，调用嵌入在 + 之间的上述例程，在我看来是这样如果这些无论如何都成为 SB 对象并且 append 方法有重载，那么继续使用它可能会更干净......所以我想我现在最多 5 美分，是吗？哈哈……

【讨论】：

【解决方案14】：

使用 "" + i 是将数字转换为字符串的最短和最简单的方法。它不是最有效的，但它是最清晰的恕我直言，这通常更重要。代码越简单，出错的可能性就越小。

【讨论】：

在调用 String.valueOf 或 Integer.toString 时怎么会出错？
我遇到过一些 String.valueOf() 的非理想用法，但我现在不记得了。虽然输出正确，但效率低于""+i

【解决方案15】：

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

它不需要了解类或方法。通常，这是在提到“类”这个词之前就被教导的——甚至是方法调用。所以使用String.valueOf(…) 之类的东西会让学生感到困惑。
这是“运算符重载”的一个例证——事实上，这是作为惯用的重载运算符卖给我们的（这里难怪，因为 Java 不允许自定义运算符重载)。

因此，它可能是出于教学的需要（尽管我认为这只是糟糕的教学），或者用于说明在 Java 中很难演示的原则。

【讨论】：

我认为相反的结构，如 "" + 我会让新手感到困惑。而且这对他们的余生来说都是一种糟糕的风格。

【解决方案16】：

表达式

"" + i

导致运行时i 的字符串转换。表达式的整体类型为String。 i 首先转换为Integer 对象（new Integer(i)），然后调用String.valueOf(Object obj)。所以相当于

"" + String.valueOf(new Integer(i));

显然，这比调用String.valueOf(new Integer(i)) 的性能稍差，后者会产生完全相同的结果。

""+i 的优点是打字更容易/更快，有些人可能会认为它更容易阅读。这不是code smell，因为它不表示任何更深层次的问题。

（参考：JLS 15.8.1）

【讨论】：

您的“等价”声明不等价。即使调用String.valueOf 需要装箱i（它不需要，因为有一个接受int 的重载），它也不会使用new Integer(i)，它会使用Integer.valueOf(i)。但它真的没有做任何这些。正如 SimonJ 的回答所指出的那样，它确实是 new StringBuilder().append("").append(i).toString()。 StringBuilder 有自己的逻辑将原始 int i 转换为 String。
关于代码异味的部分是正确的；代码气味在这里是错误的术语。所以我会取消反对票。
用 "" + i 似乎效率低下。建议使用简单的 Integer.toString 或 String.valueOf。见javadevnotes.com/java-integer-to-string-examples

【解决方案17】：

SimonJ 也大同小异。我真的不喜欢 ""+i 成语。如果您说 String.valueOf(i)，Java 会将整数转换为字符串并返回结果。如果你说 ""+i，Java 创建一个 StringBuilder 对象，将一个空字符串附加到它，将整数转换为字符串，将其附加到 StringBuilder，然后将 StringBuilder 转换为 String。这是很多额外的步骤。我想如果你在一个大项目中做一次，这没什么大不了的。但如果你一直这样做，你会让计算机做大量额外的工作，并创建所有这些额外的对象，然后必须清理这些对象。我不想对微优化狂热，但我也不想无谓地浪费。

【讨论】：

【解决方案18】：

这是可以接受的，但我从来没有写过这样的东西。我更喜欢这个：

String strI = Integer.toString(i);

【讨论】：

我更喜欢 String.valueOf 方法，因为您可以对任何类型使用完全相同的调用。
NumberFormatter 会是更好的方法
一个很好的答案，卡斯图里。我会将其发布为不仅仅是评论。
对不起我的无知，但这不会使用当前的文化吗？顺便说一句，我即将形成 .NET 背景。
对于整数，默认情况下不使用特定于文化的东西（根本没有小数或千位分隔符）。这就是NumberFormatter 的用途。您可以使用NumberFormat.getInstance(Locale.FRENCH) 等格式。

【解决方案19】：

我知道的另一种方式是来自Integer 类：

Integer.toString(int n);
Integer.toString(int n, int radix);

一个具体的例子（虽然我认为你不需要）：

String five = Integer.toString(5); // returns "5"

它也适用于其他原始类型，例如Double.toString。

See here for more details.

【讨论】：

【解决方案20】：

这不是一个好方法。

在进行int到string的转换时，应该使用：

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

【讨论】：

1.您要求空字符串； 2.你要求串联； 3. 由于您没有字符串，您最终会将您的 int 转换为字符串。 daridoo的解决方案避免了第一步。
在添加到 String strI 之前，int i 是否会被装箱到 Integer？
@KevinMeredith，不，它没有。你实际上是在调用StringBuilder.append(int)（并且StringBuilder 对所有原始类型都有一个append 方法）。