Optimised replaceAll jdk1.3

Question

Hi
I recently had to port a jdk1.4 application to jdk1.3!, and had to write a replaceAll() function. I don't have the code today, but this just looped through the entire string, like so:
int x = STRING.indexOf(TARGET);
int y = STRING.indexOf(TARGET, x+1);
to get the the locations of a pattern, and then concatenating with the string of up to x characters with the replacement and after y characters.
The old string is then replace with the new string, and the process continues until there are no more matches, at this point the string has been replacedAll() and is returned.
This all works fine, except when the data set is really large, with loads and loads of matching patterns. (the function works well to a point where the performance seems to exponentially decrease) Does any body have a more optimised version of this function that could be used?
I was considering replacing strings with stringbuffers, but I don't think the performance will still be accepatable, because the indexOf's are presumably taking all of the time.
Would something like this be better attampted in C and then called natively?
Thanks in advance.

Answer 1

Its the catenations. The following code demonstrates this. The indexOf algorithm using StringBuffers is faster thanthe regx replaceAll.
import java.io.*;
import java.util.*;
class TestStringSub2
     static boolean [] table = new boolean[128];
     static public void main(String[] args)
          int copies=1;
          if(args.length > 0)copies = toInt(args[0],1);
          String st0 = "abcdeDogfghiDogjklDogmnopDogqrstDoguvwDogxyz";
          StringBuffer stb = new StringBuffer();
          String str ="";
          int i;
          long t0,t1;
          for (i=0;i<copies;i++)stb.append(st0);
          str = stb.toString();
          System.out.println("Test data size="+str.length());
          t0 = System.currentTimeMillis();
          String fd1 = alg1(str);
          t1 = System.currentTimeMillis()-t0;
          System.out.println("regx time="+t1+" size="+fd1.length());
          // System.out.println(fd1);
          t0 = System.currentTimeMillis();
          String fd2 = alg2(str);
          t1 = System.currentTimeMillis()-t0;
          System.out.println("indx time="+t1+" size="+fd1.length()+" =regx="+(fd2.equals(fd1)));
          // System.out.println(fd2);
     static String alg1(String str)
          return str.replaceAll("Dog", "Cat");
     static String alg2(String str)
          StringBuffer data = new StringBuffer(str);
          StringBuffer filteredData = new StringBuffer(str.length());
          int i =0;
          int j;
          while(i < data.length())
               j = data.indexOf("Dog",i);
               if(j == -1)j = data.length();
               filteredData.append(data.substring(i,j));
               if(j<data.length())filteredData.append("Cat");
               i = j+3;
          return filteredData.toString();
     public static int toInt(String s, int er)
          int i;
          try{i = new Integer(s).intValue();}
          catch(NumberFormatException exc){i =er;}
          return i;
}The timings are
E:\JavaTest>java -cp . TestStringSub2
Test data size=44
regx time=10 size=44
indx time=0 size=44 =regx=true
E:\JavaTest>java -cp . TestStringSub2 100
Test data size=4400
regx time=40 size=4400
indx time=10 size=4400 =regx=true
E:\JavaTest>java -cp . TestStringSub2 1000
Test data size=44000
regx time=91 size=44000
indx time=50 size=44000 =regx=true
E:\JavaTest>java -cp . TestStringSub2 10000
Test data size=440000
regx time=350 size=440000
indx time=240 size=440000 =regx=true