Replace a String containing "$" with "\$" in Java - java

How can I do it? I made a research but I could not find a clear answer.I tried to use
pass = pass.replaceAll("$", "\\$");
but It does not work.

use
pass = pass.replace("$", "\\$");
It will also replace all occurrences. See JavaDoc.
If you prefer the hard way and want to use a regex, you need:
pass = pass.replaceAll("\\$", "\\\\\\$");
This can be simplified with Matcher.quoteReplacement() but still, only use replaceAll() when you need to replace something that matches a regular expression, and use replace() when you have to replace a literal sequence.

The problem is that String.replaceAll uses regular expressions, where both \ and $ have special meanings. You don't want that as far as I can tell - you just want to replace the strings verbatim. As such, you should use String.replace:
pass = pass.replace("$", "\\$");
(Personally I think the fact that replaceAll uses regular expressions is a design mistake, but that's another matter.)

Related

Pattern for Guava Splitter

I need to split String by comma or dot or backslach :
Pattern stringPattern = Pattern.compile("\\s+|,|\\\\|");
Splitter.on(stringPattern).omitEmptyStrings().split(description));
but this pattern don't work , what is wrong ?
Why not use a CharMatcher?
Splitter.on(CharMatcher.anyOf(",.\\")).omitEmptyStrings().split(description);
Given your simple problem, I don't think you need the regular expressions.
The correct regex for comma or dot or backslash is [.,\\], so in Java that's
Pattern.compile("[.,\\\\]")
I do like Olivier's suggestion of CharMatcher though.
I'd use string.split with the regular expressions. Following should work (I have not tried)
description.split(",.\\")
Then do null check (as such splitter has extra api for the same).
Patterns are useful for identifying "groups". Any regular expression related splitting can be equally done with strings (instead of pattern)-that is not to discourage from using Guava!

Escaping '\' for use with Java replaceAll method

I am getting some weird results when using the replaceAll method of the String class.
The string query contains the following: #cm:name:"hello"
If I say query.replaceAll(":", "\\:");
I would expect the following result: #cm\:name\:"hello"
Instead I get: #cm:name:"hello". The original content.
Don't use replaceAll(..) for non-regex replaces. Use replace(..) instead.
Then, be sure to have:
query = query.replace(":", "\\:");
because String is immutable - i.e. if you just call the method without assigning the result, you get nothing - the internal state of the object won't change.
There are two simple rules.
The Java compiler requires two blackslashes to represent a single backslash in a string literal .
Regular expressions require two backslashes to represent a single backslash in a regular expression.
So if you want a string literal to contain a regular expression single backslash you have to write four.
The escape sequence for \ is \\. So, you'd write this:
query.replaceAll(":", "\\:");
Escape the slash
query.replaceAll(":","\\:");

Refactor Regex Pattern - Java

