对于最多 9-10 步的字符串连接，是否有比 StringBuilder 更快的方法？

Question

我有这段代码来连接一些数组元素：

StringBuilder sb = new StringBuilder();
private RatedMessage joinMessage(int step, boolean isresult) {
        sb.delete(0, sb.length());
        RatedMessage rm;
        for (int i = 0; i <= step; i++) {
            if (mStack[i] == null)
                continue;
            rm = mStack[i].getCurrentMsg();// msg is built upfront, this just returns, it's a getter method call
            if (rm == null || rm.msg.length() == 0)
                continue;
            if (sb.length() != 0) {
                sb.append(", ");
            }
            sb.append(rm.msg);
        }
        rm.msg=sb.toString();
        return rm;
    }

重要的是，数组最多可容纳 10 个项目，因此数量并不多。

我的跟踪输出告诉我这个方法被调用了 18864 次，16% 的运行时间花费在这个方法上。我可以进一步优化吗？

Answer 1

首先，我不会重用 StringBuilder 并始终创建新实例。这肯定会更快，因为它允许 GC 使用年轻代堆区域。

允许消除至少一个 if 语句的另一个小技巧是重写代码，如下所示：

    String separator = "";
    for (int i = 0; i <= step; i++) {
        ...
        sb.append(separator);
        sb.append(rm.msg);
        separator = ", ";
    }

Answer 2

一些想法：

1）您是否使用估计的最大容量初始化 StringBuilder ？这样可以节省内部数组重新分配&所花费的时间。复制。

2）也许您可以在循环中附加一个尾随逗号，并避免循环内字符串长度的条件。相反，请在方法末尾添加一个条件，并根据需要删除结尾的逗号。

Answer 3

您可以进行以下更改（仅显示差异）：

    String separator = "";
    for (int i = 0; i <= step; i++) {
    // ...
        sb.append(separator).append(rm.msg);
        separator = ", ";
    }

它会消除 9 次额外的 if，但代价是添加一次空字符串。在决定保留此更改之前，您应该衡量它是否对您正在使用的数据有帮助:-)

Answer 4

如果你的函数应该连接数组元素，为什么你要传递所有这些疯狂的值和未使用的参数？

private string joinMessage( string[] myArray)
{
  StringBuilder sbr = new StringBuilder();
  for(int i = 0; i < myArray.Length; i++)
  {
     if(!string.IsNullOrEmpty(myArray[i])
     {
       sbr.Append(myArray[i]);
       sbr.Append(",")
     }
  }
  return sbr.ToString();
}

Answer 5

首先遍历堆栈中的每个元素，计算所有字符串长度的总和。

然后，您可以使用

sb.ensureCapacity(totalEndLength);

字符串构建器，就像数组列表一样工作，因此您可能会使用大部分附加内容来重建该数组。

Answer 6

一点小小的优化...将逗号测试放在循环之外。

private RatedMessage joinMessage(int step, boolean isresult) {
    sb.delete(0, sb.length());
    for (int i = 0; i <= step; i++) {
        if (mStack[i] == null)
            continue;
        rm = mStack[i].getCurrentMsg();
        if (rm == null || rm.msg.length() == 0)
            continue;
        sb.append(rm.msg).append(", ");
    }
    if (sb.length() > 2) {
        sb.delete(sb.length() - 2, 2);
    }
    return sb.toString();
}

其他建议是：

• 确保在构造 StringBuilder 时将其初始长度设置为合适的值
• 我不确定其余代码的上下文，但也许您可以预先确保 mStack[i] 将不为 null，并且 mStack[i].getCurrentMessage() 不为 null 或空 - 这将允许您在循环之外获取更多 if 语句。

Answer 7

如果你的 mStack 是一个集合而不是数组，你可以只执行 mStack.toString() ，它将打印数组的可读字符串。这可能比自己编写更容易。

Answer 8

此方法中的 16% 运行时间包括还是排除调用的方法？如果 getCurrentMsg() 调用创建大量对象，则它可能是一个隐藏的问题。

我建议从堆栈中取出所有需要的字符串，然后

除此之外，

使用 。 org/lang/api-2.5/org/apache/commons/lang/StringUtils.html#join" rel="nofollow noreferrer">Apache 公共库。尝试依靠经过测试的代码来完成如此低级的事情，而不是每隔一天自己优化它。最终，这将为您带来更好的优化结果，因为您将能够专注于大局（即软件的整体设计）。

Answer 9

有一个带有字符串表示形式的 mStack 数组的单独副本，默认情况下用空字符串初始化，因此您的循环将是：

String [] mStackCopy = new String[]{"","","","","","","","","","",};
// or mstackCopy = new String[mStack.length]; 
// for( int i = 0 ; i < mStackCopy.lenght ; i++ ) { mStack[i] = "" }

另外，创建具有足够容量的 StringBuilder：

StringBuilder sb = new StringBuilder( 10000 );// 10k chars or whatever makes sense.

因此，当您需要创建您只需简单地发送消息：

for (int i = 0; i <= step; i++) {
   sb.append( mStackCopy[i] );
}

并且空部分不会引起问题，因为它们已经是空白的：

您甚至可以对它进行硬编码：

 sb.append( mStackCopy[0]);
 sb.append( mStackCopy[1]);
 sb.append( mStackCopy[2]);
 sb.append( mStackCopy[3]);
 sb.append( mStackCopy[4]);
 sb.append( mStackCopy[5]);
 sb.append( mStackCopy[6]);
 sb.append( mStackCopy[7]);
 sb.append( mStackCopy[8]);
 sb.append( mStackCopy[9]);

但这肯定会在未来造成更多的痛苦而不是缓解。

当您向 mStack 添加内容时：

MStack item = new MStack();
item.setCurrentMessage("Some message");

 .... 

只需复制消息并附加“，”即可。

  addToMStack(int position,  MStackItem item ) {
    mStack[position] = item;
    mStackCopy[position] = item.getCurrentMessage() + ", ";
}

根据空值的出现（如果它很低），您可以捕获它们，

  addToMStack(int position,  MStackItem item ) {
    if( item == null ) { return; }
    mStack[position] = item;
    try {
        mStackCopy[position] = item.getCurrentMessage() + ", ";
    } catch( NullPointerException npe ){}
 }

这可怕

或者验证它：

  addToMStack(int position,  MStackItem item ) {
    if( item == null ) { return; }
    mStack[position] = item;
    mStackCopy[position] = item.getCurrentMessage() + ", ";
 }

我很确定您的方法正在做一些您没有向我们展示的其他事情。大概原因就在那里。

而且，如果 100% 是 1 秒，那么 16% 也不算太糟糕。

Answer 10

有时没有什么可以优化的。我认为这是这样的案例之一。您可以尝试删除一两条指令，但原则上您不会更快地得到它。

我认为唯一需要优化的是考虑为什么你调用它 18864 次以及是否可以完全避免其中一些调用。也许有些是不需要的，或者在某些情况下您可以缓存结果。

Answer 11

使用 Apache Commons Lang 中的 StringBuilder + StringUtils。使用分隔符循环遍历字符串并进行 chomping 就是 StringUtils 的全部内容！

private RatedMessage joinMessage(int step, boolean isresult) {
        StringBuilder builder = new StringBuilder();
        for (int i = 0; i <= step; i++) {
            WhateverTypeIsFromMStackVariable stackVariable = mStack[i];
            String message = getMessage(stackVariable);
            if(StringUtils.isNotEmpty(message)) {
                builder.append(message).append(", ");
            }
        }
        RatedMessage rm = new RatedMessage();
        rm.msg = StringUtils.chomp(builder.toString(), ", ");
        return rm;
    }

private static String getMessage(WhateverTypeIsFromMStackVariable stackVariable) {
    if(stackVariable != null) {
        RatedMessage message = stackVariable.getCurrentMsg();
        if(message != null) {
            return message.msg;
        }
     }
     return null;
 }

Apache Commons Lang 位于：http://commons.apache.org/lang/