What is the cause of NoSuchElementException

In Java, NoSuchElementException is thrown when attempting to access an element from an iterable (such as a collection or iterator) that does not have any more elements to provide. This exception serves as a signal that the requested element does not exist in the current iteration.

The NoSuchElementException typically occurs when using methods like next() in an iterator, which returns the next element in the iteration sequence. If there are no more elements to provide, the next() method throws this exception to indicate that the iteration has reached its end.

import java.util.*; public class sample { public static void main(String[] args) { ArrayList<String> arrlist = new ArrayList<String>(); arrlist.add(new String("One")); Iterator itr = arrlist.iterator(); System.out.println(itr.next()); // Iterator has one element System.out.println(itr.next()); // Iterator is "empty" } }
One Exception in thread "main" java.util.NoSuchElementException at java.util.ArrayList$Itr.next(Unknown Source) at sample.main(sample.java:10)

How to solve NoSuchElementException?

NoSuchElementException hasNext() method

To avoid the NoSuchElementException, it's essential to use the hasNext() method to check if there are more elements in the iteration before calling the next() method. The hasNext() method returns a boolean value indicating whether the iteration has any more elements.

By checking the result of hasNext() before calling next(), you ensure that the iteration has not reached its end, and it's safe to retrieve the next element using next(). If hasNext() returns true, then you can confidently call next() to get the next element. If hasNext() returns false, it means there are no more elements in the iteration, and calling next() would result in a NoSuchElementException. The following methods are used to check the next position:

  1. hasNext()
  2. hasMoreElements()
import java.util.*; public class sample { public static void main(String[] args) { ArrayList<String> arrlist = new ArrayList<String>(); arrlist.add(new String("hello")); Iterator itr = arrlist.iterator(); while (itr.hasNext()) { System.out.println(itr.next()); } } }

This way ensures that any element is being accessed if it exists.


java nextElement()

An exception is an abnormal condition that occurs during the execution of a program, disrupting the normal flow of code execution. Exceptions can happen for various reasons, such as invalid input, division by zero, accessing elements beyond the limit, or any other unexpected situation that violates the program's normal behavior.

The NoSuchElementException is indeed an unchecked exception in Java. Being an unchecked exception, it does not need to be declared in a method's or a constructor's throws clause. Unchecked exceptions, including NoSuchElementException, are not required to be explicitly caught or declared in the method signature, providing flexibility in handling exceptions locally within the code.

Unchecked exceptions are generally used for runtime exceptions, indicating issues that can be detected only during program execution. The Java compiler does not enforce explicit handling of unchecked exceptions, making it the responsibility of the developer to handle these exceptions based on the specific requirements of their code. The full exception hierarchy of this error is:

how to solve java.util.NoSuchElementException

The java.util.NoSuchElementException is a RuntimeException which can be thrown by different classes in Java like Iterator, Enumerator, Scanner or StringTokenizer . It is thrown by the following methods:

  1. nextElement() of Enumeration interface
  2. next() of NamingEnumeration interface
  3. nextElement() of StringTokenizer class
  4. next() of Iterator interface

Similarly, the previous() method of the ListIterator returns the previous element of the collection, if this method is invoked on an empty object or at the stating position of it a NoSuchElementException is generated at the runtime.


Handling exceptions properly in a program is essential to ensure robustness and graceful error recovery. By catching and handling exceptions appropriately, you can improve the reliability and user experience of your Java applications.