Zaimplementować Java Iterator i Iterable w tej samej klasie?

Byłeś na dobrej drodze przy pierwszej próbie. MyClass musi jedynie zaimplementować Iterable<String>, co z kolei wymaga dostarczenia Iterator<String> implementacji do powrotu z Iterable<String>.iterator().

Nie ma potrzeby umieszczania MyClassIterator poza MyClass, ponieważ w większości przypadków nigdy nie będziesz musiał bezpośrednio używać Iterator<String> (jest ona używana domyślnie przez składnię for .. in .. na Iterable<String>s), a we wszystkich innych przypadkach interfejs jest wystarczający, chyba że faktycznie dodasz dodatkowe zachowanie do implementacji (co prawdopodobnie nie będzie nigdy nie trzeba).

Oto jak bym to zrobił, Zobacz komentarze:

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

Nie powinieneś robić Myclass implements Iterable<String>,Iterator<String>{, ponieważ Iteratory są jednorazowego użytku. Z wyjątkiem iteratorów list, nie ma możliwości powrotu ich do początku.

Nawiasem mówiąc, możesz pominąć

MyClass myClass;
public MyClassInterator(MyClass m){
  myclass=m;  
}

I zamiast odwoływać się

myClass

Odniesienie

MyClass.this

Twoja wewnętrzna klasa nie jest statyczna, więc MyClass.this będzie odwoływać się do instancji klasy, która ją utworzyła.

Przypuszczam, że jest to standardowy sposób implementacji Iterable i Iterator w tym samym czasie.

// 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++;
    }

Odniesienie https://algs4.cs.princeton.edu/41graph/AdjMatrixGraph.java.html .