Comment puis-je rendre ma classe itérable pour pouvoir utiliser la syntaxe foreach?

J'ai Book et BookList classes. BookList est quelque chose comme ceci:

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) { ... }

}

Dans ma classe principale je veux imprimer des titres de livres dans une boucle for each:

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

Eclipse dit:

Ne peut itérer sur un tableau ou d'une instance de java.lang.Itérable

Comment puis-je obtenir ce travail?

source d'informationauteur mk_

Vous avez besoin pour mettre en œuvre les objet iterable de l'interface, ce qui signifie que vous avez besoin pour mettre en œuvre les iterator() méthode. Dans votre cas, cela pourrait ressembler à quelque chose comme ceci:

public class BookList implements Iterable<Book> {
    private final List<Book> bList = new ArrayList<Book>();

    @Override
    public Iterator<Book> iterator() {
        return bList.iterator();
    }

    ...
}

Mettre en œuvre les objet iterable interface. Cela signifie que vous devez mettre en œuvre une méthode qui retourne un Iterator objet qui va itérer sur les éléments d'un BookList.

Dans ce cas, votre iterator() méthode pourrait simplement retourner le résultat de l'appel d' bList.iterator(). (Qui sera la cause de for (Book b : somBookList) pour itérer sur les Book objets dans le BookList.bList ... )

Dans d'autres cas, vous pourriez avoir besoin d'écrire votre propre Iterator<T> mise en œuvre de la classe, complet avec T next()boolean hasNext() et remove() méthodes. Par exemple, si vous souhaitez empêcher de code externe de supprimer les éléments de la BookList par l'intermédiaire de votre itérateur, vous pouvez l'appliquer comme ceci:

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

Ici, nous pouvons voir que la simple mise en œuvre de la LinkedList avec itérateur foreach et de la syntaxe

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

Pour être plus précis sur la façon de "mettre en œuvre le Iterable interface":

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

0

Pour rendre une classe iteratable vous avez besoin pour mettre en œuvre Iterable Interface.

a) de Déclarer la classe en tant que ci-dessous
```
public class BookList implements Iterable<Book>
```
b) Remplacer les iterator() Méthode

Lire Plus.
Espérons qu'il saura vous aider.

Vous devez vous connecter pour publier un commentaire.