用给定字符序列交错 java 字符串的最佳方法是什么。交错间隔应该是可变的。

例子:

String s = " .... 0000000000000 ..."; // length random
String b = interleave(s, 3, "-");

结果:

... 000-000-000-000-000 ...

另一个例子:

String s = " .... we all we all we all ...";
String b = interleave(s, 7, "rock ");

结果:

... we all rock we all rock we all rock ...

如果字符串长度不是交错距离的倍数，该函数也应该有效。 有什么建议么？是否有(再次)“公地”方式来做到这一点？

最佳答案

这是一个非常简单且可读性很强的实现(我在下面的基准测试中将其称为 StringBuilder):

public static String interleave(String s, int interval, String separator)
{
    StringBuilder sb = new StringBuilder(s);
    for (int pos = (s.length()-1) / interval; pos > 0; pos--)
    {
        sb.insert(pos * interval, separator);
    }
    return sb.toString();
}

如果您关心简单的 StringBuilder 实现的效率，那么这个实现可能更适合您的需求(我在下面的基准测试中称它为 Arrays):

public static String interleave(String string, int interval, String separator)
{
    char[] src = string.toCharArray();
    char[] sep = separator.toCharArray();
    int count = (src.length-1)/interval;
    char[] dst = new char[src.length + count * sep.length];
    int srcpos = 0, dstpos = 0;
    for (int i = 0; i < count; i++)
    {
        System.arraycopy(src, srcpos, dst, dstpos, interval);
        srcpos += interval;
        dstpos += interval;
        System.arraycopy(sep, 0, dst, dstpos, sep.length);
        dstpos += sep.length;
    }
    if (dstpos < dst.length)
    {
        System.arraycopy(src, srcpos, dst, dstpos, dst.length - dstpos);
    }
    return String.valueOf(dst);
}

注意:我可能只会在 J2ME 环境下使用这种实现，但在大字符串上它应该会非常快。虽然可读性很差......

当然总是有 RegExp 做事的方式，在你爬过编译 RegExp 本身不再是一个问题的长度之后，它的速度非常快(你不能预编译 RegExp，因为它是在根据间隔飞行，感谢 Rubens Farias 指出这一点，但我自己却错过了)。所以就这样了(我在下面的基准测试中称之为 RegExp):

public static String interleave(String string, int interval, String separator)
{
    return string.replaceAll("(.{"+interval+"})", "$1"+Matcher.quoteReplacement(separator));
}

注意:如果字符串的长度是间隔的倍数(而其他实现则不会)，此实现会在末尾插入分隔符。我不喜欢 RegExp，因为它们不可读而且速度也不太快。哦，如果分隔符包含“$1”甚至更糟——如果它来自用户，你很容易忘记“quoteReplacement”部分并给自己带来大麻烦。

基准

此时我已经做了一些基准测试，所以第一个字符串长度为 100000 的实现需要 0.002643 秒，第二个 - 0.000010，第三个 - 0.000071，但一切都取决于字符串长度。

Length    StringBuilder   Arrays       RegExp
  10000     0.000012     0.000001     0.000054
 100000     0.002643     0.000010     0.000071
1000000     0.315413     0.000026     0.000199

这绝不是一个严肃的基准测试，但它仍然显示了所涉及算法的趋势和复杂性。

注意:尽管使用这些想法很有趣，但我们仍在谈论处理小于 1M 的字符串时亚秒级改进 .因此，如果您只处理大小不超过 1K 的字符串(分别为 0 毫秒和 0 毫秒)，那么采用哪种方式并不重要。最重要的是它应该是可读的、直截了当的并且不需要花费太多时间来编写，因为我相信你有更重要的问题需要解决，除非你正在编写一个通用库供每个人在最奇怪的情况下使用。请记住 - 您的时间比 CPU 时间更宝贵。

左右对齐交错

我将采用Arrays 实现，因为它似乎最容易改变:

public static String interleave(String string, int interval, String separator, boolean fromRight)
{
    char[] src = string.toCharArray();
    char[] sep = separator.toCharArray();
    int count = (src.length-1)/interval;
    char[] dst = new char[src.length + count * sep.length];
    int srcpos = 0, dstpos = 0;
    if (fromRight)
    {
        srcpos = dstpos = src.length - count * interval;
        if (srcpos > 0) System.arraycopy(src, 0, dst, 0, srcpos);
        if (count > 0)
        {
            System.arraycopy(sep, 0, dst, dstpos, sep.length);
            dstpos += sep.length;
            count--;
        }
    }
    for (int i = 0; i < count; i++)
    {
        System.arraycopy(src, srcpos, dst, dstpos, interval);
        srcpos += interval;
        dstpos += interval;
        System.arraycopy(sep, 0, dst, dstpos, sep.length);
        dstpos += sep.length;
    }
    if (dstpos < dst.length)
    {
        System.arraycopy(src, srcpos, dst, dstpos, dst.length - dstpos);
    }
    return String.valueOf(dst);
}

关于java - 如何将字符串与字符序列交错，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/1679976/