Wie funktioniert die erweiterte for-Anweisung für Arrays und wie erhält man einen Iterator für ein Array?

Wenn Sie möchten, eine Iterator über einem array, kann natürlich eine direkte Implementierungen gibt, anstatt zu Verpacken das array in ein List. Zum Beispiel:

Apache-Commons-Collections ArrayIterator

Oder dieser, wenn Sie möchten, dass Generika verwendet werden:

com.Ostermiller.util.ArrayIterator

Beachten Sie, dass, wenn Sie wollen, um eine Iterator über primitiven Typen können Sie nicht, weil eine primitive Typ kann nicht sein, die einen generischen parameter. E. g., wenn Sie möchten, eine Iterator<int> haben, müssen Sie auf eine Iterator<Integer> statt, deren Ergebnis eine Menge von autoboxing und -unboxing wenn es das ist, unterstützt durch eine int[].

InformationsquelleAutor der Antwort uckelman

Arrays.asList(arr).iterator();

Oder schreiben Sie Ihre eigenen, Implementierung ListIterator-interface..

InformationsquelleAutor der Antwort Jochem

In Java 8:

Arrays.stream(arr).iterator();

InformationsquelleAutor der Antwort Haneu

Streng genommen, können Sie nicht bekommen einen iterator, der die primitiven array, weil Iterator.die next () - kann nur ein Objekt zurückgeben. Aber durch die Magie des autoboxing, können Sie den iterator mit dem Arrays.asList() - Methode.

Iterator<Integer> it = Arrays.asList(arr).iterator();

Die obige Antwort ist falsch, Sie können nicht Arrays.asList() auf einem primitiven array, würde es wieder ein List<int[]>. Verwenden Guave's Ints.asList() statt.

InformationsquelleAutor der Antwort Sean Patrick Floyd

Wie wirkt sich die oben for-each-Schleife arbeiten?

Wie viele andere array-Funktionen, die JSL erwähnt arrays explizit und gibt Ihnen Magische Eigenschaften. JLS 7 14.14.2:

EnhancedForStatement:

    for ( FormalParameter : Expression ) Statement

[...]

Wenn der Typ von Ausdruck ist ein Subtyp des Iterabledann die übersetzung ist wie folgt

[...]

Sonst, der Ausdruck notwendigerweise ein array-Typ, T[]. [[ MAGIE! ]]

Lassen L1 ... Lm werden die (möglicherweise leeren) Folge von Etiketten, die unmittelbar vor der erweiterten for-Anweisung.

Die erweiterte for-Anweisung ist äquivalent zu einem einfachen for-Anweisung der form:

T[] #a = Expression;
L1: L2: ... Lm:
for (int #i = 0; #i < #a.length; #i++) {
    VariableModifiersopt TargetType Identifier = #a[#i];
    Statement
}

#a und #i automatisch generierte Bezeichner, die sich von allen anderen Bezeichnern (automatisch generiert oder anderweitig), die sich im Bereich an der Stelle, wo die erweiterte for-Anweisung Auftritt.

Ist das array konvertiert, um eine Liste zu bekommen die iterator?

Let ' s javap:

public class ArrayForLoop {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        for (int i : arr)
            System.out.println(i);
    }
}

dann:

javac ArrayForLoop.java
javap -v ArrayForLoop

main Methode mit ein wenig Bearbeiten, um es einfacher zu Lesen ist:

 0: iconst_3
 1: newarray       int
 3: dup
 4: iconst_0
 5: iconst_1
 6: iastore
 7: dup
 8: iconst_1
 9: iconst_2
10: iastore
11: dup
12: iconst_2
13: iconst_3
14: iastore

15: astore_1
16: aload_1
17: astore_2
18: aload_2
19: arraylength
20: istore_3
21: iconst_0
22: istore        4

24: iload         4
26: iload_3
27: if_icmpge     50
30: aload_2
31: iload         4
33: iaload
34: istore        5
36: getstatic     #2    //Field java/lang/System.out:Ljava/io/PrintStream;
39: iload         5
41: invokevirtual #3    //Method java/io/PrintStream.println:(I)V
44: iinc          4, 1
47: goto          24
50: return

Aufteilung:

