Tại sao Java không cho phép foreach trên các trình vòng lặp (chỉ trên các vòng lặp)?

Question

thể trùng lặp:
Why is Java's Iterator not an Iterable?

Idiomatic way to use for-each loop given an iterator?

Can we use for-each loop for iterating the objects of Iterator type?

Các foreach vòng lặp là như xa như tôi biết đường cú pháp bổ sung trong Java 5. Vì vậy,

Iterable<O> iterable; 
for(O o : iterable) { 
    // Do something 
} 

về cơ bản sẽ tạo ra bytecode giống như

Iterable<O> iterable; 
for(Iterator<O> iter = iterable.iterator(); iter.hasNext(); /* NOOP */) { 
    O o = iter.next(); 
    // Do something 
} 

Tuy nhiên, nếu tôi không có một iterable ở nơi đầu tiên, nhưng chỉ một iterator (nói, bởi vì một lớp học cung cấp hai vòng lặp khác nhau), tôi có thể không sử dụng vòng lặp foreach đường cú pháp. Rõ ràng tôi vẫn có thể thực hiện lặp lại kiểu cũ đơn giản. Tuy nhiên, tôi thực sự muốn làm:

Iterator<O> iter; 
for(O o : iter /* Iterator<O>, not Iterable<O>! */) { 
    // Do something 
} 

Và dĩ nhiên tôi có thể làm một giả Iterable:

class Adapter<O> implements Iterable<O> { 
    Iterator<O> iter; 

    public Adapter(Iterator<O> iter) { 
     this.iter = iter; 
    } 

    @Override 
    public Iterator<O> iterator() { 
     return iter; 
    } 
} 

(Mà trên thực tế là một sự lạm dụng xấu xí của API Iterable, vì nó có thể ! chỉ được lặp một lần)

Nếu nó được thiết kế xung quanh Iterator thay vì iterable, người ta có thể làm một số điều thú vị:

for(O o : iterable.iterator()) {} // Iterate over Iterable and Collections 

for(O o : list.backwardsIterator()) {} // Or backwards 

Iterator<O> iter; 
for(O o : iter) { 
    if (o.something()) { iter.remove(); } 
    if (o.something()) { break; } 
} 
for(O : iter) { } // Do something with the remaining elements only. 

Có ai biết lý do tại sao ngôn ngữ được thiết kế theo cách này? Để tránh sự mơ hồ nếu một lớp học sẽ triển khai cả hai Iterator và Iterable? Để tránh các lỗi lập trình giả định rằng "for (O o: iter)" sẽ xử lý tất cả các phần tử hai lần (và quên để có được một iterator mới)? Hoặc là có một số lý do khác cho việc này?

Hoặc có một số mẹo ngôn ngữ tôi chỉ không biết?

Answer 1

Vì vậy, tôi có một lời giải thích nào hợp lý bây giờ:

phiên bản ngắn: Bởi vì cú pháp cũng áp dụng cho mảng, mà không cần phải lặp.

Nếu cú ​​pháp được thiết kế xung quanh Iterator như tôi đã đề xuất, nó sẽ không phù hợp với mảng. Hãy để tôi cung cấp cho ba phiên bản:

A) như được lựa chọn bởi các nhà phát triển Java:

Object[] array; 
for(Object o : array) { } 
Iterable<Object> list; 
for(Object o : list) { } 
Iterator<Object> iter; 
while(iter.hasNext()) { Object o = iter.next(); } 

Các cư xử theo cùng một cách và là cao phù hợp qua mảng và các bộ sưu tập. Tuy nhiên, Iterator phải sử dụng kiểu lặp lại cổ điển (ít nhất là không có khả năng gây ra lỗi).

B) phép mảng và Iterators:

Object[] array; 
for(Object o : array) { } 
Iterable<Object> list; 
for(Object o : list.iterator()) { } 
Iterator<Object> iter; 
for(Object o : iter) { } 

Bây giờ mảng và các bộ sưu tập không phù hợp; nhưng mảng và ArrayList có liên quan rất chặt chẽ và nên hành xử theo cùng một cách. Bây giờ nếu tại bất kỳ thời điểm nào, ngôn ngữ là mở rộng để thực hiện ví dụ: mảng thực hiện Iterable, nó trở nên không nhất quán.

C) cho phép tất cả ba:

Object[] array; 
for(Object o : array) { } 
Iterable<Object> list; 
for(Object o : list) { } 
Iterator<Object> iter; 
for(Object o : iter) { } 

Bây giờ nếu chúng ta kết thúc trong tình huống không rõ ràng khi một trong hai người nào thực hiện cảIterable và Iterator (là vòng lặp for trù được một iterator mới hoặc lặp quá dòng - xảy ra dễ dàng trong cấu trúc giống cây!?!). Một đơn giản tie-braker ala "Iterable nhịp đập Iterator" tiếc là sẽ không làm: nó đột nhiên giới thiệu thời gian chạy so với sự khác biệt thời gian biên dịch và các vấn đề generics. Bây giờ đột nhiên, chúng ta cần phải chú ý đến việc liệu chúng ta muốn lặp qua các bộ sưu tập/vòng lặp hay mảng hay không, tại thời điểm này chúng ta đã thu được rất ít lợi ích với chi phí của một sự nhầm lẫn lớn.

