1z0-819 Exam - Question 170

Question

Given:Which two code fragments remove the elements from the original list? (Choose two. ).

Examice · Accepted Answer

To remove elements from the original list without causing a ConcurrentModificationException, we must avoid modifying the list directly while iterating over it with a for-each loop. The best way to achieve this is by ensuring that the list modifications are thread-safe or handled in such a way that doesn’t lead to concurrent issues. ConcurrentLinkedQueue (option A) allows thread-safe operations and does not throw a ConcurrentModificationException during removal while iterating. Using Collections.synchronizedList (option D) manually synchronizes the iteration and removal operations, preventing concurrent access issues. Hence, these two options successfully remove elements from the original list.

Stavok · Answer

C creates a new CopyOnWriteArrayList from the original list and then iterates over it, removing each element. The CopyOnWriteArrayList class is thread-safe and allows for concurrent modification, so it is safe to remove elements while iterating over it.

Option A is incorrect because ConcurrentLinkedQueue does not have a remove method that takes an object as an argument.

[Removed] · Answer

ArrayList & synchronizedList would throw a ConcurrentModificationException when removing elements while iterating over it.

Omnisumem · Answer

Tested AC. With a lot of modification...: import java.util.*; import java.util.concurrent.*; public class q170 { public static void main(String[] args) { List original = new ArrayList<>(Arrays.asList(1,2,3,4,5)); System.out.println(original); Queue clq = new ConcurrentLinkedQueue<>(original); for (Integer w : clq) {clq.remove(w);} System.out.println(clq); //List al = new ArrayList<>(original); //for (Integer w : al) {al.remove(w);} //System.out.println(al); List cwa = new CopyOnWriteArrayList<>(original); for (Integer w : cwa) {cwa.remove(w);} System.out.println(cwa); //List sl = Collections.synchronizedList(original); //for (Integer w : sl) {sl.remove(w);} //System.out.println(sl); } }

ASPushkin · Answer

answer: A and maybe D
A :  ConcurrentLinkedQueue is ok because it will never throw any ConcurrentModificationException, even if you remove or add item.  Note that those are all in java.util.concurrent package.
B:  For-each loops are not appropriate when you want to modify the ArrayList.  Iterator should be used.
C: is not good. 
cwa - new collection with new copy of the elements. So, it doesn't remove anything from the original.
D: looks like it can work if  put synchronized(al) before loop. Should be checked.

d7bb0b2 · Answer

Only correct is A, 
ConcurrentLinkedQueue and CopyOnWriteArrayList=> WORK A COPY not reference to list so elemments in original list are not removed 
 Collections.synchronizedList => thows excpetion

ASPushkin · Answer

A : ConcurrentLinkedQueue is ok because it will never throw any ConcurrentModificationException, even if you remove or add item. Note that those are all in java.util.concurrent package.

cathDev · Answer

Tested A C

aruni_mishra · Answer

Note: question ask which code fragments remove the elements from the "original list".
answer is None.

if question would has been which code compiles, then answer is A and C.
because 
"for-each" loop use Iterator, and with regular list, we get : ConcurrentModificationException

1z0-819 Exam - Question 170

Discussion