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

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

Java의 각 루프를 위한 방법이 있습니까?

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

루프가 이미 얼마나 자주 처리되었는지 알 수 있을까요?

well-known 사용 for(int i=0; i < boundary; i++) - " " " " 、 " " " - " 。

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

각 루프에서 이러한 카운터를 사용할 수 있는 유일한 방법?

아니요, 하지만 카운터는 따로 마련하실 수 있습니다.

그 이유는 각 루프에 대해 내부적으로 카운터가 없기 때문입니다.이것은 반복 가능한 인터페이스에 근거하고 있습니다.즉, 이 루프는Iterator컬렉션이 전혀 아닐 수도 있고 실제로 인덱스(예: 링크 목록)에 기반하지 않은 것일 수도 있습니다.

다른 방법이 있어요.

이 직접 을 생각하면Index 및 static을 한다.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);
      }
   }
}

이런 종류의 작업을 하기 위한 라이브러리가 나타나기 시작할 것입니다.아니면 직접 실행할 수도 있습니다.

8은 Java 8™을 도입했습니다.Iterable#forEach()Map#forEach()에게 효율적인CollectionMap각 루프에 대한 "실장"과 비교합니다.단, 이 경우에도 인덱스는 제공되지 않습니다.서의 은 ★★★★★★★★★★★★★★★★★★★★★★★★★★.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();
    }

List 인터페이스에서는, 다음의 URL 에 액세스 할 수 있는 것에 주의해 주세요.it.nextIndex().

(편집)

변경된 예시로:

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

Idiomatic 솔루션:

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

이것은 구글이 Guava 토론에서 제안한 해결책입니다. 왜 구글이 Guava를 제공하지 않았는지에 대한CountingIterator.

변경 사항 중 하나Sun에 대해 고려하고 있다.Java7내부로의 접근을 제공하는 것이다.Iterator포어치 루프에서.구문은 다음과 같습니다(이것이 받아들여질 경우).

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

이것은 통사설탕이지만, 이 기능에 대한 요청이 많은 것 같습니다.그러나 승인될 때까지 직접 반복 횟수를 계산하거나 일반 루프를 사용하여Iterator.

같은 목표를 달성하기 위해 언급되는 많은 방법들이 있지만, 나는 몇몇 불만족스러운 사용자들을 위해 나의 길을 공유하겠다.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));
});

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 = -1;
for(String s : stringArray) {
    doSomethingWith(s, ++i);
}

최적의 최적화 솔루션은 다음 작업을 수행하는 것입니다.

int i=0;

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

여기서 Type은 임의의 데이터 타입이며 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); 


    }
}

언급URL : https://stackoverflow.com/questions/477550/is-there-a-way-to-access-an-iteration-counter-in-javas-for-each-loop