Cara untuk mengulang daftar di Jawa

Menjadi agak baru dalam bahasa Jawa saya mencoba membiasakan diri dengan semua cara (atau setidaknya yang non-patologis) yang orang mungkin beralih melalui daftar (atau mungkin koleksi lain) dan kelebihan atau kekurangan masing-masing.

Diberikan List<E> listobjek, saya tahu cara-cara berikut untuk mengulang semua elemen:

Dasar untuk loop (tentu saja, ada yang setara while/ do whileloop juga)

// 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

    // ...
}

Catatan: Seperti yang ditunjukkan @amarseillan, formulir ini adalah pilihan yang buruk untuk iterasi List, karena implementasi sebenarnya dari getmetode ini mungkin tidak seefisien ketika menggunakan Iterator. Sebagai contoh, LinkedListimplementasi harus melintasi semua elemen sebelum i untuk mendapatkan elemen ke-i.

Dalam contoh di atas tidak ada cara bagi Listimplementasi untuk "menyelamatkan tempatnya" untuk membuat iterasi masa depan lebih efisien. Untuk suatu ArrayListitu tidak terlalu penting, karena kompleksitas / biaya getadalah waktu yang konstan (O (1)) sedangkan untuk a LinkedListapakah sebanding dengan ukuran daftar (O (n)).

Untuk informasi lebih lanjut tentang kompleksitas komputasi dari Collectionsimplementasi bawaan, lihat pertanyaan ini .

Ditingkatkan untuk loop (dijelaskan dengan baik dalam pertanyaan ini )

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

    // ...
}

Iterator

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

    // ...
}

Java fungsional

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

Iterable.forEach , Stream.forEach , ...

(Metode peta dari Stream API Java 8 (lihat jawaban @ i_am_zero).)

Di Java 8 kumpulan kelas yang mengimplementasikan Iterable(misalnya, semua Lists) sekarang memiliki forEachmetode, yang dapat digunakan sebagai ganti untuk pernyataan loop ditunjukkan di atas. (Ini adalah pertanyaan lain yang memberikan perbandingan yang bagus.)

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

Apa ada cara lain, jika ada?

(BTW, minat saya sama sekali bukan berasal dari keinginan untuk mengoptimalkan kinerja ; Saya hanya ingin tahu bentuk apa yang tersedia bagi saya sebagai pengembang.)

Tiga bentuk perulangan hampir identik. forLingkaran yang disempurnakan :

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

adalah, menurut Spesifikasi Bahasa Jawa , identik dalam efek dengan penggunaan eksplisit dari iterator dengan forloop tradisional . Dalam kasus ketiga, Anda hanya dapat mengubah daftar isi dengan menghapus elemen saat ini dan, kemudian, hanya jika Anda melakukannya melalui removemetode iterator itu sendiri. Dengan iterasi berbasis indeks, Anda bebas untuk mengubah daftar dengan cara apa pun. Namun, menambahkan atau menghapus elemen yang ada sebelum indeks saat ini berisiko memiliki elemen Anda melewatkan elemen atau memproses elemen yang sama beberapa kali; Anda perlu menyesuaikan indeks loop dengan benar saat Anda melakukan perubahan tersebut.

Dalam semua kasus, elementadalah referensi ke elemen daftar aktual. Tak satu pun dari metode iterasi membuat salinan apa pun dalam daftar. Perubahan pada keadaan internal elementakan selalu terlihat dalam keadaan internal elemen yang sesuai pada daftar.

Pada dasarnya, hanya ada dua cara untuk mengulangi daftar: dengan menggunakan indeks atau dengan menggunakan iterator. Enhanced for loop hanyalah pintasan sintaksis yang diperkenalkan di Java 5 untuk menghindari kebosanan mendefinisikan iterator secara eksplisit. Untuk kedua gaya, Anda dapat membuat variasi yang pada dasarnya sepele menggunakan for, whileatau do whileblok, tetapi semuanya bermuara pada hal yang sama (atau, lebih tepatnya, dua hal).

EDIT: Seperti @ iX3 tunjukkan dalam komentar, Anda dapat menggunakan a ListIteratoruntuk mengatur elemen daftar saat ini saat Anda mengulangi. Anda perlu menggunakan List#listIterator()alih-alih List#iterator()menginisialisasi variabel loop (yang, jelas, harus dinyatakan sebagai ListIteratorbukan Iterator).

Contoh setiap jenis yang tercantum dalam pertanyaan:

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

Pengulangan dasar tidak disarankan karena Anda tidak tahu implementasi daftar.

Jika itu adalah LinkedList, setiap panggilan ke

list.get(i)

akan mengulangi daftar, menghasilkan kompleksitas waktu N ^ 2.

Iterasi gaya JDK8:

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

Di Java 8 kami memiliki banyak cara untuk beralih dari kelas koleksi.

Menggunakan Iterable forEach

Koleksi yang menerapkan Iterable(misalnya semua daftar) sekarang memiliki forEachmetode. Kita dapat menggunakan metode-referensi yang diperkenalkan di Java 8.

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

Menggunakan Streams untuk setiap orang dan untuk setiap orang disiapkan

Kami juga dapat mengulangi daftar menggunakan Stream sebagai:

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

Kita harus memilih forEachOrderedlebih dari forEachkarena perilaku forEachsecara eksplisit nondeterministic di mana sebagai forEachOrderedmelakukan tindakan untuk setiap elemen aliran ini, dalam urutan pertemuan aliran jika aliran memiliki urutan pertemuan yang ditentukan. Jadi forEach tidak menjamin bahwa pesanan akan disimpan.

Keuntungan dengan stream adalah kita juga dapat menggunakan stream paralel dimanapun sesuai. Jika tujuannya hanya untuk mencetak barang-barang terlepas dari pesanan maka kita dapat menggunakan aliran paralel sebagai:

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

Saya tidak tahu apa yang Anda anggap patologis, tetapi izinkan saya memberikan beberapa alternatif yang belum pernah Anda lihat sebelumnya:

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

Atau versi rekursifnya:

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

Juga, versi rekursif klasik 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);
}

Saya menyebutkannya karena Anda "agak baru ke Jawa" dan ini bisa menarik.

Anda dapat menggunakan forEach mulai dari Java 8:

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

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

Untuk pencarian mundur Anda harus menggunakan yang berikut:

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

Jika Anda ingin mengetahui posisi, gunakan iterator.previousIndex (). Ini juga membantu untuk menulis loop batin yang membandingkan dua posisi dalam daftar (iterator tidak sama).

Benar, banyak alternatif terdaftar. Yang termudah dan terbersih hanya akan menggunakan forpernyataan yang disempurnakan seperti di bawah ini. Ini Expressiondari beberapa jenis yang dapat diubah.

for ( FormalParameter : Expression ) Statement

Misalnya, untuk beralih melalui, Daftar <String> id, kita bisa begitu,

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

Di java 8Anda dapat menggunakan List.forEach()metode dengan lambda expressionuntuk mengulangi daftar.

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

Anda selalu dapat mengganti contoh pertama dan ketiga dengan loop sementara dan sedikit kode lagi. Ini memberi Anda keuntungan karena dapat menggunakan do-while:

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

Tentu saja, hal semacam ini dapat menyebabkan NullPointerException jika list.size () mengembalikan 0, karena selalu dieksekusi setidaknya sekali. Ini dapat diperbaiki dengan menguji apakah elemennya nol sebelum menggunakan atribut / metode tho. Tetap saja, ini jauh lebih sederhana dan lebih mudah digunakan untuk for loop