When an element is removed from an ArrayList, everything on its right is shifted to left.
Besides being an onerous heavy operation, it messes up w/ the actual index.

For example, if element #10 is removed, element #11 becomes #10.

And even worse, if by chance the loop would still continue,
instead of accessing next ex-element #11,
it will be ex-#12 instead, totally skipping ex-#11!!!

The decreasing of number of elements, plus the shifted element positions,
most probably are the reasons why an enhanced loop fails outright!

Now, if you loop it backwards, your goal is element #0,
so it's immune from the number of elements' decrease!

Also, since the elements to the left of a removed element are not shifted,
there is guarantee you'll iterate every1 w/o skipping any!

Well, here's a modified version of your function.
Dunno whether it works. Check it out for yourself:

P.S. 1: if you need to remove the 1st one found only, include a break statement as well.  
P.S. 2: go here to see another example of an instance object telling its loop to remove it.
http://forum.processing.org/topic/array-usage-objects-in-general

void removeFromArrayList(ArrayList
               
                 myArrayList, 
                int num) {

  
                for ( 
                int i = myArrayList.
                size(); i != 0 )
    
                if (myArrayList.
                get(--i).value == num)      myArrayList.remove(i);
}

               

You can also use the ArrayList's Iterator. (Iterator it = myArrayList.iterator();) From the Iterator javadoc:

Iterators allow the caller to remove elements from the underlying collection during the iteration with well-defined semantics.

That's true. But a simple backwards loop is much less verbose!

Thank you very much!

That's true. But a simple backwards loop is much less verbose!

Not necessarily a lot less verbose:
 
  for(Iterator<Test> it = al.iterator(); it.hasNext();) {
    if(it.next().value < .5) it.remove();
  }

Very neat, rbrauer!

You've crammed the Iterator declaration inside the for loop!
All the examples I've seen about it used a while loop!

However, less complexity-wise, I find using a direct get() access easier to understand.
And above all, I tend to choose regular arrays as much as I can!

Nevertheless, your example is very handful when used on some other exotic/obscure Collection lists.
My favorite is ArrayDeque, which doesn't have methods for direct element access. Only head & tail elements!
Another one is LinkedList. Even though it allows direct access by get(), it is the slowest thing you can do w/ it!

hello,

the reason and context behind my initial question is as follows - and maybe you can help me there, too.

It's a little embarassing though...

I need to pick random numbers and want to make sure that each number is taken only once.

To ensure that I made this arraylist (of int basically also I had to wrap it in a class) and I pick the random number from there; each number that's picked gets removed (see code above). Thus I can choose a number between 0 and size() from the arraylist and be sure the number that comes out is unique.

But that seems to be very clumsy....

What is a better idea of achieving this? Thanks!

Greetings, Chrisir    

Java Collections would be very applicable here, especially the Set implementation. To iterate a collection I would use an Iterator because "Iterator.remove is the only safe way to modify a collection during iteration" (see iterators). 

thanks a lot!

Gonna use this!

remark :
you need

1. //
2. import java.util.*;

for this.


Running into loads of difficulties....

How can I say

1.         int j =  it.next() ;

or    

1.         int j = (int) ( it.next() );

?
I get Errors.

How can I say

1.   int j = a.get ( 2 );

?

How can I say

1. a.shuffle();

?
This doesn't work:

1. Collections.shuffle( Arrays.asList( intTileIndexes ) ) ;

Because when I use this:

1. Set a = new HashSet();
2.   while (a.size ()<100) {
3.     a.add(int(random(1000)));
4.   }

You can't use primitive types, like int, in Collections such as ArrayList or HashSet. If you use Integer it automatically gets converted to and from the primitive int like so:

ArrayList<Integer> blah = new ArrayList<Integer>();
blah.add(1);
int test = blah.get(0);

Its called autoboxing.

If I understand correctly, you need to select a random number between 1 and max_int and each selected number should be unique and should lie within the range. This code could help:

wow!

see my current result here

lines 235-292 :

https://forum.processing.org/topic/any-one-up-writing-simple-game-for-a-good-cause#25080000001992997