• 0 zu 14: erstellen Sie das array
• 15 zu 22: bereiten Sie sich für die for-Schleife. Bei 22store integer 0 vom stack in die lokale position 4. Das ist die loop variable.
• 24 zu 47: die Schleife. Die loop-variable abgerufen am 31und erhöht bei 44. Wenn es gleich der array-Länge, die ist gespeichert in der lokalen variable 3 auf die Kontrolle an 27wird die Schleife beendet.

Abschluss: es ist dasselbe wie eine explizite for-Schleife mit index-variable, keine itereators beteiligt.

InformationsquelleAutor der Antwort Ciro Santilli 新疆改造中心 六四事件 法轮功

Ich bin ein bisschen spät, um das Spiel, aber ich bemerkte, dass einige wichtige Punkte ausgelassen wurden, insbesondere in Bezug auf Java 8 und die Effizienz der Arrays.asList.

1. Wie funktioniert die for-each-Schleife arbeiten?

Als Ciro Santilli 六四事件 法轮功 包卓轩 wies darauf hin, es ist ein handliches Dienstprogramm für die Prüfung der bytecode, der im Lieferumfang des JDK: javap. Mit, dass, können wir feststellen, dass die beiden folgenden code-snippets zu produzieren identischen bytecode wie Java 8u74:

For-each-Schleife:

int[] arr = {1, 2, 3};
for (int n : arr) {
    System.out.println(n);
}

For-Schleife:

int[] arr = {1, 2, 3};

{  //These extra braces are to limit scope; they do not affect the bytecode
    int[] iter = arr;
    int length = iter.length;
    for (int i = 0; i < length; i++) {
        int n = iter[i];
        System.out.println(n);
    }
}

2. Wie bekomme ich einen iterator für ein array in Java?

Während dies funktioniert nicht für primitive, es sollte angemerkt werden, dass die Umwandlung von einem array in eine Liste mit Arrays.asList hat keine Auswirkungen auf die Leistung in entscheidender Weise. Die Auswirkungen auf die beiden Speicher und die Leistung ist fast unermesslich.

Arrays.asList nicht mit einem normalen Liste-Implementierung, die leicht zugänglich ist, wie eine Klasse. Es nutzt java.util.Arrays.ArrayListdas ist nicht das gleiche wie java.util.ArrayList. Es ist ein sehr dünner wrapper um ein array und kann nicht geändert werden. Blick auf den source-code für java.util.Arrays.ArrayList können wir sehen, dass es ist entworfen, um funktionell äquivalent zu einem array. Es ist fast kein Aufwand. Beachten Sie, dass ich ausgelassen habe, alle, aber die meisten relevanten code und fügte meine eigenen Kommentare.

public class Arrays {
    public static <T> List<T> asList(T... a) {
        return new ArrayList<>(a);
    }

    private static class ArrayList<E> extends AbstractList<E> implements RandomAccess, java.io.Serializable {
        private final E[] a;

        ArrayList(E[] array) {
            a = Objects.requireNonNull(array);
        }

        @Override
        public int size() {
            return a.length;
        }

        @Override
        public E get(int index) {
            return a[index];
        }

        @Override
        public E set(int index, E element) {
            E oldValue = a[index];
            a[index] = element;
            return oldValue;
        }
    }
}

Wird der iterator auf java.util.AbstractList.Itr. Soweit Iteratoren gehen, es ist sehr einfach; man ruft einfach get() bis size() erreicht ist, ähnlich wie eine Anleitung für die Schleife tun würde. Es ist die einfachste und am meisten in der Regel effiziente Umsetzung einer Iterator für ein array.

Wieder Arrays.asList keinen java.util.ArrayList. Es ist viel mehr leicht und eignet sich für den Erhalt ein iterator mit vernachlässigbarer Aufwand.

Primitive arrays

Als andere haben darauf hingewiesen, Arrays.asList können nicht verwendet werden, die auf primitive arrays. Java 8 bringt einige neue Technologien für den Umgang mit Sammlungen von Daten, von denen einige könnte verwendet werden, um zu extrahieren einfachen und relativ effizienten Iteratoren von arrays. Beachten Sie, dass wenn Sie, dass Generika verwendet werden, sind Sie immer gehen, um die Boxen-unboxing problem: Sie benötigen zum konvertieren von int nach Integer und dann wieder auf int. Während boxing/unboxing ist in der Regel vernachlässigbar ist, hat es eine O(1) Auswirkungen auf die Leistung in diesem Fall und könnte zu Problemen mit sehr großen arrays oder auf einem Computer mit sehr begrenzten Ressourcen (D. H., SoC).

