java - java.lang.String.concat 可以改进吗？

Question

我正在考虑向 Oracle Bug 数据库提交 RFE(增强请求)，这应该会显着提高字符串连接性能。但在我这样做之前，我想听听专家们对它是否有意义的评论。

这个想法是基于这样一个事实，即现有的 String.concat(String) 在 2 个字符串上的工作速度比 StringBuilder 快两倍。问题是没有连接 3 个或更多字符串的方法。外部方法无法做到这一点，因为 String.concat 使用包私有(private)构造函数 String(int offset, int count, char[] value)，它不复制 char 数组而是直接使用它。这确保了 String.concat 的高性能。在同一个包中的 StringBuilder 仍然不能使用这个构造函数，因为那样的话 String 的 char 数组将被暴露以供修改。

我建议在String中添加以下方法

public static String concat(String s1, String s2) 
public static String concat(String s1, String s2, String s3) 
public static String concat(String s1, String s2, String s3, String s4) 
public static String concat(String s1, String s2, String s3, String s4, String s5) 
public static String concat(String s1, String... array) 

注意:EnumSet.of 中使用了这种重载，以提高效率。

这是其中一种方法的实现，其他方法同理

public final class String {
    private final char value[];
    private final int count;
    private final int offset;

    String(int offset, int count, char value[]) {
        this.value = value;
        this.offset = offset;
        this.count = count;
    }

    public static String concat(String s1, String s2, String s3) {
        char buf[] = new char[s1.count + s2.count + s3.count];
        System.arraycopy(s1.value, s1.offset, buf, 0, s1.count);
        System.arraycopy(s2.value, s2.offset, buf, s1.count, s2.count);
        System.arraycopy(s3.value, s3.offset, buf, s1.count + s2.count, s3.count);
        return new String(0, buf.length, buf);
    }

另外，将这些方法添加到String后，Java编译器会针对

String s = s1 + s2 + s3;

将能够高效地构建

String s = String.concat(s1, s2, s3); 

代替现在的低效

String s = (new StringBuilder(String.valueOf(s1))).append(s2).append(s3).toString();

更新 性能测试。我在我的笔记本 Intel Celeron 925 上运行它，连接 3 个字符串，我的 String2 类完全模拟它在真实 java.lang.String 中的样子。选择字符串长度以便将 StringBuilder 置于最不利的条件下，即当它需要在每次追加时扩展其内部缓冲区容量时，而 concat 始终只创建一次 char[]。

public class String2 {
    private final char value[];
    private final int count;
    private final int offset;

    String2(String s) {
        value = s.toCharArray();
        offset = 0;
        count = value.length;
    }

    String2(int offset, int count, char value[]) {
        this.value = value;
        this.offset = offset;
        this.count = count;
    }

    public static String2 concat(String2 s1, String2 s2, String2 s3) {
        char buf[] = new char[s1.count + s2.count + s3.count];
        System.arraycopy(s1.value, s1.offset, buf, 0, s1.count);
        System.arraycopy(s2.value, s2.offset, buf, s1.count, s2.count);
        System.arraycopy(s3.value, s3.offset, buf, s1.count + s2.count, s3.count);
        return new String2(0, buf.length, buf);
    }

    public static void main(String[] args) {
        String s1 = "1";
        String s2 = "11111111111111111";
        String s3 = "11111111111111111111111111111111111111111";
        String2 s21 = new String2(s1);
        String2 s22 = new String2(s2);
        String2 s23 = new String2(s3);
        long t0 = System.currentTimeMillis();
        for (int i = 0; i < 1000000; i++) {
            String2 s = String2.concat(s21, s22, s23);
//          String s = new StringBuilder(s1).append(s2).append(s3).toString();
        }
        System.out.println(System.currentTimeMillis() - t0);
    }
}

在 1,000,000 次迭代中，结果是:

version 1 = ~200 ms
version 2 = ~400 ms

Answer 1

事实是，单个字符串连接表达式的性能很重要的用例并不常见。在大多数情况下，性能受字符串连接的限制，它发生在一个循环中，逐步构建最终产品，在这种情况下，可变 StringBuilder 显然是赢家。这就是为什么我看不到通过干预基本的 String 类来优化少数关注的提案的前景。但无论如何，就比较性能而言，您的方法确实具有显着优势:

import com.google.caliper.Runner;
import com.google.caliper.SimpleBenchmark;

public class Performance extends SimpleBenchmark
{
  final Random rnd = new Random();
  final String as1 = "aoeuaoeuaoeu", as2 = "snthsnthnsth", as3 = "3453409345";
  final char[] c1 = as1.toCharArray(), c2 = as2.toCharArray(), c3 = as3.toCharArray();

  public static char[] concat(char[] s1, char[] s2, char[] s3) {
    char buf[] = new char[s1.length + s2.length + s3.length];
    System.arraycopy(s1, 0, buf, 0, s1.length);
    System.arraycopy(s2, 0, buf, s1.length, s2.length);
    System.arraycopy(s3, 0, buf, s1.length + s2.length, s3.length);
    return buf;
  }

  public static String build(String s1, String s2, String s3) {
    final StringBuilder b = new StringBuilder(s1.length() + s2.length() + s3.length());
    b.append(s1).append(s2).append(s3);
    return b.toString();
  }

  public static String plus(String s1, String s2, String s3) {
    return s1 + s2 + s3;
  }

  public int timeConcat(int reps) {
    int tot = rnd.nextInt();
    for (int i = 0; i < reps; i++) tot += concat(c1, c2, c3).length;
    return tot;
  }

  public int timeBuild(int reps) {
    int tot = rnd.nextInt();
    for (int i = 0; i < reps; i++) tot += build(as1, as2, as3).length();
    return tot;
  }

  public int timePlus(int reps) {
    int tot = rnd.nextInt();
    for (int i = 0; i < reps; i++) tot += plus(as1, as2, as3).length();
    return tot;
  }

  public static void main(String... args) {
    Runner.main(Performance.class, args);
  }
}

结果:

 0% Scenario{vm=java, trial=0, benchmark=Concat} 65.81 ns; σ=2.56 ns @ 10 trials
33% Scenario{vm=java, trial=0, benchmark=Build} 102.94 ns; σ=2.27 ns @ 10 trials
67% Scenario{vm=java, trial=0, benchmark=Plus} 160.14 ns; σ=2.94 ns @ 10 trials

benchmark    ns linear runtime
   Concat  65.8 ============
    Build 102.9 ===================
     Plus 160.1 ==============================