How To Bargain Alongside Concurrentmodificationexception Inward Java? Beware Spell Removing Elements From Arraylist Inward Loop

One of the mutual occupation piece removing elements from an ArrayList inward Java is the ConcurrentModificationException. If you lot role classical for loop amongst the index or enhanced for loop too travail to take away an chemical component division from the ArrayList using remove() method, you lot volition acquire the ConcurrentModificationException but if you lot role Iterator's take away method or ListIterator's remove() method, so you lot won't acquire this mistake too last able to take away the element. It's an unwritten dominion inward Java that piece looping through the list, you lot should non add() or remove() elements until the collection supports fail-safe Iterator e.g. CopyOnWriteArrayList, which operate on a re-create of listing rather than the master copy list.

The principal occupation amongst this mistake is that it confuses developer that listing is getting modified yesteryear multiple threads too that's why Java is throwing this error, it's non true. Most of the fourth dimension ConcurrentModificationException comes fifty-fifty without multiple threads modifying the list.

It's misnomer, don't acquire fooled away yesteryear this. though it seems natural thinking that perhaps merely about other thread is trying to alter the collection at the same time, it's unremarkably breaking the Java rule.

In this article, I'll explicate this mistake too we'll many code instance to reproduce this code fifty-fifty amongst the unmarried thread too larn how nosotros tin avoid concurrent change mistake piece modifying an ArrayList inward Java.

Btw, if you lot are non familiar amongst collection classes e.g. ArrayList itself so you lot should bring together an online course of report e.g. Java Basics: Learn to Code the Right Way on Udemy is a practiced house to start with.

ConcurrentModificationException inward Single Thread

This is the offset instance of reproducing the concurrent change exception inward Java. In this program, nosotros are iterating over ArrayList using the enhanced foreach loop too removing selective elements e.g. an chemical component division which matches certainly status using ArrayList's remove method.

For example, inward the below code nosotros receive got offset added a duet of practiced programming books e.g. Programming Pearls, Clean Code, Effective Java, too Code Complete into ArrayList too so removing whatever chemical component division which has Code inward its title.

