blocks|key|2952396|text|还有第三个-+String.valueOf(..)+(它称为Wrapper.toString(..)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2952397|实际上，编译器在这些地方添加了Wrapper.toString(..)，所以它在字节码方面是相同的。但""%2Bx更丑陋。|2952398|entityMap^0|7|I|U|K|0|F|K|1F|4|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|I|$]]

There's a third one - <code>String.valueOf(..)</code> (which calls <code>Wrapper.toString(..)</code>

Actually the compiler adds <code>Wrapper.toString(..)</code> in these places, so it's the same in terms of bytecode. But <code>""+x</code> is uglier.

blocks|key|2952436|text|我会用|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2952437|String.valueOf(...)|code-block|syntax|javascript|2952438|您可以对所有类型使用相同的代码，但不需要丑陋且毫无意义的字符串连接。|2952439|请注意，它还准确地说明了您想要的内容-与给定原始值相对应的字符串值。与""+%2B+x方法相比，在这种方法中，即使不打算连接任何内容，也要应用字符串连接，并且空字符串与您无关。(它可能更昂贵，但我更关心的是可读性，而不是性能。)|offset|length|style|CODE|2952440|entityMap^0|0|0|0|Z|6|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|T|8|@$K|U|L|V|M|N]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

I would use

<pre><code>String.valueOf(...)
</code></pre>

You can use the same code for all types, but without the hideous and pointless string concatenation.

Note that it also says exactly what you want - the string value corresponding to the given primitive value. Compare that with the <code>"" + x</code> approach, where you're applying string concatenation even though you have no intention of concatenating anything, and the empty string is irrelevant to you. (It's probably more expensive, but it's the readability hit that I mind more than performance.)

blocks|key|2952464|text|添加双引号是一种很糟糕的方式，尤其是在可读性方面。我会考虑使用一些Apache+util类进行转换，或者编写您自己的实用方法来完成这类工作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2952465|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Appending a double quote is a bad way of doing it especially for readability. I would consider using some of the Apache util classes for conversion or writing your own utility methods for doing this type of stuff.

blocks|key|2952503|text|字符串连接方式创建了一个额外的对象(然后得到GCed)，这就是为什么它被认为是“较差”的原因之一。此外，它更棘手，可读性更差，正如Jon+Skeet指出的那样，这通常是一个更大的考虑因素。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2952504|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

The string-concatenation way creates an extra object (that then gets GCed), that is one reason why it's considered "poorer". Plus it is trickier and less readable, which as Jon Skeet points out is usually a bigger consideration.

blocks|key|2952531|text|我还将使用String.valueOf()方法，它实际上使用了原始类型的包装器对象，并为您调用toString()方法：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2952532|例如，在String类中：|2952533|public+static+String+valueOf(int+i)+{
++++++++return+Integer.toString(i,+10);
++++}|code-block|syntax|javascript|2952534|entityMap^0|5|G|1B|A|0|4|6|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|T|8|@$9|U|A|V|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|W|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|N|$]]

I would also use <code>String.valueOf()</code> method, which, in effect, uses the primitive type's Wrapper object and calls the <code>toString()</code> method for you:

Example, in the <code>String</code> class:

<pre><code>public static String valueOf(int i) {
 return Integer.toString(i, 10);
 }
</code></pre>

blocks|key|261702|text|String+s+=+""+%2B+4;|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|261703|被编译成以下代码：|unstyled|261704|StringBuffer+_$_helper+=+new+StringBuffer("");
_$_helper.append(Integer.toString(4));
String+s+=+_$_helper.toString();|261705|显然，这是相当浪费的。请记住，在后台，如果您使用%2B与字符串的关联，则编译器始终使用StringBuffers|261706|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$B|C]]|$1|I|3|J|5|F|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|F|7|Q|8|@]|9|@]|A|$]]]|L|$]]

<pre><code>String s = "" + 4;
</code></pre>

Is compiled to this code:

<pre><code>StringBuffer _$_helper = new StringBuffer("");
_$_helper.append(Integer.toString(4));
String s = _$_helper.toString();
</code></pre>

Obviously that is pretty wastefull.
Keep in mind that behind the scene the compiler is always using StringBuffers if you use + in asociation with String's

blocks|key|261713|text|最好是你知道你想要转换成字符串的参数的类型，并且让编译器知道该类型。这简化了操作，也简化了周期。当您遵循append方法时，您将把类型决定留给编译器，同时也增加了让编译器执行相同操作的代码行。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|261714|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

It is always better that you're aware of the type of argument you are trying to convert to string and also make compiler aware of the type. That simplifies the operation as well as the cycles. When you follow the append method, you are leaving the type decision to the compiler and also increasing the code lines for the compiler to do the same.

blocks|key|3166362|text|我认为答案实际上取决于您试图转换的内容，以及转换的目的，但一般来说，我不太喜欢进行裸体转换，因为在大多数情况下，转换为字符串是为了记录日志或其他人类可读性的目的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3166363|MessageFormat.format("The+value+of+XYZ+object+is+{0}",+object);|code-block|syntax|javascript|3166364|这提供了良好的可读性和对输出格式的细粒度控制，重要的是，可以通过用消息包引用替换字符串来实现国际化。|3166365|需要指出的是，这也避免了调用object.toString()时可能出现的NPE问题？|3166366|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I think the answer really depends on what you're trying to convert, and for what purpose, but in general, I'm not a big fan of doing naked conversions, because in most instances, conversions to a string are for logging, or other human readability purposes.

<pre><code>MessageFormat.format("The value of XYZ object is {0}", object);
</code></pre>

This gives good readability, fine grained control over the formatting of the output, and importantly, it can be internationalized by replacing the string with a message bundle reference.

Need I mention this also avoids the possible NPE problem of calling object.toString()?

I can convert an integer into string using

<pre><code>String s = "" + 4; // correct, but poor style
or
String u = Integer.toString(4); // this is good
</code></pre>

I can convert a double into string using

<pre><code>String s = "" + 4.5; // correct, but poor style
or
String u = Double.toString(4.5); // this is good
</code></pre>

I can use <code>String s = "" + data</code>approach to convert either an int or double into String. While If I wants to use the other approach using <code>toString()</code> I have to use the Wrapper class of each data type. Then why in <a href="http://ww0.java3.datastructures.net/contents/supplement2.pdf" rel="noreferrer">some books</a> it is mentioned that the first approach is poor one while the second one is the better. Which one is the better approach and why?

What is the better approach to convert primitive data type into String

编译器

我可以使用以下命令将整数转换为字符串String s = "" + 4; // correct, but poor styleorString u = Integer.toString(4); // this is good我可以使用以下命令将双精度值转换为字符串String s = "" + 4.5; // corr...

问将原始数据类型转换为字符串的更好方法是什么
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问将原始数据类型转换为字符串的更好方法是什么EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问将原始数据类型转换为字符串的更好方法是什么
EN