Java为什么不存在用于（每个）循环的第三种语法？

Question

I know that currently there are two approaches to loop over an List . But let's complicate it a bit more, consider:

• You iterate over List<E> list .
• You want to keep track of an int y on every iteration.
• There exists a function process(E elem, int y) that processes an item.

Option 1:

for (int i = 0, y = 0; i < list.size(); i++, y++) {
    process(list.get(i), y);
}

which actually just is

for (int i = 0; i < list.size(); i++) {
    process(list.get(i), i);
}

Option 2:

int y = 0;
for (E elem : list) {
    process(elem, y);
    y++;
}

which can be rewritten to

int y = 0;
for (E elem : list) {
    process(elem, y++);
}

However why does the following not exist? What are the objections to it not existing?

Option 3:

for (int y = 0; E elem : list; y++) {
    process(elem, y);
}

Two arguments to have this construct:

• Both foreach syntaxes are distinguishable
• Many objects implement Iterable<E> , but have no for counterpart. This happens when an Iterable<E> has no order associated with it for example.

Answer 1

This is close to the proposed variant 3:

int y = 0;
for (Iterator<E> it=list.iterator(); it.hasNext(); y++) {
   process(it.next(), y);
}

or

Iterator<E> it=list.iterator();
for (int y = 0; it.hasNext(); y++) {
   process(it.next(), y);
}

or

Iterator it;int y;
for (y = 0, it=list.iterator(); it.hasNext(); y++) {
    process(it.next(), y);
}

Answer 2

Because it's excessive? In this case y doesn't bear any sense and code can be easily rewritten as you've shown.

If you want such a nonstandard behaviour, maybe try to look at Scala language, for example. You'll be able to create truly monstrous control structures there.

Answer 3

This :

for (int y = 0; E elem : list; y++) {
   process(elem, y);
}

can very well be written as this :

E elem;
for (int y = 0 ; y < list.size(); y++, elem = list.get(y)) {
    process(elem, y);
}

Though the scope of the variable elem differs in this case . Hence I don't think there is an explicit need for the 3rd option , again , opinions may vary .

Answer 4

In a language like Python, this could be solved by zipping with an integer sequence:

>>> a = ['a','b','c','d']
>>> for val,i in zip(a, range(len(a))):
...   print val, i
...
a 0
b 1
c 2
d 3

Obviously Java doesn't have syntactic support for something like this, but I do think there can be good reasons for avoiding calling list.get(i) on each iteration, not least that fetching a specific value might be much slower than iterating to the next value (say, with a linked list).

I'm not a fan of departing from convention when using loop syntax, so I'm not so keen on putting different variables in the test and increment portions of a normal for-loop (Alexei Kaigorodov's solution looks nice, but potentially confusing for people who aren't familiar with it). My usuallly-preferred solution is to maintain the count separately while using a for-each loop, which is the OP's Option 2.

Alternatively, you could use my CountingIterable<> class, which provides the count as well as the value. Whether this is a good idea in production code is still up for debate, but the question inspired me to write it and stick it on Github .

It's used like this:

for (Counted<E> v : counting(iterable)) {
    process(v.getValue(), v.getCount());
}

(Where, in the code this was taken from, counting is statically imported from the Counting class)

Answer 5

I believe this is an opinion based question. Only the language designers could answer that.

You could somewhat improve the Iterator syntax with a utility class, if you are willing to accept the creation of a new object that wraps Iterator to make the index available. See an example below:

public static void main(String[] args) {
    List<String> list = Arrays.asList( new String[] {"item1", "item2", "item3"} );

    for (IndexIterator<String> it = IndexIterator.of(list.iterator()); it.hasNext();) {
        System.out.println( it.next() + " : " + it.index() );
    }
    // Prints:
    // item1 : 0
    // item2 : 1
    // item3 : 2
}

The IndexIterator utility class is as follows:

public static class IndexIterator<T> implements Iterator<T> {
    private int index = -1;
    private Iterator<T> iterator;
    public IndexIterator(Iterator<T> it) {
        this.iterator = it;
    }

    @Override
    public boolean hasNext() {
        return iterator.hasNext();
    }

    @Override
    public T next() {
        index++;
        return iterator.next();
    }

    @Override
    public void remove() {
        iterator.remove();
    }

    public int index() {
        return this.index;
    }

    public static <T> IndexIterator<T> of(Iterator<T> it) {
        return new IndexIterator<T>(it);
    }
}

Answer 6

Isn't

nextIndex() 

what you are looking for instead of y? Ps using ListIterator

Edited: this is what I meant in code:

Iterator<E> it = list.iterator();
while (it.hasNext()){
    process(it.next(), it.previousIndex());
}