Question

I am new to java and I am trying to learn about optimizing code to make it production ready. I have the following code below. I would like to know how I could optimize it.I thought by using a small snippet of could, it would be a good way to learn.

Some points:
1. The function would be run many times to it needs to be fast.
2. The input is unconstrained since it might come from a user or from a file. Is there a way to deal with this so not exceptions are thrown? I was thinking of using a regular expression.
3. Is there anything else I need to do to make it production ready? e.g. unit tests. If so, what would be the best way to do this?
4. I am assuming that the string to be searched is not very long.
5. When I say optimization, I mean doing things like replacing the ‘+’ operator with something faster is it can effect memory and performance, etc.

public String strReplave(String originalStr, String oldStr, String newStr) {
    int start = 0;
    while ((start = originalStr.indexOf(oldStr, start)) > 0) {
        originalStr= originalStr.substring(0,start) + newStr+ originalStr.substring(start + oldStr.length());
    start += newStr.length();
}
return originalStr;
}

Thanks for your help and if you need me to clarify anything please let me know.

Answer 1

public static String replace(String originalStr, String oldStr, String newStr) {
    int p = originalStr.indexOf(oldStr);
    if (p == -1) {
        return originalStr;
    } else {
        StringBuilder result = new StringBuilder();
        result.append(originalStr, 0, p);
        result.append(newStr);
        int q = p + oldStr.length();
        while ((p = originalStr.indexOf(oldStr, q)) != -1) {
            result.append(originalStr, q, p);
            result.append(newStr);
            q = p + oldStr.length();
        }
        result.append(originalStr, q, originalStr.length());
        return result.toString();
    }
}

• Use StringBuilder to concat Strings.
• Optimization if search string is not found. You can skip this, if this doesn’t happen freuently.