Develop Reference

Is it safe clear a Set in a loop if it finds the correct value?

I'm in this situation: if I find a specific value in a HashSet, I have to update a field, clear the set and return the field.
Here one example:
static Set<Integer> testSet = new HashSet<>();
static Integer myField = null; // the field could be already != null
public static int testClearSet()
{
for (int i = 0; i < 100; i++) { // this is just for the test
testSet.add(i);
}
for (Integer n : testSet) {
if (n == 50) {
myField = n;
testSet.clear();
return myField;
}
}
return -1;
}
I'm wondering if doing this to the set it's safe, considering the fact that later on I should reuse the set.
I'm asking this, because I knew that to make changes over a Collection while iterating, is not a "good practice", but this case I think is a little bit different.
A possible solution would be:
boolean clear = false;
for (Integer n : testSet) {
if (n == 50) {
myField = n;
clear = true;
break;
}
}
if (clear) {
testSet.clear();
return myField;
}
So, which one is the right way?

It should be safe to remove elements from a set when using an explicit iterator. Hence the following should be safe:
Iterator<Integer> iterator = testSet.iterator();
while (iterator.hasNext()) {
Integer element = iterator.next();
if (element.intValue() == 50) {
testSet.clear();
break;
}
}

A ConcurrentModificationException is only thrown if you continue iterating after changing it manually.
What you do is change it and abort iterating, so it should be 100% safe (regardless of the for-each implementation).
The real issue is, the readability of the code. A piece of code should ideally do one job, and if this job is complicated, split it up. In particular, your code has two parts, a condition and an action:
if (some condition) do some action
So:
public static int testClearSet() {
if (setConatins(50)) {
myField = 50;
testSet.clear();
return myField;
}
return -1;
}
private static boolean setConatins(int searchFor) {
for (Integer n : testSet) {
if (n == searchFor) {
return true;
}
}
return false;
}
The latter method can be replaced with a single API call, for you to figure out.

If you know that your Set changing only in one thread, so you can clean it like in first example.
Method clear() does not throw ConcurrentModificationException.

Both your code will work.
There is indeed a restriction in modifying the collection when u iterate using fail fast iterators. That means, iterating using fail fast iterator will fail if there is any modification in the collection after the iterator was created. All the default iterators that is returned by java collection classes are fail-fast iterators.
private void removeDataTest (Collection<String> c, String item) {
Iterator<String> iter = c.iterator(); //Iterator is created.
while (iter.hasNext()) {
String data = iter.next();
if (data.equals(item)) {
//c.remove(data); //Problem. Directly modifying collection after this iterator is created. In the next iteration it will throw concurrent modification exception.
iter.remove(); //This is fine. Modify collection through iterator.
//c.clear(); break; //This is also should be okay. Modifying the collection directly, but after that it is breaking out and not using the iterator.
}
}
}
In your code, u don't continue iteration after the set is modified. So should be fine.

ArrayList.addAll() ConcurrentModificationException

