Is there a faster way to escape a string?

Question

I have a method that looks like this:

public static String escape(String text)
{
   String r = replace(text, "\\", "\\\\");
   r = replace(r, "\r", "\\r");
   r = replace(r, "\b", "\\b");
   r = replace(r, "\t", "\\t");
   r = replace(r, "\n", "\\n");
   r = replace(r, "\f", "\\f");
   return r;
}

Is there a faster, less brutal way to do this and if so what would that way look like?

Note that this is J2ME, so no Apache commons, and no regex.

Answer 1

Once it works (comment noted above), the simplest way to speed it up is to perform the replacements using a StringBuffer.

But, have you measured this ? Is it a bottleneck ? I would suggest you do this before expending energy on optimisations.

Answer 2

You probably want one of the methods from Apache Commons Lang StringEscapeUtils, such as unescapeJava()

Answer 3

hm can't you just use

public static String escape(String text)
{
   String r = replace(text, "\", "\\");
   return r;
}

Answer 4

Do you mean "fast" for the developer or performance? If it's the latter, then use a char array & do it all yourself. It will be much faster since you can do it in one pass.

Answer 5

Using the following would require traversing the characters in the String only once instead of x where x is the number of control characters to escape:

private static final Hashtable mapping = new Hashtable(6);

static {
    mapping.put(Character.valueOf('\\'), "\\\\");
    mapping.put(Character.valueOf('\r'), "\\r");
    mapping.put(Character.valueOf('\b'), "\\b");
    mapping.put(Character.valueOf('\t'), "\\t");
    mapping.put(Character.valueOf('\n'), "\\n");
    mapping.put(Character.valueOf('\f'), "\\f");
}

public static String escape(String text) {
    final StringBuffer escaped = new StringBuffer();

    for (int characterNumber = 0; characterNumber < text.length(); ++characterNumber) {
        final char current = text.charAt(characterNumber);
        if (mapping.containsKey(Character.valueOf(current))) {
            escaped.append(mapping.get(current));
        } else {
            escaped.append(current);
        }
    }
    return escaped.toString();
}

Answer 6

I would do something like below. You'll have to benchmark it for your own target devices to make sure, but I think it will certainly be faster since you are not creating a new String object for every replace. And, it will be better from a creating garbage on the heap standpoint, which may or may not help with heap fragmentation.

public static String escape(String text) { 
    if(text == null) {
        return null;
    }

    int numChars = text.length();
    char ch;
    StringBuffer sb = new StringBuffer();
    for(int i = 0; i < numChars; i++) {
        ch = text.charAt(i);

        switch(ch) {
            case '\\':  { sb.append("\\\\"); break; }
            case '\r':  { sb.append("\\r"); break; }
            case '\b':  { sb.append("\\b"); break; }
            case '\t':  { sb.append("\\t"); break; }
            case '\n':  { sb.append("\\n"); break; }
            case '\f':  { sb.append("\\f"); break; }
            default: {
                sb.append(ch);
                break;
            }
        }
    }
    return sb.toString();
}