当前位置：文江博客话题详情

Java 连接以构建字符串或格式

发布于 2024-12-10 00:02:36 字数 443 浏览 1 评论 0原文

我现在正在使用java编写一个MUD（基于文本的游戏）。 MUD 的主要方面之一是格式化字符串并将其发送回用户。如何最好地实现这一点？

假设我想发送以下字符串：

您对某人说“你好！” - 其中“某人”、“说”和“你好！”都是变量。哪个性能最好？

"You " + verb + " to " + user + " \"" + text + "\""

或

String.format("You %1$s to %2$s \ “%3$s\”“，动词，用户，文本）

或其他选项？

我不确定最终哪个会更容易使用（这很重要，因为它会无处不在），但我现在正在考虑它，因为与 + 连接有点令人困惑一些较大的线路。我觉得在这种情况下使用 StringBuilder 只会使其可读性更差。

这里有什么建议吗？

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

夜访吸血鬼 2024-12-17 00:02:36

如果字符串是使用单个串联表达式构建的；例如

String s = "You " + verb + " to " + user + " \"" + text + "\"";

，这或多或少相当于更冗长的内容：

StringBuilder sb = new StringBuilder();
sb.append("You");
sb.append(verb);
sb.append(" to ");
sb.append(user);
sb.append(" \"");
sb.append(text );
sb.append('"');
String s = sb.toString();

事实上，经典的Java编译器会将前者编译为后者......几乎。在 Java 9 中，他们实现了 JEP 280，它替换了字节码中构造函数和方法调用的顺序使用单个 invokedynamic 字节码。然后运行时系统会优化此¹。

当您开始创建中间字符串或使用 += 等构建字符串时，就会出现效率问题。在某些情况下，使用显式 StringBuilder 可以²提高效率，因为您可以减少复制量。

现在，当您使用 String.format() 时，它应该在幕后使用 StringBuilder 。但是，format 还必须在每次调用时解析格式字符串，如果您以最佳方式构建字符串，则不会有这种开销。

话虽如此，我的建议是以最具可读性的方式编写代码。如果分析告诉您这是一个真正的性能问题，则只需担心构建字符串的最有效方法。（现在，您正在花时间思考解决性能问题的方法，这可能是无关紧要或无关紧要的。）

另一个答案提到使用格式字符串可以简化对多种语言的支持。这是事实，尽管您在复数、性别等方面可以做的事情是有限的。

^{1 - 因此，对于 Java 9 或更高版本，上面示例中的手动优化实际上可能会产生负面后果。但这是您每次进行微优化时都要承担的风险。
2 - 分析和预测这种情况何时发生通常是很困难的。}

If the strings are built using a single concatenation expression; e.g.

String s = "You " + verb + " to " + user + " \"" + text + "\"";

then this is more or less equivalent to the more long winded:

StringBuilder sb = new StringBuilder();
sb.append("You");
sb.append(verb);
sb.append(" to ");
sb.append(user);
sb.append(" \"");
sb.append(text );
sb.append('"');
String s = sb.toString();

In fact, a classic Java compiler will compile the former into the latter ... almost. In Java 9, they implemented JEP 280 which replaces the sequence of constructor and method calls in the bytecodes with a single invokedynamic bytecode. The runtime system then optimizes this¹.

The efficiency issues arise when you start creating intermediate strings, or building strings using += and so on. In some cases, using an explicit StringBuilder can be² more efficient because you are reduce the amount of copying.

Now when you use String.format(), it should be using a StringBuilder under the hood. However, format also has to parse the format String each time you make the call, and that is an overhead you don't have if you do the string building optimally.

Having said this, My Advice would be to write the code in the way that is most readable. Only worry about the most efficient way to build strings if profiling tells you that this is a real performance concern. (Right now, you are spending time thinking about ways to address a performance issue that may turn out to be insignificant or irrelevant.)

Another answer mentions that using a format string may simplify support for multiple languages. This is true, though there are limits as to what you can do with respect to such things as plurals, genders, and so on.

^{1 - As a consequence, hand optimization as per the example above might actually have negative consequences, for Java 9 or later. But this is a risk you take whenever you micro-optimize.
2 - Analyzing and predicting when this happens in general is difficult.}

回复收藏 0 原文

爱你是孤单的心事 2024-12-17 00:02:36

我认为使用 + 连接比使用 String.format 更具可读性。

当您需要格式化数字和日期时，String.format 非常有用。

回复收藏 0 原文

云归处 2024-12-17 00:02:36

与 plus 连接，编译器可以以性能方式转换代码。对于字符串格式我不知道。

我更喜欢与 plus 并置，我认为这样更容易理解。

回复收藏 0 原文

素罗衫 2024-12-17 00:02:36

保持简单的关键是永远不要看它。我的意思是：

Joiner join = Joiner.on(" ");

public void constructMessage(StringBuilder sb, Iterable<String> words) {
  join.appendTo(sb, words);
}

我使用 Guava Joiner 类来使可读性不再是问题。还有什么比“加入”更清楚的呢？所有与串联有关的令人讨厌的部分都被很好地隐藏起来。通过使用 Iterable，我可以将此方法用于各种数据结构，列表是最明显的。

下面是一个使用 Guava ImmutableList 的调用示例（它比常规列表更有效，因为任何修改列表的方法都会抛出异常，并且正确地表示了一个事实：constructMessage() 无法更改单词列表，只需使用它）：

StringBuilder outputMessage = new StringBuilder();
constructMessage(outputMessage, 
         new ImmutableList.Builder<String>()
            .add("You", verb, "to", user, "\"", text, "\"")
            .build());

The key to keeping it simple is to never look at it. Here is what I mean:

Joiner join = Joiner.on(" ");

public void constructMessage(StringBuilder sb, Iterable<String> words) {
  join.appendTo(sb, words);
}

I'm using the Guava Joiner class to make readability a non-issue. What could be clearer than "join"? All the nasty bits regarding concatenation are nicely hidden away. By using Iterable, I can use this method with all sorts of data structures, Lists being the most obvious.

Here is an example of a call using a Guava ImmutableList (which is more efficient than a regular list, since any methods that modify the list just throw exceptions, and correctly represents the fact that constructMessage() cannot change the list of words, just consume it):

StringBuilder outputMessage = new StringBuilder();
constructMessage(outputMessage, 
         new ImmutableList.Builder<String>()
            .add("You", verb, "to", user, "\"", text, "\"")
            .build());

回复收藏 0 原文