As of Java5 :
for ( SomeClass c : somecoll )
{ //do something with (each) c in somecoll, like :
c.change(somearg);
}
--
http://javalessons.com  Paul Hamaker, SEMM
Teaching ICT since 1987

For a one off, you could write it explicitly as:

        List<Integer> values = Arrays.asList(new Integer[] {
                1, 2, 3, 4, 5
        });
        for (
            ListIterator<Integer> iter = values.listIterator();
            Integer value = iter.next();
        ) {
            iter.set(value + 1);
        }
        System.out.println(values);

To abstract the 'array walking' takes a bit more work:

public interface Transform<T> {
    T transform(T value);
}
...
    public <T> static void transform(
        List<T> values, Transform<T> transform
    ) {
        for (
            ListIterator<T> iter = values.listIterator();
            T value = iter.next();
        ) {
            iter.set(transform.transform(value));
        }
    }
...
        List<Integer> values = Arrays.asList(new Integer[] {
                1, 2, 3, 4, 5
        });
        transform(values, new Transform<Integer>() {
                public Integer transform(Integer value) {
                    return value+1;
                }
        });
        System.out.println(values);

I have used List instead of Collection, because Collection doesn't
provide a ListIterator and it's not an entirely sensible operation to
perform on a set anyway.

As you can see, abstracting loops is not a particularly natural thing to
do in Java. After splitting the method, my example is only one line
shorter and indents three levels instead of one. The inner class can
only reference final variables of the enclosing method. So it isn't done
very often in Java, at the moment.

There are various proposals to make things simpler in Java 7. These will
allow something like:

        // BGGA
        transform(values) {
            Integer value => value+1
        }

        transform(values, { Integer value => value+1 });

        // CICE (possibly without the <Integer>).
        transform(values, Transform<Integer>(Integer value) {
                return value+1;
        });

        // My favourite:
        transform(values, new()(Integer value) {
                return value+1;
        });

Tom Hawtin

Java doesn't exactly have closures, so its hard to do stuff like what
your asking.. However, what you really want is:

Replacing "doChange" with whatever is appropriate.

You COULD make a utility class that does this for you:

public interface Transformer {
   Object transform(Object o);
}

public class ListWalker {
 public static void walk(List myList, Transformer transformer) {
   ListIterator iterator = myList.listIterator();
   while (iterator.hasNext()) {
       iterator.set( transformer.transform(iterator.next()) );
   }
}

Now you can call:
ListWalker.walk(myList, new Transformer() {
   public Object transform(Object o) {
        return new Integer(((Integer)o).intValue() + 1);
   }
});

Ick... Did I just write that?
Well, you can't do little "tricks" with Java like you can in PHP, but
don't worry about that too much.

phillip.s.powell@gmail.com schrieb:

As some have already pointed out this could be achieved
(quite verbose) using a callback-like anonymous class
implementing some interface.

Another option would be heading towards Groovy, a dynamic
language which runs on and interfaces well with the
Java platform.

Here comes a Groovy implementation of your PHP code:
--------------
array = [1, 2, 3, 4, 5]

array.collect {
  it = it+1
}
// returns [2, 3, 4, 5]
--------------

Or even shorter using a range:
--------------
(1..5).collect {
  it = it+1
}
// returns [2, 3, 4, 5]
--------------

Kai