Cách "cho mỗi" là trong Java (A) là rất nhất quán, nó gây ra rất ít lỗi lập trình và cho phép thay đổi trong tương lai có thể biến mảng thành đối tượng thông thường.

Có một biến thể D) cũng có thể hoạt động tốt: cho mỗi chỉ dành cho Iterator.Ưu tiên sử dụng bằng cách thêm một phương pháp .iterator() để mảng nguyên thủy:

Object[] array; 
for(Object o : array.iterator()) { } 
Iterable<Object> list; 
for(Object o : list.iterator()) { } 
Iterator<Object> iter; 
for(Object o : iter) { } 

Nhưng điều này đòi hỏi phải có những thay đổi đối với môi trường thời gian chạy, không chỉ là trình biên dịch, và phá vỡ tính tương thích ngược. Ngoài ra, sự nhầm lẫn được đề cập vẫn còn hiện diện là

Iterator<Object> iter; 
for(Object o : iter) { } 
for(Object o : iter) { } 

Chỉ lặp lại dữ liệu một lần.

Answer 2

Có ai biết lý do tại sao ngôn ngữ được thiết kế theo cách này?

Vì for-each chỉ có ý nghĩa hơn những điều iter thể, và không có ý nghĩa hơn iter ators. Nếu bạn đã có một trình lặp, bạn đã có những gì bạn cần làm với một vòng lặp đơn giản.

Hãy so sánh: Tôi bắt đầu với một iter thể:

// Old way 
Iterator<Thingy> it = iterable.iterator(); 
while (it.hasNext()) { 
    Thingy t = it.next(); 
    // Use `t` 
} 

// New way 
for (Thingy t : iterable) { 
    // Use `t` 
} 

Versus Tôi bắt đầu với một iterator:

// Old/current way 
while (iterator.hasNext()) { 
    Thing t = iterator.next(); 
    // Use `t` 
} 

// Imagined way 
for (Thingy t : iterator) { 
    // Use `t` 
} 

Không có nhiều trong nó trong ví dụ thứ hai, và nó làm phức tạp ngữ nghĩa của từng cái bằng cách tạo ra một trường hợp đặc biệt.

Câu hỏi "Tại sao" luôn khó khăn khi không được hướng dẫn tại những người tham gia chính tham gia vào quyết định, nhưng tôi đoán là sự phức tạp thêm không đáng giá so với tiện ích cận biên.

Answer 3

Giao diện Iterable được tạo chính xác cho mục đích đó (được tăng cường cho vòng lặp) như được mô tả trong original JSR, mặc dù giao diện Iterator đã được sử dụng.

Answer 4

Vì vòng lặp "for" sẽ hủy hoại đối với trình lặp. Iterator không thể được thiết lập lại (tức là di chuyển trở lại phần đầu) trừ khi nó thực hiện subInterator ListIterator.

Khi bạn đặt Iterator qua vòng lặp "for", nó sẽ không còn sử dụng được nữa. Tôi đoán là các nhà thiết kế ngôn ngữ đã quyết định rằng điều này kết hợp với các trường hợp đặc biệt bổ sung (trong đó đã có hai cho Iterable và mảng) trong trình biên dịch để dịch thành bytecode (bạn không thể tái sử dụng cùng một phép biến đổi như iterable) là đủ một kẻ phản đối để không thực hiện nó.

Khi bạn tự làm điều này trong mã thông qua giao diện trình lặp, nó ít nhất sẽ được rõ ràng rõ ràng những gì đang xảy ra.

Với lambdas sắp tới họ có thể làm đẹp này và dễ dàng:

Iterator<String> iterator = ...; 
Collections.each (iterator, (String s) => { System.out.println(s); }); 

List<String> list = ...; 
Collections.each (list, (String s) => { System.out.println(s); }); 

mà không vi phạm tương thích ngược, và vẫn có một cú pháp tương đối đơn giản. Tôi nghi ngờ họ sẽ xây dựng các phương pháp như "mỗi", "thu thập" và "bản đồ" vào các giao diện khác nhau vì điều đó sẽ phá vỡ sự tương thích ngược, cộng với bạn vẫn còn mảng để xử lý.

Answer 5

Tôi nghĩ rằng một phần của câu trả lời có thể được ẩn trong thực tế là vòng lặp cho mỗi là cú pháp đường. Vấn đề là bạn muốn làm một cái gì đó mà mọi người làm rất nhiều, dễ dàng hơn rất nhiều. Và (ít nhất theo kinh nghiệm của tôi) thành ngữ

Iterator iterator = iterable.iterator(); 
while(iterator.hasNext()) { 
    Element e = (Element)iterator.next() ; 
} 

xảy ra mọi lúc trong mã kiểu cũ. Và làm những điều kỳ lạ với nhiều người lặp lại thì không.