Implementando la interfaz Iterable

Question

Acabo de encontrar esta pregunta en un examen antiguo y me estoy preparando para un próximo examen. No puedo resolverlo:

A continuación se muestra una clase parcial artificial que implementa la interfaz Iterable. El único propósito de esta clase es proporcionar un método para iterar sobre el atributo things.

Hay dos cosas que debemos completar en la clase para completarla. Aquí está la clase

private class PartialIterableClass /*FILL IN */ { 
    private String[] things; 
    public PartialIterableClass(String[] things){ 
     this.things = things; 
    } 
    /*FILL IN 2*/ 
} 

que supongo que debe ser algo similar a:

private class PartialIterableClass implements Iterable<PrivateIterableClass> { 
    private String[] things; 
    public PartialIterableClass(String[] things){ 
     this.things = things; 
    } 
    public Iterator<PartialIterableClass> iterator(){ 
    return new Iterator<PartialIterableClass>() { 

    } 
    } 
} 

No estoy muy seguro de cómo dar cuerpo a una respuesta a esta pregunta, sin embargo, puede ayudar a nadie?

Answer 1

Su Iterator debe implementar todos los métodos desde la interfaz Iterator para encapsular la lógica de iteración.

En su caso, tendrá que mantener el índice de iteración actual en la matriz. Se puede ver en ArrayIterator de bienes comunes colecciones

Answer 2

La cosa más fácil de hacer, probablemente sería crear un new ArrayList<String>() llena con los valores de things, y devolver el resultado de una llamada a su método .iterator(). Eso es ciertamente lo que haría en una situación con tiempo limitado (como un examen), y muy probablemente lo que haría en un escenario del mundo real, simplemente para mantener las cosas simples.

Puede escribir su propia clase ArrayIterator, o usar una de varias bibliotecas que puede encontrar en la web, pero parece que eso agregaría una complejidad innecesaria.

Answer 3

private class PartialIterableClass implements Iterable<String> { 
    private String[] things; 
    public PartialIterableClass(String[] things){ 
     this.things = things; 
    } 

    @Override 
    public Iterator<String> iterator() { 
     return Arrays.asList(things).iterator(); 
    } 
} 

Answer 4

Puede utilizar ArrayIterator, o construir su propia iterador de esta manera:

package arrayiterator; 

import java.util.concurrent.locks.Lock; 
import java.util.concurrent.locks.ReentrantLock; 

class ArrayIterator_int 
{ 

    public static void main(String[] args) 
    { 
     int [] arr = { 5, 4, 3, 2, 1 }; 

     ArrayIterator_int iterator = new ArrayIterator_int(arr); 

     while (iterator.hasNext()) 
     { 
      System.out.println(" " + iterator.next()); 
     } 
    } 

    private int cursor; 
    private final int [] array; 
    private static final Lock lock = new ReentrantLock(); 

    public ArrayIterator_int (int [] array) 
    { 
     this.array = array; 
     this.cursor = 0; 
    } 

    public boolean hasNext() 
    { 
     boolean hasNext = false; 
     lock.lock(); 

     try 
     { 
      hasNext = ((this.cursor+1) < this.array.length); 
     } 
     catch(Exception e) 
     { 
      e.printStackTrace(); 
     } 
     finally 
     { 
      lock.unlock(); 
      return hasNext; 
     } 

    } 

    public int next() throws ArrayIndexOutOfBoundsException 
    { 
     int next = 0; 
     lock.lock(); 

     try 
     { 
      next = this.array[++this.cursor]; 
     } 
     catch(ArrayIndexOutOfBoundsException e) 
     { 
      throw e; 
     } 
     catch(Exception e) 
     { 
      e.printStackTrace(); 
     } 
     finally 
     { 
      lock.unlock(); 
      return next; 
     } 
    } 

    public int read() throws ArrayIndexOutOfBoundsException 
    { 
     int read = 0; 
     lock.lock(); 

     try 
     { 
      read = this.array[this.cursor]; 
     } 
     catch(ArrayIndexOutOfBoundsException e) 
     { 
      throw e; 
     } 
     catch(Exception e) 
     { 
      e.printStackTrace(); 
     } 
     finally 
     { 
      lock.unlock(); 
      return read; 
     } 
    } 

    public void write (int newVal) throws ArrayIndexOutOfBoundsException 
    { 
     lock.lock(); 

     try 
     { 
      this.array[this.cursor] = newVal; 
     } 
     catch(ArrayIndexOutOfBoundsException e) 
     { 
      throw e; 
     } 
     catch(Exception e) 
     { 
      e.printStackTrace(); 
     } 
     finally 
     { 
      lock.unlock(); 
     } 
    } 

}