Implémenter Java Iterator et Iterable dans la même classe?

J'essaie de comprendre Java Iterator et Iterable interfaces

Je suis en train d'écrire cette classe

class MyClass implements Iterable<String> {
    public String[] a = null;
    public MyClass(String[] arr) {
        a = arr;    
    }

    public MyClassIterator iterator() {
        return new MyClassIterator(this);
    }

    public class MyClassIterator implements Iterator<String> {
        private MyClass myclass = null;
        private int count = 0;
        public MyClassIterator(MyClass m) {
            myclass = m;    
        }

        public boolean hasNext() {
            return count < myclass.a.length;
        }
        public String next() {
            int t = count;
            count++;
            return myclass.a[t];
        }

        public void remove() {
            throw new UnsupportedOperationException();
        }
    }   
}

Il semble fonctionner.

Je devrais avoir:

Myclass implements Iterable<Stirng>, Iterator<String> {

}

Ou je devrais mettre MyClassIterator à l'extérieur MyClass comme

class MyClass implements Iterable<String> {
    public String[] a = null;
    public MyClass(String[] arr) {
        a = arr;    
    }
    public MyClassIterator iterator() {
        return new MyClassIterator(this);
    }
}


    public class MyClassIterator implements Iterator<String> {
        private MyClass myclass = null;
        private int count = 0;
        public MyClassIterator(MyClass m) {
            myclass = m;    
        }

        public boolean hasNext() {
            return count < myclass.a.length;
        }
        public String next() {
            int t = count;
            count++;
            return myclass.a[t];
        }

        public void remove() {
            throw new UnsupportedOperationException();
        }
    }

Lequel est le mieux?

source d'informationauteur icn

33

Vous devriez presque jamais mettre en œuvre à la fois Iterable et Iterator dans la même classe. Ils font des choses différentes. Un itérateur est naturellement stateful - que vous parcourez à l'aide, il doit mettre à jour son point de vue sur le monde. Un objet iterable, cependant, n'a pas besoin d'être en mesure de créer de nouveaux itérateurs. En particulier, vous pouvez avoir plusieurs itérateurs de travail au cours de la même origine itérable en même temps.

Votre approche actuelle est à peu près d'accord - il y a des aspects de la mise en place je changerais, mais c'est bien dans les conditions de la séparation des responsabilités.

Vous étiez sur la bonne voie avec votre premier essai. MyClass seulement besoin de mettre en œuvre Iterable<String>qui à son tour exige de vous fournir un Iterator<String> mise en œuvre pour le retour de Iterable<String>.iterator().

Il n'y a pas besoin de mettre le MyClassIterator à l'extérieur de MyClass parce que dans la plupart des cas, vous n'aurez plus jamais besoin même d'utiliser directement les Iterator<String> (c'est implicitement utilisé par le for .. in .. de la syntaxe Iterable<String>s), et dans tous les autres cas, l'interface est suffisant, sauf si vous avez réellement ajouter un comportement supplémentaire à la mise en œuvre (dont vous n'aurez probablement pas besoin de faire).

Voici comment je le ferais, voir les commentaires inline:

import java.util.Iterator;

class MyClass implements Iterable<String>{
    public String[] a=null; //make this final if you can
    public MyClass(String[] arr){
        a=arr; //maybe you should copy this array, for fear of external modification
    }

    //the interface is sufficient here, the outside world doesn't need to know
    //about your concrete implementation.
    public Iterator<String> iterator(){
        //no point implementing a whole class for something only used once
        return new Iterator<String>() {
            private int count=0;
            //no need to have constructor which takes MyClass, (non-static) inner class has access to instance members
            public boolean hasNext(){
                //simplify
                return count < a.length;
            }
            public String next(){
                return a[count++]; //getting clever
            }

            public void remove(){
                throw new UnsupportedOperationException();
            }
        };
    }
}

2

Vous ne devriez pas faire Myclass implements Iterable<String>,Iterator<String>{ depuis les itérateurs sont à usage unique. À l'exception de la liste des itérateurs, il n'y a aucun moyen de revenir au début.

D'ailleurs, vous pouvez sauter le
```
MyClass myClass;
public MyClassInterator(MyClass m){
  myclass=m;  
}
```
et au lieu de référencer
```
myClass
```
référence
```
MyClass.this
```
L'intérieur de votre classe n'est pas statique, donc MyClass.this référence à l'instance de la classe englobante qui l'a créé.

Je suppose que c'est un moyen standard pour mettre en œuvre l'Itérable et Itérateur en même temps.

//return list of neighbors of v
public Iterable<Integer> adj(int v) {
    return new AdjIterator(v);
}

//support iteration over graph vertices
private class AdjIterator implements Iterator<Integer>, Iterable<Integer> {
    private int v;
    private int w = 0;

    AdjIterator(int v) {
        this.v = v;
    }

    public Iterator<Integer> iterator() {
        return this;
    }

    public boolean hasNext() {
        while (w < V) {
            if (adj[v][w]) return true;
            w++;
        }
        return false;
    }

    public Integer next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }
        return w++;
    }

Référence https://algs4.cs.princeton.edu/41graph/AdjMatrixGraph.java.html.

Vous devez vous connecter pour publier un commentaire.