An IllegalStateException is a runtime exception in Java that is thrown to indicate that a method has been invoked at an illegal or inappropriate time.
To use an analogy, invoking a method in Java when the system is not in the appropriate state is like trying to start a car while it is in "Drive". Just as the car will not start because it is unsafe, a method call results in an IllegalStateException when the internal conditions necessary for its execution are not met.
What Causes IllegalStateException
The IllegalStateException is thrown when the Java environment or application is not in an appropriate state for the requested operation. This can occur when dealing with threads or the Collections framework of the java.util package under specific conditions.
Here are examples of some methods where this exception can occur when they are called at the wrong time:
- Thread.start(): When the
Thread.start()method is called on a thread that has already been started. - Iterator.remove(): When the
remove()method of theIteratorinterface is called on aListwithout calling thenext()method. This leaves theListcollection in an unstable state, causing anIllegalStateException. - Queue.add(): If an element is attempted to be added to a
Queuethat is full. Adding elements beyond the size of the queue will cause anIllegalStateException.
IllegalStateException Examples
Example One
Here’s an example of an IllegalStateException thrown when the Iterator.remove() method is called to remove an element from an ArrayList before calling the next() method:
import java.util.ArrayList;
import java.util.Iterator;
public class IllegalStateExceptionExample {
public static void main(String args[]) {
ArrayList<String> list = new ArrayList<String>();
list.add("a");
list.add("b");
list.add("c");
Iterator<String> it = list.iterator();
it.remove(); //Trying to remove element from list before calling it.next()
}
}
Since the remove() method is used to remove the previous element being referred to by the Iterator, the next() method should be called before an element is attempted to be removed. In this case, the next() method was never called, so the Iterator attempts to remove the element before the first element.
Since this action is illegal, running the above code throws an IllegalStateException:
Exception in thread "main" java.lang.IllegalStateException
at java.base/java.util.ArrayList$Itr.remove(ArrayList.java:980)
at IllegalStateExceptionExample.main(IllegalStateExceptionExample.java:12)
Example Two
Here’s an example of an IllegalStateException thrown trying to add an element to a Queue that is already full:
import java.util.Queue;
import java.util.concurrent.ArrayBlockingQueue;
public class IllegalStateExceptionExample {
public static void main(String[] args) {
Queue<Integer> queue = new ArrayBlockingQueue<>(2); //Create a queue with a fixed capacity of 2
//Add two elements to fill the queue
queue.add(1);
queue.add(2);
queue.add(3); //Attempt to add another element to the full queue
System.out.println(queue);
}
}
Here, a Queue is created with a size of 2. Since 3 elements are attempted to be added to the Queue, which is beyond its size, running the above code throws an IllegalStateException:
Exception in thread "main" java.lang.IllegalStateException: Queue full
at java.base/java.util.AbstractQueue.add(AbstractQueue.java:98)
at java.base/java.util.concurrent.ArrayBlockingQueue.add(ArrayBlockingQueue.java:329)
at IllegalStateExceptionExample.main(IllegalStateExceptionExample.java:14)
How to Fix IllegalStateException
To avoid the IllegalStateException in Java, it should be ensured that any method in code is not called at an illegal or inappropriate time.
The earlier examples can be updated to ensure this:
Example One
Calling the Iterator.next() method on the ArrayList before using the remove() method to remove an element from it will help fix the issue:
import java.util.ArrayList;
import java.util.Iterator;
public class IllegalStateExceptionExample {
public static void main(String args[]) {
ArrayList<String> list = new ArrayList<String>();
list.add("a");
list.add("b");
list.add("c");
Iterator<String> it = list.iterator();
it.next(); //Calling it.next() to move iterator position before removing element from list
it.remove();
System.out.println(list);
}
}
Calling the next() method moves the Iterator position to the next element. Calling the remove() method afterwards will remove the first element in the ArrayList, which is a legal operation and helps fix the exception.
Running the above code produces the correct output as expected:
[b, c]
Example Two
The Queue.offer() function can be used instead of Queue.add() to ensure that the capacity restrictions of the Queue are not violated:
import java.util.Queue;
import java.util.concurrent.ArrayBlockingQueue;
public class IllegalStateExceptionExample {
public static void main(String[] args) {
Queue<Integer> queue = new ArrayBlockingQueue<>(2);
queue.add(1);
queue.add(2);
queue.offer(3); //Add another element to the queue if possible
System.out.println(queue);
}
}
The Queue.offer() method ensures that an element is only added to the Queue if it is possible to do so without exceeding capacity limits. Running the above code avoids the exception produces the correct output as expected:
[1, 2]
Track, Analyze and Manage Errors With Rollbar
Managing errors and exceptions in your code is challenging. It can make deploying production code an unnerving experience. Being able to track, analyze, and manage errors in real-time can help you to proceed with more confidence. Rollbar automates error monitoring and triaging, making fixing Java errors easier than ever. Try it today!
