Có cách nào để truy cập vào bộ đếm lặp trong mỗi vòng lặp của Java không?

Có cách nào trong vòng lặp for cho mỗi vòng lặp của Java không

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

để tìm hiểu mức độ thường xuyên của vòng lặp đã được xử lý?

Bên cạnh việc sử dụng for(int i=0; i < boundary; i++)vòng lặp cũ và nổi tiếng -, là cấu trúc

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

cách duy nhất để có một bộ đếm như vậy có sẵn trong một vòng lặp for-mỗi?

Không, nhưng bạn có thể cung cấp truy cập của riêng bạn.

Lý do cho điều này là vòng lặp for-every bên trong không có bộ đếm; nó dựa trên giao diện Iterable , tức là nó sử dụng một Iteratorvòng lặp thông qua "bộ sưu tập" - có thể hoàn toàn không phải là một bộ sưu tập, và trên thực tế có thể không phải là thứ gì đó dựa trên các chỉ mục (như danh sách được liên kết).

Có một cách khác.

Cho rằng bạn viết Indexlớp của riêng bạn và một phương thức tĩnh trả về một Iterablethể hiện của lớp này, bạn có thể

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

Trường hợp thực hiện With.indexlà một cái gì đó như

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++); }
                    ...
                }
            }
        }
    }
}

Giải pháp đơn giản nhất là chỉ chạy bộ đếm của riêng bạn, do đó:

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

Lý do cho điều này là do không có đảm bảo thực tế rằng các mục trong bộ sưu tập (biến thể forlặp lại đó) thậm chí có một chỉ mục hoặc thậm chí có một thứ tự được xác định (một số bộ sưu tập có thể thay đổi thứ tự khi bạn thêm hoặc xóa phần tử).

Xem ví dụ, mã sau đây:

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

Khi bạn chạy nó, bạn có thể thấy một cái gì đó như:

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

chỉ ra rằng, đúng như vậy, trật tự không được coi là một tính năng nổi bật của một bộ.

Có nhiều cách khác để làm điều đó mà không cần bộ đếm thủ công nhưng đó là một công việc hợp lý vì lợi ích đáng ngờ.

Sử dụng lambdas và các giao diện chức năng trong Java 8 giúp tạo ra sự trừu tượng hóa vòng lặp mới. Tôi có thể lặp qua một bộ sưu tập với chỉ mục và kích thước bộ sưu tập:

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

Đầu ra nào:

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

Mà tôi đã thực hiện như:

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

Các khả năng là vô tận. Ví dụ: tôi tạo một bản tóm tắt sử dụng hàm đặc biệt chỉ cho phần tử đầu tiên:

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

Mà in một danh sách được phân tách bằng dấu phẩy chính xác:

one,two,three,four

Mà tôi đã thực hiện như:

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

Các thư viện sẽ bắt đầu bật lên để làm những việc này, hoặc bạn có thể tự cuộn.

Java 8 đã giới thiệu phương thức Iterable#forEach()/ Map#forEach(), hiệu quả hơn cho nhiều Collection/ Maptriển khai so với vòng lặp "cổ điển" cho mỗi vòng lặp. Tuy nhiên, cũng trong trường hợp này, một chỉ số không được cung cấp. Mẹo ở đây là sử dụng AtomicIntegerbên ngoài biểu thức lambda. Lưu ý: các biến được sử dụng trong biểu thức lambda phải có hiệu quả cuối cùng, đó là lý do tại sao chúng ta không thể sử dụng một biến thông thường int.

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

Tôi sợ điều này là không thể với foreach. Nhưng tôi có thể gợi ý cho bạn một vòng lặp kiểu cũ đơn giản :

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

Lưu ý rằng, giao diện Danh sách cho phép bạn truy cập it.nextIndex().

(biên tập)

Để ví dụ thay đổi của bạn:

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

Một trong những thay đổi Sunđang được xem xét Java7là cung cấp quyền truy cập vào bên Iteratortrong các vòng lặp foreach. cú pháp sẽ giống như thế này (nếu điều này được chấp nhận):

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

Đây là đường cú pháp, nhưng rõ ràng rất nhiều yêu cầu đã được đưa ra cho tính năng này. Nhưng cho đến khi được phê duyệt, bạn sẽ phải tự mình đếm các lần lặp hoặc sử dụng vòng lặp thông thường cho một vòng lặp Iterator.

Giải pháp thành ngữ:

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

đây thực sự là giải pháp mà Google gợi ý trong cuộc thảo luận về ổi về lý do tại sao họ không cung cấp CountingIterator.

Mặc dù có rất nhiều cách khác được đề cập để đạt được điều tương tự, tôi sẽ chia sẻ cách của mình cho một số người dùng không hài lòng. Tôi đang sử dụng tính năng Java 8 IntStream.

1. Mảng

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. Danh sách

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

Nếu bạn cần một bộ đếm trong một vòng lặp cho mỗi vòng, bạn phải tự đếm. Không có xây dựng trong quầy theo như tôi biết.

Có một "biến thể" để trả lời câu trả lời ... ;-)

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

Đối với các tình huống đôi khi tôi chỉ cần chỉ mục, như trong mệnh đề bắt, đôi khi tôi sẽ sử dụng 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);
  }
}

Giải pháp tốt nhất và tối ưu hóa là làm những việc sau:

int i=0;

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

Trong đó Kiểu có thể là bất kỳ kiểu dữ liệu và kiểu nào là biến mà bạn đang áp dụng cho một vòng lặp.

Tôi hơi ngạc nhiên khi không ai đề xuất những điều sau đây (tôi thừa nhận đó là một cách tiếp cận lười biếng ...); Nếu stringArray là một Danh sách sắp xếp nào đó, bạn có thể sử dụng một cái gì đó như stringArray.indexOf (S) để trả về một giá trị cho số hiện tại.

Lưu ý: điều này giả định rằng các thành phần của Danh sách là duy nhất hoặc không thành vấn đề nếu chúng không phải là duy nhất (vì trong trường hợp đó, nó sẽ trả về chỉ mục của bản sao đầu tiên được tìm thấy).

Có những tình huống sẽ đủ ...

Đây là một ví dụ về cách tôi đã làm điều này. Điều này nhận được chỉ số tại mỗi vòng lặp. Hi vọng điêu nay co ich.

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


    }
}