Find ASCII "arrows" in text

Question

I'm trying to find all the occurrences of "Arrows" in text, so in

"<----=====><==->>"

the arrows are:

"<----", "=====>", "<==", "->", ">"

This works:

 String[] patterns = {"<=*", "<-*", "=*>", "-*>"};
    for (String p : patterns) {
      Matcher A = Pattern.compile(p).matcher(s);
       while (A.find()) {
        System.out.println(A.group());
      }         
    }

but this doesn't:

      String p = "<=*|<-*|=*>|-*>";
      Matcher A = Pattern.compile(p).matcher(s);
       while (A.find()) {
        System.out.println(A.group());
      }

No idea why. It often reports "<" instead of "<====" or similar.

What is wrong?

Answer 1

for <======= you need <=+ as the regex. <=* will match zero or more ='s which means it will always match the zero case hence <. The same for the other cases you have. You should read up a bit on regexs. This book is FANTASTIC: Mastering Regular Expressions

Answer 2

Your provided regex pattern String does work for your example: "<----=====><==->>"

 String p = "<=*|<-*|=*>|-*>";
 Matcher A = Pattern.compile(p).matcher(s);
   while (A.find()) {
           System.out.println(A.group());
                   }

However it is broken for some other examples pointed out in the answers such as input string "<-" yields "<", yet strangely "<=" yields "<=" as it should.

Answer 3

Solution

The following program compiles to one possible solution to the question:

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class A {
  public static void main( String args[] ) {
    String p = "<=+|<-+|=+>|-+>|<|>";
    Matcher m = Pattern.compile(p).matcher(args[0]);
    while (m.find()) {
      System.out.println(m.group());
    }
  }
}

Run #1:

$ java A "<----=====><<---<==->>==>"
<----
=====>
<
<---
<==
->
>
==>

Run #2:

$ java A "<----=====><=><---<==->>==>"
<----
=====>
<=
>
<---
<==
->
>
==>

Explanation

An asterisk will match zero or more of the preceding characters. A plus (+) will match one or more of the preceding characters. Thus <-* matches < whereas <-+ matches <- and any extended version (such as <--------).

Answer 4

When you match "<=*|<-*|=*>|-*>" against the string "<---", it matches the first part of the pattern, "<=*", because * includes zero or more. Java matching is greedy, but it isn't smart enough to know that there is another possible longer match, it just found the first item that matches.

Answer 5

Your first solution will match everything that you are looking for because you send each pattern into matcher one at a time and they are then given the opportunity to work on the target string individually.

Your second attempt will not work in the same manner because you are putting in single pattern with multiple expressions OR'ed together, and there are precedence rules for the OR'd string, where the leftmost token will be attempted first. If there is a match, no matter how minimal, the get() will return that match and continue on from there.

See Thangalin's response for a solution that will make the second work like the first.