Why would anyone want to use regular expressions to look for a plain
String?  Regular expressions are a tool for deciding whether a String or
some subset thereof matches a defined regular language.  Although string
searching is a trivial degeneration of the problem addressed by regular
expressions, there's no need to introduce the added complexity.

If you are set on using regular expressions, converting the arbitrary
input string into a pattern that matches only itself is the first task.  
Prior to Java 1.5, this was very difficult.  In 1.5, it's encapsulated
in a method called Pattern.quote(String).  Once that's done, you can
search for that pattern.  It's far easier, though, to use String.indexOf
(prior to 1.5) or String.contains (as of 1.5).

Thanks a lot, guys. Roedy, I will try that approach later.

I did a little testing on the performance and got an interesting
result. Here is the program.

import java.util.*;
/*
This is an un-scientific, probably way off-mark, testing
comparing the speed of three functions:
String.contains(), String.indexOf() and String.matches().
Note that String.matches() use regular expression approach
according to the java doc

Result: the speeds of indexOf() and contains() are about the same,
but matches() is at least ten times slower.
Is regular expression bad in terms of performance?

Problems with this tesing:
1. The target string a is not long enough. As I said, in my app, it
can be up to 100k. The performance may change if string a gets bigger.
2. In all loops, string a and string b are the same. In my app, at the
least string a is always changing, such as newly downloaded web pages.
3. Right now, it always matches inside the loop. should do a randomized
String a and string b.

Testing machine: WinXP Pro, P3 500, 256MB Ram, JDK 1.5.0_05
*/

public class Test {

    public static void main(String args[]) {

        int loop = 1000000;

        int matches = 0;

        String a = "This is a testing string. It is not very long.";
        String b = "is not";

        long startTime = System.currentTimeMillis();

        for (int i = 0; i < loop; i++) {
            if (a.contains(b)) matches++; //took about 1620 miliseconds
            //if (a.matches(".*not.*")) matches++; //took about 25200
miliseconds
            //if (a.indexOf(b) != -1) matches++; //took about 1520 miliseconds
        }

        long endTime = System.currentTimeMillis();

        System.out.println("\nRunning " + loop + " times took " + (endTime -
startTime) + " miliseconds.");
    }

}

right now, this part of my app (processing the downloaded web pages)
takes lots of time. so i am looking for ways to speed it up.

Thomas Weidenfeller <nobody@ericsson.invalid> wrote in news:dn0u58$ika$1
@news.al.sw.ericsson.se:

I find my knowledge of such standard algorithms to be quite limited.  Can
you suggest a good source - online or in print - to broaden my knowledge?

TIA
zero

Agree, best is ambiguous. But the message subject line contains 'quickest',
so the question must be runtime.

Hiran