How do I get the current index/key in a "for each" loop

Detailed insight: varied index tracking techniques

The above solution will suit your needs in basic scenarios. However, when the situation gets a bit tricky, different approaches may come in handy. Let's review them:

Keeping an eye on performance

If your goal is maximum performance, you can utilize size() method for collections or length property for arrays as index trackers:

for (int i = 0; i < yourArray.length; i++) {
    YourType item = yourArray[i];
    // Now you're playing with power... and with access to index i
}


Crafting a custom iterator

Would you like to have the comfort of for-each loops plus index tracking simultaneously? A custom iterator can be your rescue:

public class IterableWithIndex<T> implements Iterable<Pair<Integer, T>> {
    private final List<T> list;

    public IterableWithIndex(List<T> list) {
        this.list = list;
    }

    @Override
    public Iterator<Pair<Integer, T>> iterator() {
        return new Iterator<Pair<Integer, T>>() {
            private int index = 0;

            @Override
            public boolean hasNext() {
                return index < list.size(); // Are there more treasures to find?
            }

            @Override
            public Pair<Integer, T> next() {
                // Hip, Hip, Array! Get your elements and indices in pairs.
                return Pair.of(index++, list.get(index - 1));
            }
        };
    }
}


This methodology helps zip together your elements with their accordance indices gracefully.

Dressing functional style with Java 8

The introduction of Java 8's IntStream enables iteration over ranges. This feature can be harnessed to zip collections and indices together:

IntStream.range(0, yourList.size())
         .forEach(idx -> {
             YourType item = yourList.get(idx);
             // Less variable juggling can lead to fewer dropped balls, or errors.
         });


It's neat as it keeps the code readable and removes the need for an added index variable.

Opting for alternative collection types

Java collections like ArrayList and LinkedList inherently store positional information about elements. Combining List.indexOf(Object o) method with these can retrieve an element's index, post-retrieval.

Rethinking your strategy

Tempted to access indices in a for-each loop? It might be a signal to reconsider your algorithm. Perhaps there's an innovative way that reduces dependence on indices, yet leading to a cleaner and efficient solution.

Side-stepping potential pitfalls

Editing collections while iterating could lead to concurrent modification exceptions. Yes, that's as scary as it sounds! Also, separate indexing variables can introduce off-by-one errors. So keep your eyes wide open when incrementing.