"\\" results in a 1 character string containing a backslash
only. This is not a valid regular expression.

 Harald.

I am also kind of stuck in the regex, I sometimes use this function to
do the string / substring replacement work.

 public String stringReplaceAllCaseSensitive (String orig, String
from, String to)
 {
    if ((from==null) || (from.length()==0))
     {
       println("\tWarning in stringReplaceAllCaseSensitive, from
string is empty. Ignored. ");
       return orig;
     };
     if (from.compareTo(to)==0)
       return orig;
    //
     int fromLength = from.length();
     //
     int start = orig.indexOf (from);
     if (start <0)
         return orig;
     //
     boolean greaterLength = (to.length() >= fromLength);

     StringBuffer buffer;
     // If the "to" parameter is longer than (or
     // as long as) "from", the final length will
     // be at least as large
     if (greaterLength)
     {
         buffer = new StringBuffer(orig.length());
     }
     else
     {
         buffer = new StringBuffer();
     };
     //
     char [] origChars = orig.toCharArray();
     int copyFrom=0;
     while (start != -1)
     {
         buffer.append (origChars, copyFrom, start-copyFrom);
         buffer.append (to);
         copyFrom=start+fromLength;
         start = orig.indexOf (from, copyFrom);
     }
     buffer.append (origChars, copyFrom, origChars.length-copyFrom);

     return buffer.toString();
 }
 //

Here are a couple of tips.
A literal Java backslash looks like this: "\\"
A literal regex backslash looks like this: \\
Therefore, a literal regex backslash using Java looks like this: "\\\\"

Backslash requires special treatment BOTH in regex string
and Java String. See the example program:

public class ReplaceTest{
 public static void main(String[] args){
   String str = "\\he said \"I love you.\"\\";

   System.out.println("original: " + str);

   /* regex str for a single BS is \\, so the Java String for
      that is "\\\\" */
   str = str.replaceAll("\"", "\\\\\""); //dq -> BS + dq
   System.out.println("result1 : " + str);
   /* read the above comment for BS regex str */
   str = str.replaceAll("\\\\", "\\\\\\\\"); //BS -> double BSs
   System.out.println("result2 : " + str);
 }
}

Oops!
Please reverse the calling order of my two replaceAll() calls.

The arguments to replaceAll get processed twice: first by the
compiler, then by the Pattern (first argument) and Matcher (second
argument) classes, which do the actual matching and replacing.  Both
of those classes also treat the backslash as an escape character.  So,
to match a literal backslash character, or to insert one into the
replacement string, you have to double it, then double it again.  So
replacing a single backslash with a double backslash looks like this:

 text = text.replaceAll("\\\\", "\\\\\\\\");

The double-quote character, OTOH, has to be escaped for the compiler,
but it isn't special to the regex classes, so you only need one
backslash to escape it.  Of course, to add a backslash in front of it,
you have to use four of them, plus the one to escape the quote:

 text = text.replaceAll("\"", "\\\\\"");

Instead of doing in two passes, though, you can use the power of
regexes to do it in one:

 text = text.replaceAll("[\"\\\\]", "\\\\$0");

The regex, "[\"\\\\]", is a character class that matches either a
quote or a backslash, and the $0 in the second argument gets replaced
with whatever was matched by the regex.  For more info, check out this
site:

http://www.regular-expressions.info/

hmmmm... escape char nightmare, it happens in emacs too :-)