Question

我曾经认为String.replace比String.replaceAll更快，因为后者使用Pattern正则表达式而前者不使用。但事实上，在性能或实施方面没有显着差异。就是这样：

public String replace(CharSequence target, CharSequence replacement) {
    return Pattern.compile(target.toString(), Pattern.LITERAL).matcher(
        this).replaceAll(Matcher.quoteReplacement(replacement.toString()));
}

这里有什么需要使用Pattern？我写了一个非正则表达式替换版本

static String replace(String s, String target, String replacement) {
    StringBuilder sb = new StringBuilder(s);
    for (int i = 0; (i = sb.indexOf(target, i)) != -1; i += replacement.length()) {
        sb.replace(i, i + target.length(), replacement);
    }
    return sb.toString();
}

并比较表现

    public static void main(String args[]) throws Exception {
        String s1 = "11112233211";
        for (;;) {
            long t0 = System.currentTimeMillis();
            for (int i = 0; i < 1000000; i++) {
//              String s2 = s1.replace("11", "xxx");
                 String s2 = replace(s1, "11", "22");
            }
            System.out.println(System.currentTimeMillis() - t0);
        }
    }

基准：我的版本 - 400ms; JDK版本 - 1700ms。

我的测试是错误的还是String.replace真的效率不高？

Answer 1

让你知道String.replace是多么低效

来自Java 7更新11的源代码。

public String replace(CharSequence target, CharSequence replacement) {
    return Pattern.compile(target.toString(), Pattern.LITERAL).matcher(
        this).replaceAll(Matcher.quoteReplacement(replacement.toString()));
}

AFAIK，使用Pattern和Matcher.quiteReplacement等是一种明确而非有效的尝试。我怀疑它可以追溯到许多内部库是在没有性能考虑的情况下编写的。

恕我直言Java 7已经看到许多内部库提高了性能，特别是减少了不必要的对象创建。这种方法显然是一种改进的选择。

您可以通过执行一次复制来提高性能，而不是尝试插入现有的StringBuilder。

static String replace2(String s, String target, String replacement) {
    StringBuilder sb = null;
    int start = 0;
    for (int i; (i = s.indexOf(target, start)) != -1; ) {
        if (sb == null) sb = new StringBuilder();
        sb.append(s, start, i);
        sb.append(replacement);
        start = i + target.length();
    }
    if (sb == null) return s;
    sb.append(s, start, s.length());
    return sb.toString();
}

public static void main(String... ignored) {
    String s1 = "11112233211";
    for (; ; ) {
        timeReplace(s1);
        timeReplace2(s1);
        timeStringReplaceRefactored(s1);
        timeStringReplace(s1);
    }
}

private static void timeStringReplace(String s1) {
    long start0 = System.currentTimeMillis();
    for (int i = 0; i < 1000000; i++) {
        String s2 = s1.replace("11", "xxx");
        if (s2.length() <= s1.length()) throw new AssertionError();
    }
    System.out.printf("String.replace %,d ns avg%n", System.currentTimeMillis() - start0);
}

private static void timeStringReplaceRefactored(String s1) {
    long start0 = System.currentTimeMillis();
    Pattern compile = Pattern.compile("11", Pattern.LITERAL);
    String xxx = Matcher.quoteReplacement("xxx");
    for (int i = 0; i < 1000000; i++) {
        String s2 = compile.matcher(s1).replaceAll(xxx);
        if (s2.length() <= s1.length()) throw new AssertionError();
    }
    System.out.printf("String.replace %,d ns avg (Refactored)%n", System.currentTimeMillis() - start0);
}
private static void timeReplace(String s1) {
    long start0 = System.currentTimeMillis();
    for (int i = 0; i < 1000000; i++) {
        String s2 = replace(s1, "11", "xxx");
        if (s2.length() <= s1.length()) throw new AssertionError();
    }
    System.out.printf("Replace %,d ns avg%n", System.currentTimeMillis() - start0);
}

private static void timeReplace2(String s1) {
    long start0 = System.currentTimeMillis();
    for (int i = 0; i < 1000000; i++) {
        String s2 = replace2(s1, "11", "xxx");
        if (s2.length() <= s1.length()) throw new AssertionError();
    }
    System.out.printf("My replace %,d ns avg%n", System.currentTimeMillis() - start0);
}

