Java'da bir liste üzerinde yineleme yolları

Java diline biraz yeni gelmek, bir liste (veya belki de diğer koleksiyonlar) ve her birinin avantajları veya dezavantajları aracılığıyla yineleyebileceği tüm yolları (veya en azından patolojik olmayanları) tanımaya çalışıyorum.

Bir List<E> listnesne göz önüne alındığında , tüm öğeler arasında dolaşmak için aşağıdaki yolları biliyorum:

Döngü için temel (elbette, eşdeğer / döngüler de var)whiledo while

// Not recommended (see below)!
for (int i = 0; i < list.size(); i++) {
    E element = list.get(i);
    // 1 - can call methods of element
    // 2 - can use 'i' to make index-based calls to methods of list

    // ...
}

Not: @amarseillan'ın işaret ettiği gibi, bu form Lists üzerinde yineleme yapmak için kötü bir seçimdir , çünkü getyöntemin gerçek uygulaması bir Iterator. Örneğin LinkedList, i-th öğesini elde etmek için uygulamalar i'den önceki tüm öğeleri geçmelidir.

Yukarıdaki örnekte, Listuygulamanın gelecekteki yinelemeleri daha verimli hale getirmek için "yerini kaydetmesinin" bir yolu yoktur . Çünkü ArrayListbunun önemi yoktur, çünkü karmaşıklığı / maliyeti getsabit süredir (O ​​(1)), a için ise LinkedListlistenin büyüklüğü (O (n)) ile orantılıdır.

Yerleşik Collectionsuygulamaların hesaplama karmaşıklığı hakkında daha fazla bilgi için bu soruya göz atın .

Döngü için geliştirildi ( bu soruda iyi açıklandı )

for (E element : list) {
    // 1 - can call methods of element

    // ...
}

yineleyici

for (Iterator<E> iter = list.iterator(); iter.hasNext(); ) {
    E element = iter.next();
    // 1 - can call methods of element
    // 2 - can use iter.remove() to remove the current element from the list

    // ...
}

ListIterator

for (ListIterator<E> iter = list.listIterator(); iter.hasNext(); ) {
    E element = iter.next();
    // 1 - can call methods of element
    // 2 - can use iter.remove() to remove the current element from the list
    // 3 - can use iter.add(...) to insert a new element into the list
    //     between element and iter->next()
    // 4 - can use iter.set(...) to replace the current element

    // ...
}

Fonksiyonel Java

list.stream().map(e -> e + 1); // Can apply a transformation function for e

Her biri için , yinelenebilir .

(Java 8'in Stream API'sinden bir harita yöntemi (@ i_am_zero'nun cevabına bakın).)

Java 8 toplama sınıflarında Iterable(örneğin, tüm Lists) uygulanan , yukarıda gösterilen for döngüsü ifadesiforEach yerine kullanılabilecek bir yöntem vardır . (İşte iyi bir karşılaştırma sağlayan başka bir soru .)

Arrays.asList(1,2,3,4).forEach(System.out::println);
// 1 - can call methods of an element
// 2 - would need reference to containing object to remove an item
//     (TODO: someone please confirm / deny this)
// 3 - functionally separates iteration from the action
//     being performed with each item.

Arrays.asList(1,2,3,4).stream().forEach(System.out::println);
// Same capabilities as above plus potentially greater
// utilization of parallelism
// (caution: consequently, order of execution is not guaranteed,
// see [Stream.forEachOrdered][stream-foreach-ordered] for more
// information about this).

Varsa başka hangi yollar var?

(BTW, ilgim hiç performansı optimize etme arzusundan kaynaklanmıyor ; sadece bir geliştirici olarak hangi formların kullanılabilir olduğunu bilmek istiyorum.)

Üç döngü şekli neredeyse aynıdır. Geliştirilmiş fordöngü:

for (E element : list) {
    . . .
}

göre, bir Java Dil Şartname , aynı geleneksel sahip iterasyon kesin kullanımı için yürürlükte fordöngü. Üçüncü durumda, liste içeriğini yalnızca geçerli öğeyi kaldırarak ve ardından yalnızca removeyineleyicinin kendi yöntemiyle yaparsanız değiştirebilirsiniz . Dizin tabanlı yineleme ile listeyi herhangi bir şekilde değiştirebilirsiniz. Ancak, geçerli dizinden önce gelen öğelerin eklenmesi veya kaldırılması, döngü öğelerinizi atlamayı veya aynı öğeyi birden çok kez işleme riskini taşır; bu tür değişiklikler yaparken döngü dizinini doğru şekilde ayarlamanız gerekir.

Her durumda, elementgerçek liste öğesine bir referanstır. Yineleme yöntemlerinin hiçbiri listedeki herhangi bir şeyin kopyasını oluşturmaz. Dahili durumunda yapılan değişiklikler elementher zaman listedeki ilgili elemanın dahili durumunda görülür.

Esasen, bir liste üzerinde yineleme yapmanın yalnızca iki yolu vardır: bir dizin kullanarak veya bir yineleyici kullanarak. Geliştirilmiş döngü, bir yineleyiciyi açıkça tanımlamaktan kaçınmak için Java 5'te sunulan sözdizimsel bir kısayoldur. Her iki stil için for, whileveya do whileblokları kullanarak esasen önemsiz varyasyonlar ortaya çıkarabilirsiniz , ancak hepsi aynı şeye (veya daha ziyade iki şeye) kaynar.

DÜZENLEME: @ iX3 bir yorumda belirttiği gibi, ListIteratorbir listenin geçerli öğesini yineleme yaparken ayarlamak için a kullanabilirsiniz . Sen kullanmanız gerekir List#listIterator()yerine List#iterator()(tabii ki, bir ilan edilmesi gerekir döngü değişkeni başlatmak için ListIteratorbir yerine Iterator).

Soruda listelenen her türden örnek:

ListIterationExample.java

import java.util.*;

public class ListIterationExample {

     public static void main(String []args){
        List<Integer> numbers = new ArrayList<Integer>();

        // populates list with initial values
        for (Integer i : Arrays.asList(0,1,2,3,4,5,6,7))
            numbers.add(i);
        printList(numbers);         // 0,1,2,3,4,5,6,7

        // replaces each element with twice its value
        for (int index=0; index < numbers.size(); index++) {
            numbers.set(index, numbers.get(index)*2); 
        }
        printList(numbers);         // 0,2,4,6,8,10,12,14

        // does nothing because list is not being changed
        for (Integer number : numbers) {
            number++; // number = new Integer(number+1);
        }
        printList(numbers);         // 0,2,4,6,8,10,12,14  

        // same as above -- just different syntax
        for (Iterator<Integer> iter = numbers.iterator(); iter.hasNext(); ) {
            Integer number = iter.next();
            number++;
        }
        printList(numbers);         // 0,2,4,6,8,10,12,14

        // ListIterator<?> provides an "add" method to insert elements
        // between the current element and the cursor
        for (ListIterator<Integer> iter = numbers.listIterator(); iter.hasNext(); ) {
            Integer number = iter.next();
            iter.add(number+1);     // insert a number right before this
        }
        printList(numbers);         // 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15

        // Iterator<?> provides a "remove" method to delete elements
        // between the current element and the cursor
        for (Iterator<Integer> iter = numbers.iterator(); iter.hasNext(); ) {
            Integer number = iter.next();
            if (number % 2 == 0)    // if number is even 
                iter.remove();      // remove it from the collection
        }
        printList(numbers);         // 1,3,5,7,9,11,13,15

        // ListIterator<?> provides a "set" method to replace elements
        for (ListIterator<Integer> iter = numbers.listIterator(); iter.hasNext(); ) {
            Integer number = iter.next();
            iter.set(number/2);     // divide each element by 2
        }
        printList(numbers);         // 0,1,2,3,4,5,6,7
     }

     public static void printList(List<Integer> numbers) {
        StringBuilder sb = new StringBuilder();
        for (Integer number : numbers) {
            sb.append(number);
            sb.append(",");
        }
        sb.deleteCharAt(sb.length()-1); // remove trailing comma
        System.out.println(sb.toString());
     }
}

Listenin uygulanmasını bilmediğiniz için temel döngü önerilmez.

Bu bir LinkedList olsaydı, her çağrı

list.get(i)

liste üzerinde yinelenerek N ^ 2 zaman karmaşıklığına neden olur.

JDK8 tarzı bir yineleme:

public class IterationDemo {

    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3);
        list.stream().forEach(elem -> System.out.println("element " + elem));
    }
}

In Java 8 biz toplama sınıfları üzerinde yineleme için birden fazla yol var.

