Java Language Créer votre propre structure Iterable à utiliser avec Iterator ou pour chaque boucle.


Exemple

Pour que notre collection puisse être itérée en utilisant un itérateur ou pour chaque boucle, nous devons prendre en charge les étapes suivantes:

  1. Les éléments sur lesquels nous voulons effectuer une itération doivent être Iterable et exposer l' iterator() .
  2. Concevez un java.util.Iterator en hasNext() , next() et remove() .

J'ai ajouté une implémentation de liste chaînée générique simple ci-dessous qui utilise les entités ci-dessus pour rendre la liste chaînée itérable.

package org.algorithms.linkedlist;
 
import java.util.Iterator;
import java.util.NoSuchElementException;
 
 
public class LinkedList<T> implements Iterable<T> {
 
    Node<T> head, current;
 
    private static class Node<T> {
        T data;
        Node<T> next;
 
        Node(T data) {
            this.data = data;
        }
    }
 
    public LinkedList(T data) {
        head = new Node<>(data);
    }
 
    public Iterator<T> iterator() {
        return new LinkedListIterator();
    }
 
    private class LinkedListIterator implements Iterator<T> {
 
        Node<T> node = head;
 
        @Override
        public boolean hasNext() {
            return node != null;
        }
 
        @Override
        public T next() {
            if (!hasNext())
                throw new NoSuchElementException();
            Node<T> prevNode = node;
            node = node.next;
            return prevNode.data;
        }
 
        @Override
        public void remove() {
            throw new UnsupportedOperationException("Removal logic not implemented.");
        }
    }
 
    public void add(T data) {
        Node current = head;
        while (current.next != null)
            current = current.next;
        current.next = new Node<>(data);
    }
 
}
 
class App {
    public static void main(String[] args) {
 
        LinkedList<Integer> list = new LinkedList<>(1);
        list.add(2);
        list.add(4);
        list.add(3);
 
        //Test #1
        System.out.println("using Iterator:");
        Iterator<Integer> itr = list.iterator();
        while (itr.hasNext()) {
            Integer i = itr.next();
            System.out.print(i + " ");
        }
 
        //Test #2
        System.out.println("\n\nusing for-each:");
        for (Integer data : list) {
            System.out.print(data + " ");
        }
    }
}

Sortie

using Iterator:
1 2 4 3
using for-each:
1 2 4 3 

Cela fonctionnera dans Java 7+. Vous pouvez le faire fonctionner sur Java 5 et Java 6 également en remplaçant:

LinkedList<Integer> list = new LinkedList<>(1);

avec

LinkedList<Integer> list = new LinkedList<Integer>(1);

ou juste toute autre version en incorporant les modifications compatibles.