static String replace(String s, String target, String replacement) {
    StringBuilder sb = new StringBuilder(s);
    for (int i = 0; (i = sb.indexOf(target, i)) != -1; i += replacement.length()) {
        sb.replace(i, i + target.length(), replacement);
    }
    return sb.toString();
}

打印

Replace 177 ns avg
My replace 108 ns avg
String.replace 436 ns avg (Refactored)
String.replace 598 ns avg

捕捉模式并替换文本有一点帮助，但不如使用自定义例程进行替换。

Answer 2

比较两种解决方案时有一个有趣的方面，至少在我的机器上。当涉及到更大的字符串时，内置版本可以更好地扩展。给出一个稍微修改过的测试版本：

for (int i = 0; i < 10; i++) {
    s1 = s1 + s1;
    long t0 = call1(s1); // your implementation
    long t1 = call2(s1); // 1.7_07 Oracle
    long delta = t0 - t1;

    System.out.println(
      String.format("Iteration %s, string length %s, call1 %s, call2 %s, delta %s", i, s1.length(), t0, t1, delta));

    try {
        Thread.sleep(200);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

通过在每次调用时将字符串长度加倍，在迭代3或4之后已达到收支平衡：

Iteration 0, string length 22, call1 450, call2 1715, delta -1265
Iteration 1, string length 44, call1 1048, call2 2152, delta -1104
Iteration 2, string length 88, call1 2695, call2 4024, delta -1329
Iteration 3, string length 176, call1 7737, call2 7574, delta 163
Iteration 4, string length 352, call1 24662, call2 15560, delta 9102

参考call1和call2的两个实现：

static long call1(String s) {
    long t0 = System.currentTimeMillis();
    for (int i = 0; i < 1000000; i++) {
        String s2 = replace(s, "11", "22");
    }
    return System.currentTimeMillis() - t0;
}

static long call2(String s) {
    long t0 = System.currentTimeMillis();
    for (int i = 0; i < 1000000; i++) {
        String s2 = s.replace("11", "xxx");
    }
    return System.currentTimeMillis() - t0;
}

Answer 3

字符串替换和替换所有方法没有效率或时间的差异都采取n操作来替换charecter下面的代码可能会帮助你如何在java中使用字符串替换方法工作你可以在你的日食中结帐

package com.jav.exec;

public class replace {

    static String s1="This the India the india the nation";

    public static String replace(String s2,String s3)
    {
        int counter=0;
        int count=s3.length()-1;
        int count1=0;
        char[] ca1=s1.toCharArray();
        char[] ca2=s2.toCharArray();
        char[] ca3=s3.toCharArray();

        for(int f1=0;f1<ca1.length;f1++)//finding the number of occurances
        {
            if(ca1[f1]==ca2[counter])//increasing counter if charecters matches
            {
                counter++;

                if(counter==s2.length())//if consecutive charecters makes count equal to replacing string
                {
                    count1++;//increasing the count if consecutive charecters matches the striing
                    counter=0;//making counter 0 for next occurence
                }
            }
            else
            {
                counter=0;//making counter 0 if occurence less than the string 
            }
        }

        char[] ca4=new char[ca1.length+(count1*ca3.length)-(count1*ca2.length)];
        //creating new sized array for storing values
        counter=0;
        count=s3.length()-1;
        count1=0;
        int count2=0;

        for(int f=0;f<ca4.length;f++)
        {
            ca4[f]=ca1[count2];//storing the values into the new array of original long array
            //increasing the count  
            if(ca1[count2]==ca2[counter])//if charecters matches replacing array charecters
            {
                counter++;
                if(counter==ca2.length)//if counter is equal to length of replacing array
                {
                    f=f+ca3.length-ca2.length;//increasing the count of f
                    for(int f1=0;f1<ca3.length;f1++)//storing replaced array charecters to new array
                    {
                        ca4[f-count]=ca3[count1];
                        count1++;
                        count--;
                    }
                    counter=0;//redeclaring variables to their inital values for next replacement
                    count1=0;
                    count=s3.length()-1;
                }
            }

            else
            {   
                while(counter>0)
                {   
                    ca4[f-counter]=ca1[count2-counter];
                    counter--;
                }
            }
            count2++;
        }
        return new String(ca4);
    }

    public static void main(String[] args)
    {
        System.out.println(replace("the","mother"));
    }
}

String.replace实现真的很有效吗？

3 个答案: