for - recorrer lista java 8

¿Cómo puedo hacer que mi clase sea iterable para poder usar la sintaxis de foreach?

Question

Tengo clases de Book y BookList . BookList es algo como esto:

public class BookList
{
private final List<Book> bList = new ArrayList<Book>();
public int size() { return bList.size(); }
public boolean isEmpty() { ... }
public boolean contains(Book b) { ... }
public boolean add(Book b) { ... }
public boolean remove(Book b) { .. }
public void clear() { ... }
public Object get(int index) { ... }
}

En mi clase principal quiero imprimir títulos de libros con en para cada bucle:

for(Book b : bList)
{
b.print();
}

Eclipse dice:

Solo puede iterar sobre una matriz o una instancia de java.lang.Iterable

¿Cómo puedo hacer que esto funcione?

Answer 1

Aquí podemos ver la implementación simple de LinkedList con iterador y sintaxis de foreach

class LinkedList implements Iterable<LinkedList.Node>{
private Node node;
public void add(Object data){
if(!Optional.ofNullable(node).isPresent()){
node = new Node();
node.setData(data);
}else{
Node node = new Node();
node.setData(data);
Node lastNode = getLastNode(this.node);
lastNode.setNext(node);
}
}
private Node getLastNode(Node node){
if(node.getNext()==null){
return node;
}else{
return getLastNode(node.getNext());
}
}
class Node{
private Object data;
private Node next;
public Object getData() {
return data;
}
public void setData(Object data) {
this.data = data;
}
public Node getNext() {
return next;
}
public void setNext(Node next) {
this.next = next;
}
}
public Iterator<Node> iterator() {
return new NodeIterator();
}
class NodeIterator implements Iterator<Node>{
private Node current;
public boolean hasNext() {
if(current == null){
current = node;
return Optional.ofNullable(current).isPresent();
}else{
current = current.next;
return Optional.ofNullable(current).isPresent();
}
}
public Node next() {
return current;
}
}
}
public class LinkedListImpl {
public static void main(String[] args) {
LinkedList linkedList = new LinkedList();
linkedList.add("data1");
linkedList.add("data2");
linkedList.add("data3");
for(LinkedList.Node node: linkedList){
System.out.println(node.getData());
}
}
}

Answer 2

Implementar la interfaz Iterable . Eso significa que necesita implementar un método que devuelva un objeto Iterator que itere sobre los elementos de una BookList de BookList .

En este caso, el método de iterator() podría devolver el resultado de llamar a bList.iterator() . (Eso causará for (Book b : somBookList) itere sobre los objetos de Book en la BookList.bList ...)

En otros casos, es posible que necesite escribir su propia clase de implementación Iterator<T> , completa con T next() , boolean hasNext() y remove() . Por ejemplo, si desea evitar que el código externo elimine elementos de la BookList través de su iterador, puede implementarlo de la siguiente manera:

public class BookList implements Iterable<Book> {
private final List<Book> bList = new ArrayList<Book>();
//...
@Override
public Iterator<Book> iterator() {
return new Iterator<Book> () {
private final Iterator<Book> iter = bList.iterator();
@Override
public boolean hasNext() {
return iter.hasNext();
}
@Override
public Book next() {
return iter.next();
}
@Override
public void remove() {
throw new UnsupportedOperationException("no changes allowed");
}
};
}
}

Answer 3

Para hacer que una clase sea iteratable, necesita implementar una interfaz Iterable .

a) Declara la clase como abajo

public class BookList implements Iterable<Book>

b) Anular el método iterator()

Leer más . Espero que te ayude.

Answer 4

Para ser más específicos sobre cómo "implementar la interfaz de Iterable ":

public class BookList implements Iterable<Book>
{
private final List<Book> bList = new ArrayList<Book>();
...
@Override
public Iterator<Book> iterator()
{
return bList.iterator();
}
}

Answer 5

Iterable implementar la interfaz de Iterable , lo que significa que debe implementar el método iterator() . En tu caso, esto podría verse así:

public class BookList implements Iterable<Book> {
private final List<Book> bList = new ArrayList<Book>();
@Override
public Iterator<Book> iterator() {
return bList.iterator();
}
...
}