Is there a standard java exception class that means "The object was not found"?

Question

Consider a function of the following general form:

Foo findFoo(Collection<Foo> foos, otherarguments)
throws ObjectNotFoundException {
    for(Foo foo : foos){
        if(/* foo meets some condition*/){
            return foo;
        }
    }
    throw new ObjectNotFoundException();
}

A concrete case, for example, would be:

User findUserByName(Collection<User> users, String name)
throws ObjectNotFoundException {
    for(User user : users){
        if(user.getName().equals(name)){
            return user;
        }
    }
    throw new ObjectNotFoundException();
}

These functions throw an exception if the object is not found. I can create a custom exception class for this purpose (in the examples, ObjectNotFoundException) but I would prefer to use an existing class. However, I could not find any exception class with this meaning in the standard java library. Do you know if there is a standard exception that can be used here?

And why do you insist on the JDK providing the exception when it is three lines of code to provide it yourself? I don't know what APIs you are additionally working with; JPA provides a "NoResultException" for example. — Gimby, Jul 15 '14 at 14:06
I would go for: `IllegalArgumentException` as the docs says: `Thrown to indicate that a method has been passed an illegal or inappropriate argument.` Which is in fact what is happening. — Jorge Campos, Jul 15 '14 at 14:06
IMHO It's better to create custom exception that is relevant to the context of your method/class/layer/application, but if you insist you can use `NoSuchElementException` — Svetlin Zarev, Jul 15 '14 at 14:06
@Gimby At what point was OP "insisting" that the JDK provide the exception? OP stated a preference and asked a question. Moreover three lines of code, becomes longer when appropriately documented. And why bother *if* the JDK already provides it? — pamphlet, Jul 15 '14 at 14:10

Stephen C · Accepted Answer · 2016-06-17T02:50:24.083

Do you know if there is a standard exception that can be used here?

There are a couple of exceptions that could be used (e.g. NoSuchElementException or IllegalArgumentException) but the answer really depends on the semantics that you intend to convey:

NoSuchElementException tends to be used when you are stepping through an sequence or enumeration, where what you have here is a lookup.
IllegalArgumentException tends to imply that the argument is in error, but in this case, it could be that the assumptions of the caller are incorrect, or something that is specific to the application logic.
A custom exception allows you to say (in the javadocs) exactly what the exception means. You can also declare it to be checked ... if that it appropriate.

(But don't be tempted to use UnknownUserException. That would be horribly wrong; read the javadoc!)

It is also worth considering returning null, especially if lookup failure is likely to be a fairly common (non-exceptional) event in your application. However, the downside of returning null is that the caller needs to check for null or risk unexpected NullPointerExceptions. Indeed, I would argue that over-use of null is worse than over-use of exceptions. The former can result in unreliable applications, whereas the latter is "only" bad for performance.

For Java 8 and onwards, returning an Optional would be a cleaner choice than returning a null.

In these things, it is important to look beyond the dogmas, and make up your mind based on what the actual context requires.

score 7 · Answer 2 · edited Mar 08 '16 at 16:08

7

IllegalArgumentException is sometimes used here but using your own Exception is perfectly fine.

As an aside I'd recommend using a Map with String name as the key and User as the value. Iterating over the collection would then be unnecessary and it would prevent having two users with the same name in the collection. If you don't want to use a Map then at least defend against NullPointerException like so:

User findUserByName(Collection<User> users, String name) throws ObjectNotFoundException
{
  if (name == null)
  {
    throw new IllegalArgumentException("name parameter must not be null");
  }
  if (users == null)
  {
    throw new IllegalArgumentException("Collection of users must not be null");
  }
  for(User user : users)
  {
    if(name.equals(user.getName()))
    {
      return user;
    }
  }
  throw new ObjectNotFoundException("Unable to locate user with name: " + name);
}

edited Mar 08 '16 at 16:08

Jeremy Gosling

1,130
10
11

answered Jul 15 '14 at 14:16

Paul

19,704
14
78
96

Late comment. It is debatable whether you should "defend" against `null` and NPEs. The alternative viewpoint is that when a `null` is passed to an API method that is not *documented* as allowing `null`, then that is a BUG, and you *should* throw the NPE (as the most specific exception for that condition). Preventing the NPE entirely (e.g. by trying to "make good") or throwing a different exception will not help, and *may* make things worse by hiding a problem that should be brought to the attention of the developer / maintainer. – Stephen C Jun 17 '19 at 00:12
In this example, it doesn't make any difference if you throw a `NullPointerException` or an `IllegalArgumentException`. Both are unchecked exceptions, and both *should* cause the caller to "bail out" with a stacktrace for the developer to look at. So, at least the `users == null` check is redundant. (NPE is your friend, not your enemy!) – Stephen C Jun 17 '19 at 00:15

score 5 · Answer 3 · answered Apr 03 '17 at 15:01

With Java 8, I would recommend using an Optional for this use case.

Optional<User> findUserByName(Collection<User> users, String name){
    Optional<User> value = users
        .stream()
        .filter(a -> a.equals(name))
        .findFirst();
}

This also makes it very clear to the caller that the optional can be empty if the value is not found. If you really want to throw an exception, you can use orElseThrows in Optional to achieve it.

score 4 · Answer 4 · answered Jul 15 '14 at 14:10

It depends on your method's documented interface contract:

If your method's documentation states that the name argument must correspond to the name of an existing user, then it's appropriate to throw IllegalArgumentException if the name isn't found, because it means the caller violated the method's requirements by passing a name that doesn't correspond to a user.

If your method doesn't say that the name must correspond to an existing user, then passing an unknown name is not an error and you shouldn't throw an exception at all. Returning null would be appropriate in this situation.

Note that your findUserByName method is basically reinventing the Map.get method, which returns null if the specified key isn't found.

Is there a standard java exception class that means "The object was not found"?

4 Answers4

Linked

Related