CODEWITHSUNDEEP
javaregex
Yibin Lin
Yibin Lin

Reputation: 721

What's the difference between Matcher.lookingAt() and find()?

I am looking at Java regex tutorial, the title pretty much explains itself. It looks like Matcher.lookingAt() is trying to match the entire String. Is that true?

Upvotes: 20

Views: 13577

Answers (3)

Eugene
Eugene

Reputation: 120858

Maybe some code would make this easier to grasp:

    @Test
    void testFind() {
        Pattern p = Pattern.compile("abc");
        Matcher m = p.matcher("abc def mno abc");

        while (m.find()) {
            System.out.println("found from : " + m.start() + " to " + m.end());
        }
    }

    @Test
    void testLookingAt() {
        Pattern p = Pattern.compile("abc");
        Matcher m = p.matcher("abc def mno abc");

        if (m.lookingAt()) {
            System.out.println("lookingAt hit " + m.start() + " to " + m.end());
        }
    }

    @Test
    void testMatches() {
        Pattern p = Pattern.compile("abc");
        Matcher m = p.matcher("abc def mno abc");

        if (m.matches()) {
            System.out.println("matches");
        }
    }

As you can see find is like an iterator, in our sample it found two tokens. lookingAt looks from the beginning and matches tries to match against the entire input (that's why that statement is not printed at all)

Upvotes: 1

Jeffrey Bosboom
Jeffrey Bosboom

Reputation: 13653

The documentation for Matcher.lookingAt clearly explains the region lookingAt tries to match:

Like the matches method, this method always starts at the beginning of the region; unlike that method, it does not require that the entire region be matched.

So no, lookingAt does not require matching the whole string. Then what's the difference between lookingAt and find? From the Matcher Javadoc overview:

  • The matches method attempts to match the entire input sequence against the pattern.
  • The lookingAt method attempts to match the input sequence, starting at the beginning, against the pattern.
  • The find method scans the input sequence looking for the next subsequence that matches the pattern.

lookingAt always starts at the beginning, but find will scan for a starting position.

Viewed another way, matches has a fixed start and end, lookingAt has a fixed start but a variable end, and find has a variable start and end.

Upvotes: 41

Martin M J
Martin M J

Reputation: 880

lookingAt() always starts checking from the beginning, and returns true when it comes across a match.

find() can find multiple matches, because it stores its current position, much like an iterator.

About find() from http://docs.oracle.com/javase/7/docs/api/java/util/regex/Matcher.html#find%28%29:

This method starts at the beginning of this matcher's region, or, if a previous invocation of the method was successful and the matcher has not since been reset, at the first character not matched by the previous match.

Upvotes: 5

Related Questions