Java의 for-each 루프에서 반복 카운터에 액세스하는 방법이 있습니까?

Java for-each 루프에 방법이 있습니까?

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

루프가 얼마나 자주 처리되었는지 확인하려면?

오래되고 잘 알려진 for(int i=0; i < boundary; i++)루프 를 사용하는 것 외에도 구성은

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

for-each 루프에서 이러한 카운터를 사용할 수있는 유일한 방법은 무엇입니까?

아니요, 그러나 자신의 카운터를 제공 할 수 있습니다.

그 이유는 피 각 루프 내부 없다는 것이다 가 카운터; 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 은 "클래식"for-each 루프에 비해 많은 / 구현에서 더 효율적인 Iterable#forEach()/ Map#forEach()메소드를 도입했습니다 . 그러나이 경우에도 색인이 제공되지 않습니다. 여기서 트릭 은 람다 식 외부에서 사용 하는 것입니다. 참고 : 람다 식에 사용 된 변수는 효과적으로 최종 변수 여야하므로 일반을 사용할 수 없습니다 .CollectionMapAtomicIntegerint

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

이 기능을 사용할 수 없습니다 foreach. 그러나 나는 당신에게 간단한 구식 for 루프를 제안 할 수 있습니다 :

    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내부에 대한 액세스를 제공하는 것입니다 Iteratorforeach는 루프에서. 문법은 다음과 같습니다 (만약 이것이 받아 들여지면) :

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

이것은 구문 설탕이지만 분명히이 기능에 대한 많은 요청이있었습니다. 그러나 승인 될 때까지 반복을 직접 계산하거나으로 정규 for 루프를 사용해야합니다 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();
}

이것은 실제로 구글이 구아바 토론 에서 그들이 제공하지 않은 이유에 대해 제안하는 솔루션입니다 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));
});

for-each 루프에 카운터가 필요한 경우 스스로 계산해야합니다. 내가 아는 한 내장 카운터가 없습니다.

pax '답변에 "변형"이 있습니다 ... ;-)

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

catch 절과 같이 가끔 인덱스 만 필요한 상황에서는 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가 일종의 List이면 stringArray.indexOf (S)와 같은 것을 사용하여 현재 개수의 값을 반환 할 수 있습니다.

참고 : 이것은 List의 요소가 고유하거나 고유하지 않은 경우 중요하지 않다고 가정합니다 (이 경우 발견 된 첫 번째 사본의 색인을 리턴하므로).

충분할 상황이 있습니다 ...

여기 내가 어떻게 한 예가 있습니다. 이것은 각 루프마다 인덱스를 가져옵니다. 도움이 되었기를 바랍니다.

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); 


    }
}