Re-ordering 2 files, can you help me speed it up?

Question

Hi all - this is kind of complicated. I have 2 files, each contains identical blocks of information (identified by the word "Processing") but in different orders. So I have to find the block in the first file, write it to an output file, and then find the matching block in the 2nd file and write it out - Thereby insuring that the processing blocks in both outfiles are in the same order. (What my end result should be is 2 files I can compare, looking for info inside the blocks that may differ).
I've got a function now, but it's sloooooow. The biggest file that I have to read & manipulate like this is 14,406 kb in size. Takes about 15 to 20 minutes and eats up 97% of my resources. The code is below, can anyone help identify bottlenecks? (or better ways to accomplish this...)
Thanks!!!
/* This function reads one file line by line.  if a line contains the word "processing",
then another stream is opened (same file, starting at same line), and data is read and
written to the "out" file until "processing" is found again.  A 2nd file, with the same
info but in a different order, is opened & searched for the same processing block, this
data is entered into the 2nd out file.  This is basically a re-ordering scheme.*/
protected void CrossThem(String outfile1, String outfile2){
     /* create the new "clean" files */
     String out1 = CreateCleanFile(outfile1);//creates the 1st file that will be written to
     String out2 = CreateCleanFile(outfile2);//creates the 2nd file that will be written to
     /* create the 3 RandomAccessFiles that will be read from */
    RandomAccessFile rf1;
    RandomAccessFile rf2;
    RandomAccessFile rf3;
     try
          BufferedWriter bw = new BufferedWriter(new FileWriter(out1, true));
          BufferedWriter bw2 = new BufferedWriter(new FileWriter(out2, true));
          rf1 = new RandomAccessFile(outfile1, "rw");//1st file to be read from
          rf2 = new RandomAccessFile(outfile2, "rw");//1st file to be searched when info is found in rf1
          rf3 = new RandomAccessFile(outfile1, "rw");//2nd file to be searched for info found in 1st
          String line1 = null;
          String line2 = null;
          while((line1 = rf1.readLine()) != null){
              if (line1.indexOf("Processing")!= -1){
                    g_fp = rf1.getFilePointer();
                String nextline1 = null;
                bw.write(line1 + "\n");
                rf3.seek(g_fp);
                /* get rest of processing block by opening another
                 * file and starting from there
                while(((nextline1 = rf3.readLine()) != null ) && (nextline1.indexOf("Processing") == -1)){
                      bw.write(nextline1);
                        bw.write("\n");
                /* find block in rf2 */
                    rf2.seek(0);
                while((line2 = rf2.readLine()) != null){
                    if((line2.equalsIgnoreCase(line1) && (line2.indexOf("Processing") != -1))){
                    long fp2 = rf2.getFilePointer();
                    String nextline2 = null;
                    bw2.write(line2);
                    bw2.write("\n");
                    rf2.seek(fp2);
                    while((nextline2 = rf2.readLine()) != null && (nextline2.indexOf("Processing")== -1)){
                         bw2.write(nextline2);
                         bw2.write("\n");
        rf1.close();
          rf2.close();
        rf3.close();
        bw.flush();
        bw2.flush();
        bw.close();
        bw2.close();
        }catch (Exception o){
             //do something
     }     

Answer 1

I'd suggest one quick and easy thing you can do is not re-scan the second file on each processing block.
During the scan, if it is not the block you want, you could save the file location into a HashMap with the processing line/identifier as the key. You could also save the "furthest" location you've progressed into the file. Then when you get a processing block from the first file, check if it matches one in your HashMap, and immediately seek to that location and process the block. If it's not in the HashMap, seek to the furthest location you saved, and continue scanning procedure, adding processing blocks to the HashMap (again) until you find the block you want.