Yinelenebilir forEach kullanma

Uygulayan koleksiyonların Iterable(örneğin tüm listeler) artık forEachyöntemi vardır. Java 8'de tanıtılan yöntem referansını kullanabiliriz .

Arrays.asList(1,2,3,4).forEach(System.out::println);

Akışları forEach ve forEachOrdered kullanma

Stream'i şu şekilde kullanarak bir liste üzerinde de yineleme yapabiliriz :

Arrays.asList(1,2,3,4).stream().forEach(System.out::println);
Arrays.asList(1,2,3,4).stream().forEachOrdered(System.out::println);

Biz tercih etmeliyiz forEachOrderedüzerinde forEachdavranışı nedeniyle forEachaçıkça deterministik olmayan olduğu kadar forEachOrderedgerçekleştirir akışı tanımlanmış bir karşılaşma olduğunu kabul edersek akışının karşılaşma için bu akımın her elemanı için bir eylem. Bu nedenle forEach, siparişin korunacağını garanti etmez.

Akarsuların avantajı, uygun olan yerlerde paralel akarsuları da kullanabilmemizdir. Amaç yalnızca siparişe bakılmaksızın öğeleri yazdırmaksa, paralel akışı aşağıdaki gibi kullanabiliriz:

Arrays.asList(1,2,3,4).parallelStream().forEach(System.out::println);

Patolojik olarak neyi düşündüğünüzü bilmiyorum, ama daha önce göremediğiniz bazı alternatifler sunmama izin verin:

List<E> sl= list ;
while( ! sl.empty() ) {
    E element= sl.get(0) ;
    .....
    sl= sl.subList(1,sl.size());
}

Veya özyinelemeli sürümü:

void visit(List<E> list) {
    if( list.isEmpty() ) return;
    E element= list.get(0) ;
    ....
    visit(list.subList(1,list.size()));
}

Ayrıca, klasikin özyinelemeli bir versiyonu for(int i=0...:

void visit(List<E> list,int pos) {
    if( pos >= list.size() ) return;
    E element= list.get(pos) ;
    ....
    visit(list,pos+1);
}

Onlardan bahsediyorum çünkü "Java için biraz yenisiniz" ve bu ilginç olabilir.

Java 8'den başlayarak forEach'ı kullanabilirsiniz :

 List<String> nameList   = new ArrayList<>(
            Arrays.asList("USA", "USSR", "UK"));

 nameList.forEach((v) -> System.out.println(v));

Geriye doğru arama için aşağıdakileri kullanmalısınız:

for (ListIterator<SomeClass> iterator = list.listIterator(list.size()); iterator.hasPrevious();) {
    SomeClass item = iterator.previous();
    ...
    item.remove(); // For instance.
}

Bir konum bilmek istiyorsanız iterator.previousIndex () öğesini kullanın. Ayrıca listedeki iki konumu karşılaştıran bir iç döngü yazmaya yardımcı olur (yineleyiciler eşit değildir).

Doğru, birçok alternatif listelenmiştir. En kolay ve en temiz for, aşağıdaki gibi gelişmiş ifadeyi kullanmak olacaktır . Bu Expressionyinelenebilir bir türdür.

for ( FormalParameter : Expression ) Statement

Örneğin, <String> kimliklerini listelemek için,

for (String str : ids) {
    // Do something
}

İçinde bir liste üzerinden yineleme yapmak için ile yöntemini java 8kullanabilirsiniz . List.forEach()lambda expression

import java.util.ArrayList;
import java.util.List;

public class TestA {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("Apple");
        list.add("Orange");
        list.add("Banana");
        list.forEach(
                (name) -> {
                    System.out.println(name);
                }
        );
    }
}

Birinci ve üçüncü örnekleri her zaman while döngüsü ve biraz daha kodla değiştirebilirsiniz. Bu size do-while özelliğini kullanabilme avantajı sağlar:

int i = 0;
do{
 E element = list.get(i);
 i++;
}
while (i < list.size());

Tabii ki, list.size () 0 döndürürse, bu tür şeyler NullPointerException neden olabilir, çünkü her zaman en az bir kez yürütülür. Bu, öğenin özniteliklerini / yöntemlerini kullanmadan önce öğenin boş olup olmadığını test ederek düzeltilebilir. Yine de, for döngüsünü kullanmak çok daha basit ve daha kolay