That depends on what you mean. If you just want to get rid of them, do this:
(Update: Apparently you want to keep digits as well, use the second lines in that case)

String alphaOnly = input.replaceAll("[^a-zA-Z]+","");
String alphaAndDigits = input.replaceAll("[^a-zA-Z0-9]+","");

or the equivalent:

String alphaOnly = input.replaceAll("[^\\p{Alpha}]+","");
String alphaAndDigits = input.replaceAll("[^\\p{Alpha}\\p{Digit}]+","");

(All of these can be significantly improved by precompiling the regex pattern and storing it in a constant)

Or, with Guava:

private static final CharMatcher ALNUM =
  CharMatcher.inRange('a', 'z').or(CharMatcher.inRange('A', 'Z'))
  .or(CharMatcher.inRange('0', '9')).precomputed();
// ...
String alphaAndDigits = ALNUM.retainFrom(input);

But if you want to turn accented characters into something sensible that's still ascii, look at these questions:

• Converting Java String to ASCII
• Java change áéőűú to aeouu
• ń ǹ ň ñ ṅ ņ ṇ ṋ ṉ ̈ ɲ ƞ ᶇ ɳ ȵ --> n or Remove diacritical marks from unicode chars

Simply use String#replace(CharSequence target, CharSequence replacement) in your case to replace a given CharSequence, as next:

special = special.replace("@$", "as");

Or use Pattern.quote(String s) to convert your String as a literal pattern String, as next:

special = special.replaceAll(Pattern.quote("@$"), "as");

If you intend to do it very frequently, consider reusing the corresponding Pattern instance (the class Pattern is thread-safe which means that you can share instances of this class) to avoid compiling your regular expression at each call which has a price in term of performances.

So your code could be:

private static final Pattern PATTERN = Pattern.compile("@$", Pattern.LITERAL);
...
special = PATTERN.matcher(special).replaceAll("as");

 public static void main(String[] args) throws IOException {
        String exp = "XY_Universit�-WWWWW-ZZZZZ";
        exp = exp.replaceAll("Universit[^a]", "Universita");
        System.out.println(exp);
    }

Output

XY_Universita-WWWWW-ZZZZZ

... but it seems like a duct tape answer.

It seems like a "duct tape" answer because you haven't learned why you need to use \+ when you are replacing just a "+" character.

The answer is that "+" is a regex metacharacter. It means "the character or group before this may appear one or more times".

If you want "to+go" to be treated as a literal String (rather than a regex), then one way to do this is to "regex quote" it; e.g.

s.replaceAll(Pattern.quote("to+go"), "");

On the other hand, if the + characters are entirely irrelevant, then removing them would also work ...

You can go the other way round. Replace everything that is not word characters, using negated character class:

message = message.replaceAll("[^\\w]", "");

or

message = message.replaceAll("\\W", "");

Both of them will replace the characters apart from [a-zA-Z0-9_]. If you want to replace the underscore too, then use:

[\\W_]

The closing quotes are missing in the 2nd parameter. Change to:

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

Also see this example.

It's better in this case to use non-regex replace() instead of regex replaceAll(). You don't need regular expressions for this replacement and it complicates things because it needs extra escapes. Backslash is a special character in Java and also in regular expressions, so in Java if you want a straight backslash you have to double it up \\ and if you want a straight backslash in a regular expression in Java you have to quadruple it \\\\.

something = something.replace("\\", "/");

Behind the scenes, replace(String, String) uses regular expression patterns (at least in Oracle JDK) so has some overhead. In your specific case, you can actually use single character replacement, which may be more efficient (not that it probably matters!):

something = something.replace('\\', '/');

If you were to use regular expressions:

something = something.replaceAll("\\\\", "/");

Or:

something = something.replaceAll(Pattern.quote("\\"), "/");

I'm not sure why you use the StringUtils you can just directly replace words that match the bad words. This code works for me:

public static void main(String[] args) {
    ArrayList<String> badWords = new ArrayList<String>();
    badWords.add("test");
    badWords.add("BadTest");
    badWords.add("\\$\\$");
    String test = "This is a TeSt and a $$ with Badtest.";
    for(int i = 0; i < badWords.size(); i++) {
            test = test.replaceAll("(?i)" + badWords.get(i), "****");
    }
    test = test.replaceAll("\\w*\\*{4}", "****");
    System.out.println(test);
}

Output:

This is a **** and a **** with ****.

You can get rid of all characters outside the printable ASCII range using String#replaceAll() by replacing the pattern [^\\x20-\\x7e] with an empty string:

a = a.replaceAll("[^\\x20-\\x7e]", "");

But this actually doesn't solve your actual problem. It's more a workaround. With the given information it's hard to nail down the root cause of this problem, but reading either of those articles must help a lot:

• The Absolute Minimum Every Software Developer Absolutely, Positively Must Know About Unicode and Character Sets (No Excuses!)
• Unicode - How to get the characters right?