Scanner with Regex not reading the entire file

Here's my parsing method.

public void loadInput(File fileName) throws IOException {
    try {
      Scanner s = new Scanner(fileName);
      int numWords = 0;
      while (s.hasNext("(?<!')[\\w']+")) {
        System.out.println("word:" + s.next());
        numWords++;
      }
      System.out.println("Number of words: " + numWords);
    } catch (IOException e) {
      System.out.println("Error accessing input file!");
    }
  }

And here's an example input file:

Alice was beginning to get very tired of sitting by her sister
on the bank, and of having nothing to do:  once or twice she had
peeped into the book her sister was reading, but it had no
pictures or conversations in it, `and what is the use of a book,'
thought Alice `without pictures or conversation?'

  So she was considering in her own mind (as well as she could,
for the hot day made her feel very sleepy and stupid), whether
the pleasure of making a daisy-chain would be worth the trouble
of getting up and picking the daisies, when suddenly a White
Rabbit with pink eyes ran close by her.

It only matches these words:

word:Alice
word:was
word:beginning
word:to
word:get
word:very
word:tired
word:of
word:sitting
word:by
word:her
word:sister
word:on
word:the
Number of words: 14

Somehow, scanner is thinks that it has reached the end of the file, which it's not true. Any ideas on why this is happening? I checked my Regex and it does seem to work (A words contain letters a-z and apostrophes). Thanks!

Scanner is dividing the text up into "tokens". The default token separator is whitespace. When your program stops, the current token is bank, When you compare that against your .hasNext() regex, it is not matching due to the extra comma on the end.

A solution may be keep the scanner using whitespace token separator for both .hasNext() and .next() methods and apply the regex on the println statement.

while(s.hasNext()) {
   Matcher m = wordPattern.matcher(s.next());
   if (m.find()) {
       System.out.println("word:" + m.group(0))
   }
}

scanner's hasNext is mostly useless.

Scanner works like this:

1. Anytime where relevant (either on any next() / nextX() call, or any hasNext call, but not nextLine(), ensure that scanner is aware of the 'next token in the queue'. If there isn't one already, then go read read another token from the feed. This is done by completely disregarding what is asked for, and instead scanning for either end-of-stream, or the 'delimiter' (which, by default, is 'any whitespace'). everything up to then is the next token.
2. hasX() checks the token that is next in line and returns true or false depending on whether it matches or not. It has nothing to do with whether there is any data left to read.
3. nextLine ignores all this and doesn't work well with anything else in scanner.

So, you're calling hasNext, and hasNext is faithfully reporting: Well, the next token in line is bank, and that doesn't match the regexp, so returns false. Just as the docs say.

Solution

Forget hasX, you don't want those. You also never want nextLine. Scanner works best if you change the delimiter if the delimiter is no good (i.e. never invoke nextLine, invoke useDelimiter("\r?\n") and next() instead), and call .nextX() methods. And that is all you ever do with it.

So, just invoke next(), check that it matches or not, and keep going.