Java NoSuchElementException

Question

So I have a pretty big java application that I wrote a year ago and I'm trying to understand it again. I'm looking at a method in the code where there is an obvious risk of getting NoSuchElementException: I'm calling .next() on a scanner variable that has been constructed with an arbitrary string. The only thing the method is declared to throw are custom made subclasses of Exception. The risky command isn't written in a catch-block either. The code compiles and works fine and when I use my gui in such a fashion that it should throw a NoSuchElementException nothing happens :O

As a test I wrote a catch-block into the code, compiled it, ran the gui and made it throw NoSuchElementException again and the application successfully caught the exception and acted accordingly. How is it that I can compile the code without specifying the this exception may be thrown? If it's any use at all, here is the code without the catch-block:

public static Expression interpret(final Scanner scanner)
  throws
    InvalidPosition,
    NoSuchSpreadsheet,
    IllegalStartOfExpression,
    InvalidExpression,
    FalseSyntax,
    InvalidRange {

String keyword = null;

try {
  keyword = scanner.next();
} catch (NoSuchElementException e) {
  throw new IllegalStartOfExpression();
}

switch(keyword) {
  case "Get":
    Position pos = PositionInterpreter.interpret(scanner.next());
    Expression expression = Application.instance.get(pos);
    if (expression instanceof Text) {
        System.out.println("Failure");
    } else { System.out.println("Success"); }
    return new Text(expression.toString());
  case "Int":
    return new Int(
      scanner.nextInt());

As you can see, the method simply assumes that there is more than one word in the scanner after checking if there is at least the one. How am I getting away with compiling this?

I don't see where I declare that the method throws it Hunter, please elaborate — user2651804, Sep 24 '13 at 18:05

codeMan · Accepted Answer · 2013-09-25T04:00:47.060

It is be cause NoSuchElementException is unchecked exception, which means that it "is-a" RuntimeException which does not force you to catch.

The unchecked exceptions classes are the class RuntimeException and its subclasses, and the class Error and its subclasses. All other exception classes are checked exception classes. The Java API defines a number of exception classes, both checked and unchecked. Additional exception classes, both checked and unchecked, may be declared by programmers. See ref for a description of the exception class hierarchy and some of the exception classes defined by the Java API and Java virtual machine.

Runtime exceptions serve the same purpose as checked exceptions; to communicate exceptional conditions (unexpected failures, etc) to the user.

checked exception forces the caller of a method to handle that exception, even if they do not know how to handle it. Often times, developers will end up catching the checked exception, only to re-throw it (or another exception). Hence the Runtime exceptions

Here is the exception hierarchy

enter image description here

score 2 · Answer 2 · answered Sep 24 '13 at 18:13

2

As the question has already been answered, I'd like to point on that this is very poor design and not the intended usage of the Scanner class:

try {
  keyword = scanner.next();
} catch (NoSuchElementException e) {
  throw new IllegalStartOfExpression();
}

What you should really be doing is ask the scanner whether there is any input, and only then retrieving it, like so:

if(scanner.hasNext()) {
    keyword = scanner.next();
}
else {
   throw new IllegalStartOfExpression();
}

The same applies to the line which is causing your problem:

if(scanner.hasNextInt()) {
    return new Integer(scanner.nextInt());
}

answered Sep 24 '13 at 18:13

MrLore

3,759
2
28
36

It seems to me that if(scanner.hasNextInt()) { return new Integer(scanner.nextInt()); } Does the exact same thing as simply: return new Integer(scanner.nextInt()); – user2651804 Sep 24 '13 at 18:19
The point is that it will only do it if there is an integer ready in the scanner, if there isn't and you don't check, you will get the `NoSuchElementException`. – MrLore Sep 24 '13 at 18:22
Yes, but apparantly that exception has no consquences at all. So the difference between getting it, and getting nothing? I can't see it – user2651804 Sep 24 '13 at 18:24
1

The point is design. `RuntimeException`s indicate serious problems that you shouldn't try to handle, in this case it's because your code is using the class incorrectly: It is intended that you check first. – MrLore Sep 24 '13 at 18:26

score 0 · Answer 3 · edited Jun 20 '20 at 09:12

java.util.NoSuchElementException is a subclass of java.lang.RuntimeException. RuntimeExceptions don't have to be handled. From the Java API documentation:

RuntimeException is the superclass of those exceptions that can be thrown during the normal operation of the Java Virtual Machine.

RuntimeException and its subclasses are unchecked exceptions. Unchecked exceptions do not need to be declared in a method or constructor's throws clause if they can be thrown by the execution of the method or constructor and propagate outside the method or constructor boundary.

Java NoSuchElementException

3 Answers3

Linked