正则表达式获取除冒号之外的两个冒号之间的值

Question

I have a string like this:

something:POST:/some/path

Now I want to take the POST alone from the string. I did this by using this regex

:([a-zA-Z]+):

But this gives me a value along with colons. ie I get this:

:POST:

but I need this

POST

My code to match the same and replace it is as follows:

String ss = "something:POST:/some/path/";
Pattern pattern = Pattern.compile(":([a-zA-Z]+):");
Matcher matcher = pattern.matcher(ss);

if (matcher.find()) {
    System.out.println(matcher.group());
    ss = ss.replaceFirst(":([a-zA-Z]+):", "*");
}
System.out.println(ss);

EDIT:

I've decided to use the lookahead/lookbehind regex since I did not want to use replace with colons such as :*: . This is my final solution.

String s = "something:POST:/some/path/";
String regex = "(?<=:)[a-zA-Z]+(?=:)";

Matcher matcher = Pattern.compile(regex).matcher(s);

if (matcher.find()) {
    s = s.replaceFirst(matcher.group(), "*");
    System.out.println("replaced: " + s);
} 
else {
    System.out.println("not replaced: " + s);
}

Answer 1

There are two approaches:

• Keep your Java code, and use lookahead/lookbehind (?<=:)[a-zA-Z]+(?=:) , or
• Change your Java code to replace the result with ":*:"

Note: You may want to define a String constant for your regex, since you use it in different calls.

Answer 2

UPDATE

Looking at your update, you just need ReplaceFirst only:

String result = s.replaceFirst(":[a-zA-Z]+:", ":*:");

See the Java demo

When you use (?<=:)[a-zA-Z]+(?=:) , the regex engine checks each location inside the string for a * before it, and once found, tries to match 1+ ASCII letters and then assert that there is a : after them. With :[A-Za-z]+: , the checking only starts after a regex engine found : character. Then, after matching :POST: , the replacement pattern replaces the whole match. It is totlally OK to hardcode colons in the replacement pattern since they are hardcoded in the regex pattern .

Original answer

You just need to access Group 1:

if (matcher.find()) {
    System.out.println(matcher.group(1));
}

See Java demo

Your :([a-zA-Z]+): regex contains a capturing group (see (....) subpattern). These groups are numbered automatically: the first one has an index of 1 , the second has the index of 2 , etc.

To replace it, use Matcher#appendReplacement() :

String s = "something:POST:/some/path/";
StringBuffer result = new StringBuffer();
Matcher m = Pattern.compile(":([a-zA-Z]+):").matcher(s);
while (m.find()) {
    m.appendReplacement(result, ":*:");
}
m.appendTail(result);
System.out.println(result.toString());

See another demo

Answer 3

As pointed out, the reqex captured group can be used to replace.

The following code did it:

  String ss = "something:POST:/some/path/";
    Pattern pattern = Pattern.compile(":([a-zA-Z]+):");
    Matcher matcher = pattern.matcher(ss);

    if (matcher.find()) {
        ss = ss.replaceFirst(matcher.group(1), "*");
    }
    System.out.println(ss);

Answer 4

This is your solution:

regex = (:)([a-zA-Z]+)(:)

And code is:

String ss = "something:POST:/some/path/";

ss = ss.replaceFirst("(:)([a-zA-Z]+)(:)", "$1*$3");

ss now contains:

something:*:/some/path/

Which I believe is what you are looking for...