How To Withdraw Objects Or Elements Piece Iterating Over Arraylist Inwards Coffee - The Correct Way

One of the mutual problems many Java Programmers expression upwards is to remove elements piece iterating over ArrayList inward Java because the intuitive solution doesn't operate e.g. you lot but cannot become through an ArrayList using a for loop as well as take away an chemical component subdivision depending upon about condition. Even though java.util.ArrayList provides remove() methods e.g. remove (int index) as well as remove (Object element), you lot cannot role them to take away elements piece iterating over ArrayList inward Java because they volition throw ConcurrentModificationException if called during iteration. The correct agency to take away objects from ArrayList piece iterating over it is yesteryear using the Iterator's remove() method.

When you lot role iterator's remove() method, ConcurrentModfiicationException is non thrown. because it too updates the counters as well as variables used yesteryear Iterator similar modCount which yell for that alteration is done yesteryear the Iterator itself as well as non somewhere around.

In this article, I'll demonstrate you lot an instance of both ways as well as how they operate inward Java. You'll too larn a picayune combat well-nigh java.util.ConcurrentModificationException, which is a mutual occupation for non-concurrent collection classes similar ArrayList or HashMap.

Though, if you lot are completely novel to Java as well as coming from a non-programming background, I advise you lot to get-go become through a comprehensive Java course of written report similar The Complete Java MasterClass instead of learning from arbitrary articles.

The course of written report provides structured learning which is both efficient as well as industrial plant groovy for beginners. Once you lot know the fundamentals, you lot tin larn whatever theme yesteryear reading a weblog postal service or private tutorial, they volition brand to a greater extent than feel yesteryear thus also

1. ArrayList remove() method Example

Now, let's run across an instance of removing elements from ArrayList piece looping using for() loop as well as ArrayList.remove() method which is incorrect as well as the programme volition throw ConcurrentModificationExcetpion upon execution.

import java.util.ArrayList; import java.util.List;  /*  * Java Program to take away an chemical component subdivision piece iterating over ArrayList  */  public class Main {    public static void main(String[] args) throws Exception {      List<String> loans = new ArrayList<>();     loans.add("personal loan");     loans.add("home loan");     loans.add("auto loan");     loans.add("credit business loan");     loans.add("mortgage loan");     loans.add("gold loan");      // printing ArrayList earlier removing whatever element     System.out.println(loans);      // removing chemical component subdivision using ArrayList's take away method during iteration     // This volition throw ConcurrentModification      for (String loan : loans) {       if (loan.equals("personal loan")) {         loans.remove(loan);       }     }      // printing ArrayList subsequently removing an element     System.out.println(loans);   }  }

Output
Exception inward thread "main" [personal loan, abode loan, machine loan, credit business loan, mortgage loan, gilded loan]
java.util.ConcurrentModificationException
at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:859)
at java.util.ArrayList$Itr.next(ArrayList.java:831)
at Main.main(Main.java:26)


Some of you lot may wonder that nosotros are getting ConcurrentModificationException because nosotros are non using the Iterator, but that's non true, fifty-fifty if you lot role Iterator you lot volition acquire java.util.ConcurrentModificationException equally long equally you lot volition role ArrayList's remove() method for removing chemical component subdivision piece iterationg equally shown inward next example:

Iterator<String> itr = loans.iterator();     piece (itr.hasNext()) {       String loan = itr.next();       if (loan.equals("personal loan")) {         loans.remove(loan);       }     }

Exception inward thread "main" java.util.ConcurrentModificationException
at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:859)
at java.util.ArrayList$Itr.next(ArrayList.java:831)
at Main.main(Main.java:29)


In monastic nation to produce higher upwards code, you but involve to take away the loans.remove(loan) amongst itr.remove() method, which is explained inward the side yesteryear side example. Though, if you lot desire to know to a greater extent than well-nigh Iterator as well as inward full general Java Collection Framework, which tin experience daunting sometimes, I advise you lot become through iterating over it.

import java.util.ArrayList;

import java.util.Iterator; import java.util.List;  /*  * Java Program to take away an chemical component subdivision piece iterating over ArrayList  */  public class Main {    public static void main(String[] args) throws Exception {      List<String> loans = new ArrayList<>();     loans.add("personal loan");     loans.add("home loan");     loans.add("auto loan");     loans.add("credit business loan");     loans.add("mortgage loan");     loans.add("gold loan");      // printing ArrayList earlier removing whatever element     System.out.println(loans);      // removing chemical component subdivision using ArrayList's take away method during iteration     // This volition throw ConcurrentModification      Iterator<String> itr = loans.iterator();     while (itr.hasNext()) {       String loan = itr.next();       if (loan.equals("personal loan")) {         itr.remove();       }     }      // printing ArrayList subsequently removing an element     System.out.println(loans);   }  }

Output
[personal loan, abode loan, machine loan, credit business loan, mortgage loan, gilded loan]
[home loan, machine loan, credit business loan, mortgage loan, gilded loan]

From the output, you lot tin run across that "personal loan" chemical component subdivision is removed from the ArrayList. Size of the ArrayList is too reduced yesteryear i as well as at that topographic point is no ConcurrentModficiationException inward the code.


That's all well-nigh how to take away elements piece iterating over ArrayList inward Java. As I convey said that if you lot role ArrayList's remove() method like remove(int index) or remove(Object obj) piece iterating over ArrayList thus a ConcurrentModfiicationException volition survive thrown. You tin avoid that yesteryear using Iterator's remove() method, which removes the electrical flow object inward the iteration.

Further Learning
The Complete Java Masterclass
tutorial)

How to produce as well as initialize ArrayList inward the same line? (example)

Difference betwixt ArrayList as well as HashSet inward Java? (answer)

Difference betwixt an Array as well as ArrayList inward Java? (answer)

How to contrary an ArrayList inward Java? (example)

How to loop through an ArrayList inward Java? (tutorial)

How to synchronize an ArrayList inward Java? (read)

When to role ArrayList over LinkedList inward Java? (answer)

Difference betwixt ArrayList as well as HashMap inward Java? (answer)

Difference betwixt ArrayList as well as Vector inward Java? (answer)

How to variety an ArrayList inward descending monastic nation inward Java? (read)

How to acquire sublist from ArrayList inward Java? (example)

How to convert CSV String to ArrayList inward Java? (tutorial)

Thanks for reading this article thus far. If you lot similar this article thus delight portion amongst your friends as well as colleagues. If you lot convey whatever questions or feedback thus delight drib a note. If you lot like, you lot tin too follow me on Twitter, my id is @javinpaul.

Share this post