I have the following aaaa_bb_cc string to match and written a regex pattern like
\\w{4}+\\_\\w{2}\\_\\w{2} and it works. Is there any simple regex which can do this same ?
You don't need to escape the underscores:
\w{4}+_\w{2}_\w{2}
And you can collapse the last two parts, if you don't capture them anyway:
\w{4}+(?:_\w{2}){2}
Doesn't get shorter, though.
(Note: Re-add the needed backslashes for Java's strings, if you like; I prefer to omit them while talking about regular expressions :))
I sometimes do what I call "meta-regexing" as follows:
String pattern = "x{4}_x{2}_x{2}".replace("x", "[a-z]");
System.out.println(pattern); // prints "[a-z]{4}_[a-z]{2}_[a-z]{2}"
Note that this doesn't use \w, which can match an underscore. That is, your original pattern would match "__________".
If x really needs to be replaced with [a-zA-Z0-9], then just do it in the one place (instead of 3 places).
Other examples
Regex for metamap in Java
How do I convert CamelCase into human-readable names in Java?
Yes, you can use just \\w{4}_\\w{2}_\\w{2} or maybe \\w{4}(_\\w{2}){2}.
Looks like your \w does not need to match underscore, so you can use [a-zA-Z0-9] instead
[a-zA-Z0-9]{4}_[a-zA-Z0-9]{2}_[a-zA-Z0-9]{2}

Is using "\\\\" to match '\' with Regex in Java the most Readable Way?

I know that the following works but it is not that readable, is there any way to make it more readable in the code itself without the addition of a comment?
//Start her off
String sampleregex = "\\\\";
if (input.matches(sampleregex))
//do something
//do some more
Why not
if (input.contains("\\")) {
}
since you simply appear to be looking for a backward slash ?
Assuming you mean "\\\\" instead of "////":
You could escape it with \Q and \E, which removes one layer of backslashes: "\\Q\\\E", but that's not that much better. You could also use Pattern.quote("\\") to have it escaped at runtime. But personally, I'd just stick with "\\\\".
(As an aside, you need four of them because \ is used to escape things in both the regex engine and in Java Strings, so you need to escape once so the regex engine knows you're not trying to scape anything else (so that's \\); then you need to escape both of those so Java knows you're not escaping something in the string (so that's \\\\)).
/ is not a regex metacharacter, so the regex string "/" matches a single slash, and "////" matches four in a row.
I imagine you meant to ask about matching a single backslash, rather than a forward slash, in which case, no, you need to put "\\\\" in your regex string literal to match a single backslash. (And I needed to enter eight to make four show up on SO--damn!)
My solution is similiar to Soldier.moth's but with a twist. Create a constants file which contains common regular expressions and keep adding to it. The expressions as constants can even be combined providing a layer of abstraction to building regular expressions, but in the end they still often end up messy.
public static final String SINGLE_BACKSLASH = "\\\\";
The one solution I've thought of is to do
String singleSlash = "\\\\";
if(input.matches(singleSlash))
//...
Using better names for your variables and constants, and composing them step by step is a good way to do without comments, for example:
final string backslash = "\\";
final string regexEscapedBackslash = backslash + backslash;
if (input.matches(regexEscapedBackslash)) {
...

Escaping a String from getting regex parsed in Java

In Java, suppose I have a String variable S, and I want to search for it inside of another String T, like so:
if (T.matches(S)) ...
(note: the above line was T.contains() until a few posts pointed out that that method does not use regexes. My bad.)
But now suppose S may have unsavory characters in it. For instance, let S = "[hi". The left square bracket is going to cause the regex to fail. Is there a function I can call to escape S so that this doesn't happen? In this particular case, I would like it to be transformed to "\[hi".
String.contains does not use regex, so there isn't a problem in this case.
Where a regex is required, rather rejecting strings with regex special characters, use java.util.regex.Pattern.quote to escape them.
As Tom Hawtin said, you need to quote the pattern. You can do this in two ways (edit: actually three ways, as pointed out by #diastrophism):
Surround the string with "\Q" and "\E", like:
if (T.matches("\\Q" + S + "\\E"))
Use Pattern instead. The code would be something like this:
Pattern sPattern = Pattern.compile(S, Pattern.LITERAL);
if (sPattern.matcher(T).matches()) { /* do something */ }
This way, you can cache the compiled Pattern and reuse it. If you are using the same regex more than once, you almost certainly want to do it this way.
Note that if you are using regular expressions to test whether a string is inside a larger string, you should put .* at the start and end of the expression. But this will not work if you are quoting the pattern, since it will then be looking for actual dots. So, are you absolutely certain you want to be using regular expressions?
Try Pattern.quote(String). It will fix up anything that has special meaning in the string.
Any particular reason not to use String.indexOf() instead? That way it will always be interpreted as a regular string rather than a regex.
Regex uses the backslash character '\' to escape a literal. Given that java also uses the backslash character you would need to use a double bashslash like:
String S = "\\[hi"
That will become the String:
\[hi
which will be passed to the regex.
Or if you only care about a literal String and don't need a regex you could do the following:
if (T.indexOf("[hi") != -1) {
T.contains() (according to javadoc : http://java.sun.com/javase/6/docs/api/java/lang/String.html) does not use regexes. contains() delegates to indexOf() only.
So, there are NO regexes used here. Were you thinking of some other String method ?

Categories

Resources