How to resolve IllegalStateException in Java?

An exception is an unwanted and unexpected error thrown in the program. Most of the time, an exception occurs when there is an error in our code but it can be handled. It disrupts the normal flow of the code.

For example, the code throws an exception if the user has entered invalid information, if the code is unable to read the file located at the remote place, or if the network connection is lost in the middle of the communication.

IllegalStateException in Java

IllegalStateExceptionis the sub-class of RuntimeException class, and therefore it is an unchecked exception. It is raised by the programmer or by the API developer explicitly. It is thrown when a method call illegal or a method is called at incorrect time.

For example, once we start a thread, we cannot restart the same thread again; if we try to do that, it throws a runtime exception i.e., IllegalStateException.

The exception may arise in the code usually when we are working with the Collections framework. The List, Queue, Maps, Tree are some of the collections. Out of these, List and Queues tend to throw the illegal state exception at the specific conditions.

Note: IllegalStateException exception is not just limited to the Collections framework.

Let's see some of the scenario where the IllegalStateException will be thrown.

Example 1:

The following Java program depicts the situation where we try to call the start() method when the run() method is already executing.

IllegalStateExceptionTest1.java

// importing necessary packages
import java.io.*;
import java.util.*;
// creating a new thread in NewThread class by extending Thread class
// below class is acts as a helper class
class NewThread extends Thread {
// declaring the run() method
// executes 3 times using for loop
public void run()
{
for (int i = 0; i < 3; i++) {
// displaying the text
System.out.println("This is example of IllegalStateException");
}
}
}
// creating main class
public class IllegalStateExceptionTest1 {
// main  method
public static void main(String[] args)
{
// creating the object of above helper class NewThread
NewThread t = new NewThread();
// starting the above created thread using the start() method
t.start();
// displaying the text
System.out.println("This is main thread");
// starting the thread again when it is already running
// this gives an exception
t.start();
}
}

Output:

How to resolve IllegalStateException in Java

Example 2:

The following code depicts the situation where we call the start() method on a thread when the execution of run() method is over.

IllegalStateExceptionTest2.java

// importing necessary packages
import java.io.*;
import java.util.*;
// creating a new thread in NewThread class by extending Thread class
// below class is acts as a helper class
class NewThread extends Thread {
// declaring the run() method
// executes 3 times using for loop
public void run()
{
for (int i = 0; i < 3; i++) {
// displaying the text
System.out.println("This is example of IllegalStateException");
}
}
}
// creating main class
public class IllegalStateExceptionTest2 {
// main  method
public static void main(String[] args)
{
// creating the object of above helper class NewThread
NewThread t = new NewThread();

// starting the above created thread using the start() method
t.start();
try {
System.out.println("Main thread is going to sleep");
// putting the main thread on sleep for 4000ms
t.sleep(4000);
System.out.println("Main thread is awaken");
}
catch (Exception e) {
System.out.println(e);
}
// displaying the message
System.out.println("This is main thread");
// calling the start() method over a dead thread
// this also gives an exception
t.start();
}
}

Output:

Example 3:

The following code explains the situation where we are using the remove() method to remove the element from the ArrayList, before moving to the first element.

IllegalStateExceptionTest3.java

// importing necessary packages
import java.util.ArrayList;
import java.util.ListIterator;

// creating the main class
public class IllegalStateExceptionTest3 {
// main method
public static void main(String args[]) {
// instantiating the object of ArrayList
ArrayList<String> list = new ArrayList<String>();
// adding elements to the ArrayList
list.add("Nirnay");
list.add("Anu");
list.add("Swara");
list.add("Pavan");
// creating the iterator object to iterate the list
ListIterator <String> it = list.listIterator();
// removing the element without moving to first position
// gives an exception
it.remove();
}
}

Output:

Solution for the IllegalStateException

To avoid the java.lang.IllegalStateException in Java we should take care that any method in our code cannot be called at inappropriate or illegal time.

Solution for example 1 and 2:

Consider the above example 1 and 2 where we have called the start() method more than once. If we call it only once, we will not get this exception. Because start() method is not called after starting the thread.

IllegalStateExceptionSolution.java

// importing necessary packages
import java.io.*;
import java.util.*;
// creating a new thread in NewThread class by extending Thread class
// below class is acts as a helper class
class NewThread extends Thread {
// declaring the run() method
// executes 3 times using for loop
public void run()
{
for (int i = 0; i < 3; i++) {
// displaying the text
System.out.println("This is example of IllegalStateException");
}
}
}
// creating main class
public class IllegalStateExceptionSolution {
// main  method
public static void main(String[] args)
{
// creating the object of above helper class NewThread
NewThread t = new NewThread();
// starting the above created thread using the start() method
t.start();
try {
System.out.println("Main thread is going to sleep");
// putting the main thread on sleep for 4000ms
t.sleep(4000);
System.out.println("Main thread is awaken");
}
catch (Exception e) {
System.out.println(e);
}
// displaying the message
System.out.println("This is main thread");
// we do not call start() method again
}
}

Output:

Solution for Example 3:

The remove() method of the ArrayList class is used to remove the last element after calling the next() method.

After removing element at current index we have to move next element to remove it. (for every call of the next() method, we have to invoke the remove() method only once).
As the initial position of list will be before the first element, we cannot call the remove() method without calling the next() method.

In order to prevent the exception we need to follow the above steps in our Java code.

IllegalStateExceptionSolution2.java

// importing necessary packages
import java.util.ArrayList;
import java.util.ListIterator;
// creating the main class
public class IllegalStateExceptionSolution2 {
// main method
public static void main(String args[]) {
// instantiating the object of ArrayList
ArrayList<String> list = new ArrayList<String>();
// adding elements to the ArrayList
list.add("Nirnay");
list.add("Anu");
list.add("Swara");
list.add("Pavan");
// creating the iterator object to iterate the list
ListIterator <String> it = list.listIterator();
// using the next() method before remove()
it.next();
// removing the element without moving to first position
it.remove();
// displaying new ArrayList
System.out.println("List after removing the first element: "
+ list);
}
}

Output: