Чи є спосіб отримати доступ до лічильника ітерацій в Java для кожного циклу?

Чи існує спосіб у Java для кожного циклу

for(String s : stringArray) {
  doSomethingWith(s);
}

щоб дізнатися, як часто цикл вже обробляється?

Крім використання старого і відомого for(int i=0; i < boundary; i++)- циклу, є конструкція

int i = 0;
for(String s : stringArray) {
  doSomethingWith(s);
  i++;
}

єдиний спосіб мати такий лічильник доступний для кожного циклу?

Ні, але ви можете надати власний лічильник.

Причина цього полягає в тому , що для кожної петля-внутрішньо не має лічильника; він заснований на інтерфейсі Iterable , тобто він використовує Iteratorцикл через "колекцію" - що може взагалі не бути колекцією, а насправді може бути чимось зовсім не заснованим на індексах (наприклад, пов'язаний список).

Є й інший спосіб.

Враховуючи, що ви пишете власний Indexклас та статичний метод, який повертає Iterableзайві екземпляри цього класу, які ви можете

for (Index<String> each: With.index(stringArray)) {
    each.value;
    each.index;
    ...
}

Де реалізація With.indexчимось схожа

class With {
    public static <T> Iterable<Index<T>> index(final T[] array) {
        return new Iterable<Index<T>>() {
            public Iterator<Index<T>> iterator() {
                return new Iterator<Index<T>>() {
                    index = 0;
                    public boolean hasNext() { return index < array.size }
                    public Index<T> next() { return new Index(array[index], index++); }
                    ...
                }
            }
        }
    }
}

Найпростішим рішенням є просто запустити свій власний лічильник , таким чином:

int i = 0;
for (String s : stringArray) {
    doSomethingWith(s, i);
    i++;
}

Причиною цього є те, що немає фактичної гарантії, що елементи колекції (над якими цей варіант forповторюється) навіть мають індекс, або навіть мають певний порядок (деякі колекції можуть змінювати порядок, коли ви додаєте або видаляєте елементи).

Дивіться, наприклад, наступний код:

import java.util.*;

public class TestApp {
  public static void AddAndDump(AbstractSet<String> set, String str) {
    System.out.println("Adding [" + str + "]");
    set.add(str);
    int i = 0;
    for(String s : set) {
        System.out.println("   " + i + ": " + s);
        i++;
    }
  }

  public static void main(String[] args) {
    AbstractSet<String> coll = new HashSet<String>();
    AddAndDump(coll, "Hello");
    AddAndDump(coll, "My");
    AddAndDump(coll, "Name");
    AddAndDump(coll, "Is");
    AddAndDump(coll, "Pax");
  }
}

Запустивши це, ви можете побачити щось на кшталт:

Adding [Hello]
   0: Hello
Adding [My]
   0: Hello
   1: My
Adding [Name]
   0: Hello
   1: My
   2: Name
Adding [Is]
   0: Hello
   1: Is
   2: My
   3: Name
Adding [Pax]
   0: Hello
   1: Pax
   2: Is
   3: My
   4: Name

вказуючи на те, що, справедливо так, порядок не вважається помітною ознакою набору.

Є й інші способи зробити це без ручного лічильника, але це сумнівна робота для сумнівної вигоди.

Використання лямбдасів та функціональних інтерфейсів у Java 8 робить можливим створення нових абстракцій циклу. Я можу перейти до колекції з індексом та розміром колекції:

List<String> strings = Arrays.asList("one", "two","three","four");
forEach(strings, (x, i, n) -> System.out.println("" + (i+1) + "/"+n+": " + x));

Які виходи:

1/4: one
2/4: two
3/4: three
4/4: four

Що я реалізував як:

   @FunctionalInterface
   public interface LoopWithIndexAndSizeConsumer<T> {
       void accept(T t, int i, int n);
   }
   public static <T> void forEach(Collection<T> collection,
                                  LoopWithIndexAndSizeConsumer<T> consumer) {
      int index = 0;
      for (T object : collection){
         consumer.accept(object, index++, collection.size());
      }
   }

Можливості безмежні. Наприклад, я створюю абстракцію, яка використовує спеціальну функцію саме для першого елемента:

forEachHeadTail(strings, 
                (head) -> System.out.print(head), 
                (tail) -> System.out.print(","+tail));

Який надрукує список, відокремлений комами:

one,two,three,four

Що я реалізував як:

public static <T> void forEachHeadTail(Collection<T> collection, 
                                       Consumer<T> headFunc, 
                                       Consumer<T> tailFunc) {
   int index = 0;
   for (T object : collection){
      if (index++ == 0){
         headFunc.accept(object);
      }
      else{
         tailFunc.accept(object);
      }
   }
}

Бібліотеки почнуть з'являтися, щоб робити подібні речі, або ви можете скочувати свої власні.

Java 8 представила метод Iterable#forEach()/ Map#forEach(), який є більш ефективним для багатьох Collection/ Mapреалізацій порівняно з "класичним" для кожного циклу. Однак і в цьому випадку індекс не надається. Хитрість тут полягає у використанні AtomicIntegerпоза лямбда-виразу. Примітка: змінні, що використовуються в лямбда-виразі, повинні бути ефективно остаточними, тому ми не можемо використовувати звичайний int.

final AtomicInteger indexHolder = new AtomicInteger();
map.forEach((k, v) -> {
    final int index = indexHolder.getAndIncrement();
    // use the index
});

Боюся, що це неможливо foreach. Але я можу запропонувати вам простий старий стиль для циклів :

    List<String> l = new ArrayList<String>();

    l.add("a");
    l.add("b");
    l.add("c");
    l.add("d");

    // the array
    String[] array = new String[l.size()];

    for(ListIterator<String> it =l.listIterator(); it.hasNext() ;)
    {
        array[it.nextIndex()] = it.next();
    }

Зверніть увагу, що інтерфейс списку надає вам доступ до it.nextIndex().

(редагувати)

До зміненого прикладу:

    for(ListIterator<String> it =l.listIterator(); it.hasNext() ;)
    {
        int i = it.nextIndex();
        doSomethingWith(it.next(), i);
    }

Однією із змін Sun, які розглядаються, Java7є надання доступу до внутрішніх Iteratorу передній петлі. синтаксис буде приблизно таким (якщо це прийнято):

for (String str : list : it) {
  if (str.length() > 100) {
    it.remove();
  }
}

Це синтаксичний цукор, але, мабуть, було багато запитів щодо цієї функції. Але поки його не буде затверджено, вам доведеться самостійно рахувати ітерації або використовувати звичайний цикл з an Iterator.

Ідіоматичне рішення:

final Set<Double> doubles; // boilerplate
final Iterator<Double> iterator = doubles.iterator();
for (int ordinal = 0; iterator.hasNext(); ordinal++)
{
    System.out.printf("%d:%f",ordinal,iterator.next());
    System.out.println();
}

це насправді рішення, яке Google пропонує в дискусії Guava про те, чому вони не запропонували CountingIterator.

Хоча є багато інших способів, згаданих для досягнення цього, я поділюсь своїм незадоволеним користувачам. Я використовую функцію Java 8 IntStream.

1. Масиви

Object[] obj = {1,2,3,4,5,6,7};
IntStream.range(0, obj.length).forEach(index-> {
    System.out.println("index: " + index);
    System.out.println("value: " + obj[index]);
});

2. Список

List<String> strings = new ArrayList<String>();
Collections.addAll(strings,"A","B","C","D");

IntStream.range(0, strings.size()).forEach(index-> {
    System.out.println("index: " + index);
    System.out.println("value: " + strings.get(index));
});

Якщо вам потрібен лічильник у кожному циклі, вам доведеться порахувати себе. Наскільки я не знаю, немає вбудованого лічильника.

Існує "варіант" відповіді "pax" ... ;-)