I'm facing some really strange problems while implementing a kind of Kademlia bucket in Java 8 (OpenJDK).
I need to get at least a specific number of items from so-called Buckets.
But that's not the problem.
Somehow, I get sometimes a ConcurrentModificationException while doing closest.addAll() on the ArrayList though it is just used in a single thread and I'm not iterating or doing something like that.
Do you know how to help me?
Here is my code (I know it's a mess!):
List<Neighbour> getClosest(Node n, int num) {
ArrayList<Neighbour> closest = new ArrayList<>();
int missing;
int walkDown = n.getBucket(me);
int walkUp = walkDown + 1;
boolean pleaseBreak = true;
while (true) {
missing = num - closest.size();
if (missing <= 0) {
return closest;
}
if (walkUp >= 0 && walkUp < 160) {
List<Neighbour> l = buckets[walkUp].getClosest(missing);
closest.addAll(l);
if (closest.size() >= missing) {
return closest;
}
walkUp++;
pleaseBreak = false;
}
if (walkDown >= 0 && walkDown < 160) {
List<Neighbour> l = buckets[walkDown].getClosest(missing);
closest.addAll(l);
if (closest.size() >= missing) {
return closest;
}
walkDown--;
pleaseBreak = false;
}
if (pleaseBreak) {
return closest;
}
pleaseBreak = true;
}
}

ConcurrentModificationException actually means that you are breaking the rules of iteration by somehow modifying the list while iterating it.
Note that this exception does not always indicate that an object has been concurrently modified by a different thread. If a single thread issues a sequence of method invocations that violates the contract of an object, the object may throw this exception. For example, if a thread modifies a collection directly while it is iterating over the collection with a fail-fast iterator, the iterator will throw this exception.
That said it is fairly clear what could be causing this issue. As closest is a new List being filled by the method it must be l that is being modified.
There are two options:
Another thread is doing it.
You already have an iterator open across the list l.
Assuming it is not 1 (or you would probably have mentioned that) I will go for:
Your getClosest method is returning a sublist of a list that is being iterated across and/or modified and addAll is also attempting to iterate over it.
To fix, make getClosest return a copy of the sublist.

Java ConcurrentModificationException when removing two indexes, current and random one

I have a list of players.
This list contains players which do not have targets. Targets means that a player is targeted to another player, they two are targets, and should not be in the list.
The purpose of the following loop is to loop through all players, and search for a target, and if the player is not ready yet, it will just call the tick() method, which basically ticks down the target search timer. isReady method is basically timer == 0
for (Client c : participants) {
PlayerTargetDomain dom = c.getTarget();
if (dom.isReady()) {
if (dom.getSearchDelay() == 0) {
SharedTargetDomain d;
if ((d = search(c)) != null) {
participants.removeAll(Arrays.asList(d.getFirst(), d.getSecond()));
continue;
}
}
else {
dom.tickSearchDelay();
}
}
else dom.tick();
}
Now the search() method, basically looks for a matching target, and if found it will build SharedTargetDomain which contains the current index, and the found target index objects.
If the returned SharedTargetDomain instance from search(Client) was not null, I will remove both of the objects from the participants list using removeAll()
Unfortunately, if I remove any of them I will get the following error:
java.util.ConcurrentModificationException
at java.util.ArrayList$Itr.checkForComodification(Unknown Source)
at java.util.ArrayList$Itr.next(Unknown Source)
at mod.game.TargetManager.execute(TargetManager.java:24)
The line 24 is this:
for (Client c : participants) {
Why am I getting this? I've tried using Iterator for the current index, but I still get the error because I am deleting the other index too, but what does the other one has to do with the current index if I delete it? I am really misunderstanding something.
Thanks!
Iterator implementation:
Iterator<Client> itr = participants.iterator();
while(itr.hasNext()) {
Client c = itr.next();
if (c != null) {
PlayerTargetDomain dom = c.getTarget();
if (dom.isReady()) {
if (dom.getSearchDelay() == 0) {
SharedTargetDomain d;
if ((d = search(c)) != null) {
participants.remove(d.getSecond());
itr.remove();
continue;
}
}
else {
dom.tickSearchDelay();
}
}
else dom.tick();
}
}

Problem is that you modifying collection while iterating it.
There are at least two solution
Use index access. You get a lot of fun handling indexes because element will be shifted after remove.
Collect elements that you need to remove and apply all changes after finish iteration, You get a lot of fun always having in mind that element you processing can be already scheduled for deletion.

You can use
CopyOnWriteArrayList to avoid this exception

linked list throws an IndexOutOfBoundsException

I have a piece of code which involve a LinkedList. The followings
topic.read()
topic.delete() and
topic.send()
are methods from that LinkedList called Topic. These are being implemented in a GUI design. The methods
topic.read(name)
topic.send(text)
are working OK, but the
topic.delete(index)
is throwing me an
IndexOutOfBoundsException
I explain the methods briefly:read(name) and send(text) take String parameters and reads the topics and its list of messages and sends messages to topics receptively. The delete(index) should delete the index-specified message from the topic. However, the error message is telling me that the Size is 0.
The relevant piece:(I reckon that the piece should be enough, if needed more pieces will be added)
public void act(String s)
{
topic = new Topic(s, topics);
if (s.equals("Read"))
setEditorText(topic.read(readText()));
else if (s.equals("Delete"))
topic.delete(indexText());
else if (s.equals("Send"))
{
topic.send(getEditorText(), sendText());
clear();
}
}
Added these to this Quesion:
private JTextField indexText = new JTextField(10);
public int indexText()
{
return Integer.parseInt(indexText.getText());
}
public class Topic {
private LinkedList<String> messages = new LinkedList<String>();
public void delete(int index)
{
messages.remove(index - 1);
}
}

You need to do bounds checking then, if the index is valid, before deleting, such as:
if (index > 0 && index <= messages.size()) {
messages.remove(index - 1)
};
This will allow you to avoid IndexOutOfBoundsException

Hello Dilshat Abduwalli!
When you are getting a response that say your index size is 0 means that objects are not being added to the list or haven't yet been added and is why you go to delete said object of index value 2 for example it is going to throw an IndexOutOfBoundsException since the index is size is only 0. Ensure that you are adding values to your List or otherwise it will not be populated.
I would reccomend using #nitegazer2003 if statement you check for values that will fit within your List.size() you a integer isn't called that exceeds the List size which will give you the IndexOutOfBoundsException.
Double check your list values with a for loop.
for(int i = 0; i < list.size(); i++)
System.out.println(list.get(i)); //Print the Strings in the list (Assuming its a list of Strings)
Or
for(int i = 0; i < list.size(); i++)
System.out.println(list.getSize()); //Test the size of the list
Simular Question about Index 0 and OutOfBoundsException
The last posted response explains a similar answer. You don't have to read all his code though.
Oracle's List
Good source for documentation of List and its features.
I hope this helps or points you in the right direction! Good Luck!

in Java, how to traverse a queue without destroying it, in a simple way?

E.g.
I have a queue
void someMethod() {
history.add(new Sample(time, data));
...
traverse(history);
}
void traverse(Queue<Sample> history) {
for(int i=0; i<history.size(); i=i+10) {
history.get(i)... // ???
}
}
class Sample {
long time;
double data;
}
The concerns are that
I don't want to destroy this queue by calling traverse().
Traverse the queue in a given step, say 10 here.
Any simple and nice solution?

for (Sample s : history)
doStuff(s);
This is called the enhanced for-loop; you can read more about it here.

Queue implements Iterable, so a simple loop will traverse it:
for (Sample sample : history)
An Iterator is another way to do it, with more control (can destroy it if you want to), but more verbose.

If you just want to iterate, use a for-each loop or directly a for loop with an Iterator. This doesn't consume the queue.
If you need to iterate with a step, you can use this pattern. It works generally with any Iterable. Putting the skipping into a separate reusable method makes the code more clear than having two nested for loops.
public static void main(String[] args) {
Queue<Sample> history = ...
int step = 10;
for (Iterator<Sample> it = history.iterator();
it.hasNext(); skip(it, step - 1)) {
// note that we skipped 1 less elements than the size of the step
Sample sample = it.next();
// stuff
}
}
static void skip(Iterator<?> iterator, int count) {
for (int i = 0; i < count && iterator.hasNext(); i++) {
iterator.next();
}
}

LinkedList<Sample> h = (LinkedList<Sample>) history;
for(int i=0; i < h.size(); i+=step) {
h.get(i).memory ...
}
I just realized this approach, haven't tried it yet.
As nullptr pointed out, the condition for above code is that the Queue is implemented as a LinkedList. (which is my case: Queue<Sample> history = new LinkedList<Sample>();)