Mein persönlicher Favorit für jede Art von array casting/boxing-operation in Java 8 ist die neue stream-API. Zum Beispiel:

int[] arr = {1, 2, 3};
Iterator<Integer> iterator = Arrays.stream(arr).mapToObj(Integer::valueOf).iterator();

Die streams-API bietet auch Konstrukte für die Vermeidung der Boxen-Problem in den ersten Platz, aber dies erfordert Verzicht auf Iteratoren zu Gunsten von streams. Es gibt engagierte stream-Typen für int, long und double (IntStream, LongStream, und DoubleStream, beziehungsweise).

int[] arr = {1, 2, 3};
IntStream stream = Arrays.stream(arr);
stream.forEach(System.out::println);

Interessanterweise Java 8 fügt auch java.util.PrimitiveIterator. Dies bietet das beste aus beiden Welten: die Kompatibilität mit Iterator<T> über Boxen zusammen mit Methoden, um zu vermeiden Boxen. PrimitiveIterator hat drei eingebaute Schnittstellen, die Sie erweitern: OfInt, OfLong, und OfDouble. Alle drei Kontrollkästchen, wenn next() genannt wird, sondern können sich auch wieder über primitive Methoden wie nextInt(). Neuer code, der entwickelt wurde für die Java 8 sollte vermeiden, mit next() es sei denn Boxen ist absolut notwendig.

int[] arr = {1, 2, 3};
PrimitiveIterator.OfInt iterator = Arrays.stream(arr);

//You can use it as an Iterator<Integer> without casting:
Iterator<Integer> example = iterator;

//You can obtain primitives while iterating without ever boxing/unboxing:
while (iterator.hasNext()) {
    //Would result in boxing + unboxing:
    //int n = iterator.next();

    //No boxing/unboxing:
    int n = iterator.nextInt();

    System.out.println(n);
}

Wenn Sie noch nicht auf Java 8, leider, Ihre einfachste option ist viel weniger prägnant und ist fast sicher gehen zu beteiligen Boxen:

final int[] arr = {1, 2, 3};
Iterator<Integer> iterator = new Iterator<Integer>() {
    int i = 0;

    @Override
    public boolean hasNext() {
        return i < arr.length;
    }

    @Override
    public Integer next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }

        return arr[i++];
    }
};

Oder wenn Sie wollen, etwas zu schaffen, das mehr wiederverwendbar:

public final class IntIterator implements Iterator<Integer> {
    private final int[] arr;
    private int i = 0;

    public IntIterator(int[] arr) {
        this.arr = arr;
    }

    @Override
    public boolean hasNext() {
        return i < arr.length;
    }

    @Override
    public Integer next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }

        return arr[i++];
    }
}

Können Sie rund um die Boxen-Problem hier, indem Sie Ihre eigenen Methoden für den Erhalt der primitiven, aber es würde funktionieren nur mit Ihren eigenen internen code.

3. Ist das array konvertiert, um eine Liste zu bekommen die iterator?

Nein, es ist nicht. Jedoch, das bedeutet nicht, wickeln Sie es in einer Liste wird Ihnen schlechter Leistung, wenn du etwas leichtes wie Arrays.asList.

InformationsquelleAutor der Antwort Zenexer

Ich mag die Antwort von 30thh mit Iterators aus Guave. Jedoch, von einigen frameworks bekomme ich null statt einem leeren array, und Iterators.forArray(array) behandelt nicht gut. Also ich kam mit dieser Helfer-Methode, die Sie aufrufen können, mit Iterator<String> it = emptyIfNull(array);

public static <F> UnmodifiableIterator<F> emptyIfNull(F[] array) {
    if (array != null) {
        return Iterators.forArray(array);
    }
    return new UnmodifiableIterator<F>() {
        public boolean hasNext() {
            return false;
        }

        public F next() {
            return null;
        }
    };
}

InformationsquelleAutor der Antwort Max Hohenegger