How To Bargain Amongst Concurrentmodificationexception Inwards Java? Beware Spell Removing Elements From Arraylist Inwards Loop

One of the mutual occupation field removing elements from an ArrayList inwards Java is the ConcurrentModificationException. If yous piece of work classical for loop alongside the index or enhanced for loop too endeavour to take away an chemical cistron from the ArrayList using remove() method, yous volition acquire the ConcurrentModificationException but if yous piece of work Iterator's take away method or ListIterator's remove() method, so yous won't acquire this mistake too live on able to take away the element. It's an unwritten dominion inwards Java that field looping through the list, yous 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 original list.

The original occupation alongside this mistake is that it confuses developer that listing is getting modified past times 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 past times this. though it seems natural thinking that peradventure simply 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 event to reproduce this code fifty-fifty alongside the unmarried thread too acquire how nosotros tin give notice avoid concurrent alteration mistake field modifying an ArrayList inwards Java.

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

ConcurrentModificationException inwards Single Thread

This is the kickoff event of reproducing the concurrent alteration exception inwards Java. In this program, nosotros are iterating over ArrayList using the enhanced foreach loop too removing selective elements e.g. an chemical cistron which matches certainly status using ArrayList's remove method.

For example, inwards the below code nosotros guide maintain kickoff added a twosome of skillful programming books e.g. Programming Pearls, Clean Code, Effective Java, too Code Complete into ArrayList too so removing whatever chemical cistron which has Code inwards 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 cistron during iteration volition throw         // ConcurrentModificationException inwards 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 give notice run into that this mistake comes fifty-fifty though nosotros simply guide maintain i thread, original thread which is operating alongside ArrayList. The ConcurrentModification mistake comes because nosotros are non using Iterator, instead simply calling listOfBooks.remove() method.

In this code, I guide maintain used Java 1.5 enhanced for loop, yous must know how enhanced for loop plant inwards Java.

Difference betwixt for loop too enhanced for loop is that afterwards 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 simply about other interesting code event of removing elements from ArrayList. Surprisingly this code volition non throw ConcurrentModificationException when yous kickoff run it? make yous know why?

Well, endeavour it earlier yous human face at the explanation after the code. It's genuinely this variety of fry details near Java programming linguistic communication too Collection framework, which volition brand yous a skillful developer, too too help yous to acquire your Java certification if yous 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 simply using traditional for loop.

It's the Iterator which throws ConcurrentModificationException, too non the take away method of ArrayList, so yous don't run into that mistake inwards below code.

If yous human face at the code for ArrayList.java, yous volition notice that at that spot is a nested cast which implemented Iterator interface too it's next() method calls checkForComodification() business office which genuinely checks if ArrayList has modified during iteration or not, if modCount doesn't fit alongside expectedModCount so it throws ConcurrentModificationException.

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

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

Here is the sum code snippet from the ArrayList.java cast for your quick reference:

Using Iterator but ArrayList's take away method

Now, let's run into simply about other code example, where Java programmer thinks he has done everything correct but yet getting the concurrent alteration exception. Can yous spot the error? It's genuinely mutual too I guide maintain seen this variety of code a lot of fourth dimension on Java forums, StackOverflow too on Facebook Java groups where they asked to cook 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 alongside this code is that fifty-fifty though the code is using Iterator to acquire over ArrayList, it's non genuinely using the Iterator.remove() method to take away the element. It is simply using Iterator to acquire the side past times side chemical cistron but calling the ArrayList.remove() method to delete the element.

I know, it looks slowly when yous know the argue but inwards existent time, many times programmer accept fifty-fifty hours to figure out what is wrong. So, simply beware of that.

Btw, if yous are learning Java so I propose joining Complete Java Masterclass to acquire Java ameliorate too avoid such mutual errors.

Right means to take away chemical cistron is past times using Iterator's take away method

Finally, hither is the correct means to delete an chemical cistron from ArrayList during iteration. In this example, nosotros guide maintain used Iterator both iterate equally good equally take away the element. The code is ok but it has a serious limitation, yous tin give notice alone piece of work this code to take away the electrical current element. You cannot take away whatever arbitrary chemical cistron from ArrayList inwards 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 equally well. I hateful yous tin give notice supervene upon Iterator alongside ListIterator too code volition piece of work fine. The ListIterator too allow yous to navigate inwards both directions i.e. forrard too backward.

That's all near how to avoid ConcurrentModificationException field removing elements from ArrayList during iteration. You tin give notice piece of work the same technique to avoid ConcurrentModificationException field removing elements from whatever other collection classes which guide maintain fail-fast Iterator e.g. LinkedList. Btw, if yous are novel to Java programming so joining a good, comprehensive course of written report like Java Basics: Learn to Code the Right Way on Udemy tin give notice help yous to acquire Java ameliorate too quicker.

Other Java troubleshooting Guides yous may like
How to solve ArrayIndexOutOfBoundsException inwards Java? (guide)
How to solve NullPointerException inwards Java? (guide)
How to solve the "System cannot honour the Path specified" error? (solution)
How to solve NoClassDefFoundError field running Java computer programme from a ascendence line? (solution)
How to solve "No JVM found, Please install 64-bit JDK" mistake inwards Android Studio? (solution)
How to bargain alongside SQLException "No Suitable driver constitute " mistake inwards JDBC too MySQL? (guide)
How to solve NumberFormatException inwards Java? (guide)
How to solve Minecraft - java.lang.UnsatisfiedLinkError: lwjgl64.dll : Access Denied? (solution)
How to cook java.lang.ArrayIndexOutOfBoundsException: 1 inwards Java? (solution)
How to cook java.net.SocketException: Software caused connectedness abort: recv failed (fix)

Thanks for reading this tutorial, if yous similar this tutorial so delight part alongside your friends too colleagues.  If yous guide maintain whatever inquiry or proposition so delight drib a comment.