มีวิธีการเข้าถึงตัวนับซ้ำในแต่ละวงของ 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

แสดงให้เห็นว่าถูกต้องเพื่อไม่ถือว่าเป็นคุณสมบัติเด่นของชุด

มีวิธีอื่น ๆ ที่จะทำโดยไม่มีเคาน์เตอร์คู่มือ แต่มันเป็นงานที่ค่อนข้างยุติธรรมเพื่อผลประโยชน์ที่น่าสงสัย

การใช้lambdasและส่วนต่อประสานการทำงานในJava 8ทำให้การสร้างลูป abstractions เป็นไปได้ ฉันสามารถวนรอบคอลเลกชันด้วยดัชนีและขนาดคอลเลกชัน:

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ในวงรอบ foreach ไวยากรณ์จะเป็นดังนี้ (ถ้าเป็นที่ยอมรับ):

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

นี่คือน้ำตาลเชิงประโยค แต่เห็นได้ชัดว่ามีคำขอจำนวนมากสำหรับคุณลักษณะนี้ 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 แสดงให้เห็นในการอภิปรายฝรั่ง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 'answer ... ;-)

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


    }
}