package beginner;  import java.util.ArrayList; import java.util.List;  public class HelloWorldApp{     public static void main(String... args){        List<String> listOfBooks = new ArrayList<>();          listOfBooks.add("Programming Pearls");        listOfBooks.add("Clean Code");        listOfBooks.add("Effective Java");        listOfBooks.add("Code Complete");                // Using forEach loop to iterate too removing         // chemical component division during iteration volition throw         // ConcurrentModificationException inward Java        for(String book: listOfBooks){            if(book.contains("Code"));{                listOfBooks.remove(book);            }        }    }  } Output Exception in thread "main" java.util.ConcurrentModificationException     at java.util.ArrayList$Itr.checkForComodification(Unknown Source)     at java.util.ArrayList$Itr.next(Unknown Source)     at beginner.HelloWorldApp.main(HelloWorldApp.java:18)

You tin run into that this mistake comes fifty-fifty though nosotros merely receive got i thread, principal thread which is operating amongst ArrayList. The ConcurrentModification mistake comes because nosotros are non using Iterator, instead merely calling listOfBooks.remove() method.

In this code, I receive got used Java 1.5 enhanced for loop, you lot must know how enhanced for loop works inward Java.

Difference betwixt for loop too enhanced for loop is that afterward internally uses an Iterator for going over all elements of a collection. For a to a greater extent than in-depth discussion, run into here

Using Classical for loop too ArrayList.remove(index)

Here is merely about other interesting code instance of removing elements from ArrayList. Surprisingly this code volition non throw ConcurrentModificationException when you lot offset run it? make you lot know why?

Well, travail it earlier you lot expression at the explanation after the code. It's truly this sort of tiddler details virtually Java programming linguistic communication too Collection framework, which volition brand you lot a practiced developer, too too assistance you lot to acquire your Java certification if you lot are preparing for it.

package beginner;  import java.util.ArrayList; import java.util.List;  public class HelloWorldApp{     public static void main(String... args){        List<String> listOfBooks = new ArrayList<>();          listOfBooks.add("Programming Pearls");        listOfBooks.add("Clean Code");        listOfBooks.add("Effective Java");        listOfBooks.add("Code Complete");                System.out.println("List earlier : " + listOfBooks);        for(int i=0; i<listOfBooks.size(); i++){            String mass = listOfBooks.get(i);            if(book.contains("Programming")){                System.out.println("Removing " + book);                listOfBooks.remove(i); // volition throw CME            }        }        System.out.println("List after : " + listOfBooks);    }  }  Output List earlier : [Programming Pearls, Clean Code, Effective Java, Code Complete] Removing Programming Pearls List after : [Clean Code, Effective Java, Code Complete]

This code doesn't throw ConcurrentModificationException because hither nosotros are not using Iterator but nosotros are merely using traditional for loop.

It's the Iterator which throws ConcurrentModificationException, too non the take away method of ArrayList, thence you lot don't run into that mistake inward below code.

If you lot expression at the code for ArrayList.java, you lot volition notice that at that spot is a nested course of report which implemented Iterator interface too it's next() method calls checkForComodification() business office which truly checks if ArrayList has modified during iteration or not, if modCount doesn't gibe amongst expectedModCount so it throws ConcurrentModificationException.

final void checkForComodification() {   if (modCount != expectedModCount)     throw new ConcurrentModificationException(); }

This sort of questions are too really pop on Oracle Java Certification e.g. OCAJP (1z0-808) too OCPJP (1Z0-809), so if you lot are preparing for those exams, you lot should know the answer.

Here is the amount code snippet from the ArrayList.java course of report for your quick reference:

Using Iterator but ArrayList's take away method

Now, let's run into merely about other code example, where Java programmer thinks he has done everything correct but yet getting the concurrent change exception. Can you lot spot the error? It's truly mutual too I receive got seen this sort of code a lot of fourth dimension on Java forums, StackOverflow too on Facebook Java groups where they asked to prepare the problem.

package beginner;  import java.util.ArrayList; import java.util.Iterator; import java.util.List;  public class HelloWorldApp{     public static void main(String... args){        List<String> listOfBooks = new ArrayList<>();          listOfBooks.add("Programming Pearls");        listOfBooks.add("Clean Code");        listOfBooks.add("Effective Java");        listOfBooks.add("Code Complete");                Iterator<String> iterator = listOfBooks.iterator();        while(iterator.hasNext()){            String mass = iterator.next();            listOfBooks.remove(book);        }    }  }  Output Exception in thread "main" java.util.ConcurrentModificationException     at java.util.ArrayList$Itr.checkForComodification(Unknown Source)     at java.util.ArrayList$Itr.next(Unknown Source)     at beginner.HelloWorldApp.main(HelloWorldApp.java:18)

The existent occupation amongst this code is that fifty-fifty though the code is using Iterator to become over ArrayList, it's non truly using the Iterator.remove() method to take away the element. It is merely using Iterator to acquire the side yesteryear side chemical component division but calling the ArrayList.remove() method to delete the element.

I know, it looks slow when you lot know the argue but inward existent time, many times programmer receive got fifty-fifty hours to figure out what is wrong. So, merely beware of that.

Btw, if you lot are learning Java so I advise joining Complete Java Masterclass to larn Java amend too avoid such mutual errors.

Right agency to take away chemical component division is yesteryear using Iterator's take away method

Finally, hither is the correct agency to delete an chemical component division from ArrayList during iteration. In this example, nosotros receive got used Iterator both iterate every bit good every bit take away the element. The code is ok but it has a serious limitation, you lot tin solely role this code to take away the electrical flow element. You cannot take away whatever arbitrary chemical component division from ArrayList inward Java.

package beginner;  import java.util.ArrayList; import java.util.Iterator; import java.util.List;  public class HelloWorldApp{     public static void main(String... args){        List<String> listOfBooks = new ArrayList<>();          listOfBooks.add("Programming Pearls");        listOfBooks.add("Clean Code");        listOfBooks.add("Effective Java");        listOfBooks.add("Code Complete");                System.out.println("List earlier : " + listOfBooks);        Iterator<String> iterator = listOfBooks.iterator();        while(iterator.hasNext()){            String mass = iterator.next();            System.out.println("Removing " + book);            iterator.remove();        }        System.out.println("List after : " + listOfBooks);    }  } Output List earlier : [Programming Pearls, Clean Code, Effective Java, Code Complete] Removing Programming Pearls Removing Clean Code Removing Effective Java Removing Code Complete List after : []

The same behaviour is applicable to ListIterator every bit well. I hateful you lot tin supervene upon Iterator amongst ListIterator too code volition operate fine. The ListIterator too allow you lot to navigate inward both directions i.e. forrard too backward.

That's all virtually how to avoid ConcurrentModificationException piece removing elements from ArrayList during iteration. You tin role the same technique to avoid ConcurrentModificationException piece removing elements from whatever other collection classes which receive got fail-fast Iterator e.g. LinkedList. Btw, if you lot are novel to Java programming so joining a good, comprehensive course of report like Java Basics: Learn to Code the Right Way on Udemy tin assistance you lot to larn Java amend too quicker.

Other Java troubleshooting Guides you lot may like
How to solve ArrayIndexOutOfBoundsException inward Java? (guide)
How to solve NullPointerException inward Java? (guide)
How to solve the "System cannot discovery the Path specified" error? (solution)
How to solve NoClassDefFoundError piece running Java programme from a ascendance line? (solution)
How to solve "No JVM found, Please install 64-bit JDK" mistake inward Android Studio? (solution)
How to bargain amongst SQLException "No Suitable driver industrial plant life " mistake inward JDBC too MySQL? (guide)
How to solve NumberFormatException inward Java? (guide)
How to solve Minecraft - java.lang.UnsatisfiedLinkError: lwjgl64.dll : Access Denied? (solution)
How to prepare java.lang.ArrayIndexOutOfBoundsException: 1 inward Java? (solution)
How to prepare java.net.SocketException: Software caused connector abort: recv failed (fix)

Thanks for reading this tutorial, if you lot similar this tutorial so delight part amongst your friends too colleagues.  If you lot receive got whatever query or proposition so delight driblet a comment. 

Bagikan Artikel ini