int i = -1;
for(String s : stringArray) {
    doSomethingWith(s, ++i);
}

У ситуаціях, коли мені потрібен індекс лише час від часу, як, наприклад, у пункті вилову, я інколи буду використовувати indexOf.

for(String s : stringArray) {
  try {
    doSomethingWith(s);
  } catch (Exception e) {
    LOGGER.warn("Had some kind of problem with string " +
      stringArray.indexOf(s) + ": " + s, e);
  }
}

Найкращим і оптимізованим рішенням є наступне:

int i=0;

for(Type t: types) {
  ......
  i++;
}

Де Type може бути будь-який тип даних і типів - це змінна, за якою ви подаєте заявку на цикл.

Я трохи здивований, що ніхто не запропонував такого (я визнаю, це лінивий підхід ...); Якщо stringArray - це якийсь Список, ви можете використовувати щось на зразок stringArray.indexOf (S), щоб повернути значення для поточного підрахунку.

Примітка. Це передбачає, що елементи Списку є унікальними або не має значення, чи не є унікальними (тому що в цьому випадку він поверне індекс першої знайденої копії).

Є ситуації, в яких цього було б достатньо ...

Ось приклад того, як я це зробив. Це отримує індекс на циклі для кожного циклу. Сподіваюсь, це допомагає.

public class CheckForEachLoop {

    public static void main(String[] args) {

        String[] months = new String[] { "JANUARY", "FEBRUARY", "MARCH", "APRIL", "MAY", "JUNE", "JULY", "AUGUST",
                "SEPTEMBER", "OCTOBER", "NOVEMBER", "DECEMBER" };
        for (String s : months) {
            if (s == months[2]) { // location where you can change
              doSomethingWith(s); // however many times s and months
                                  // doSomethingWith(s) will be completed and 
                                  // added together instead of counter
            }

        }
        System.out.println(s); 


    }
}