Itérable un type de retour

Je vais avoir de la difficulté à comprendre une méthode. J'ai méthodes que j'ai besoin de remplir, mais je ne comprends pas vraiment la première. Comment peut-Itérable être un type de retour et comment est-il utilisé ? Un exemple serait génial..

@Override
public Iterable<ClientInterface> getNeighbours() {

    return null;
}

@Override
public void addNeighbour(ClientInterface newNeighbour){
    //TODO Implement me!
}

@Override
public void removeNeighbour(String clientID) {
    //TODO Implement me!
}
Essayez de les ajouter à votre Liste de classe comme un membre privé et de l'utiliser dans tous les 3 de ces méthodes.
stackoverflow.com/questions/5849154/...
Ce qui vous fait penser à Itérable ne pouvait pas être un type de retour? Sûr qu'il peut.

OriginalL'auteur Tolga Tamer | 2014-04-18

  1. 7

    Il ressemble à votre classe doit avoir une mise en œuvre de Iterable<ClientInterface> en tant que membre de la classe, comme ArrayList.

    Nous allons utiliser comme exemple:

    public class Bus {
   private ArrayList<Person> riders;
   ... //constructors and other methods

   public Iterable<Person> getRiders() {

     return riders;

   }
   ... //other methods
}

    OriginalL'auteur Mike

  2. 6

    Tout peut être un type de retour: un enum, une classe, une interface, un int, une exception etc.

    Iterable est un interface qui pourrait être utilisé pour utiliser le retour dans un foreach appel (c'est pourquoi vous pouvez utiliser for(T something : AnArrayList) parce que ArrayList<T> implémente Iterable<T>)

    Maintenant, ma réponse contient un exemple:

    Nous avons une méthode getNeighbours qui renvoie Iterable<ClientInterface> 

    public Iterable<ClientInterface> getNeighbours()
{
    return new Iterable<ClientInterface>();
}

    Bien, ok, puisque Iterable est juste une interface, nous avons besoin de mettre en œuvre des méthodes ou de l'utilisation d'une mise en œuvre.

    Puisque c'est quelque chose que nous devrions faire manuellement, nous devrions mettre en œuvre les méthodes par nous-mêmes.

    La seule méthode (dans Java8, il y a 3 méthodes, mais nous allons l'ignorer) est iterator() qui retourne un iterator.

    public Iterable<ClientInterface> getNeighbours()
{
    return new Iterable<ClientInterface>()
    {
        @Override
        public Iterator<ClientInterface> iterator()
        {
            return null;
        }
    };
}

    Iterator est une autre interface qui est utilisée pour fournir la logique d'itérer sur la collection, une liste d'éléments, etc.

    Nous sommes obligés de met en œuvre deux méthodes: hasNext et prochaine

    hasNext est utilisé pour déterminer si il y a plus d'éléments à parcourir, next est utilisé pour itérer sur elle.

    public Iterable<ClientInterface> getNeighbours()
{
    return new Iterable<ClientInterface>()
    {
        @Override
        public Iterator<ClientInterface> iterator()
        {
            return new Iterator<ClientInterface>()
            {
                @Override
                public boolean hasNext()
                {
                    return false;
                }

                @Override
                public ClientInterface next()
                {
                    return null;
                }
            };
        }
    };
}

    Nous avons ici besoin de se souvenir de ce qui fut notre dernière position de sorte que l'on crée un champ à l'intérieur de notre Itérateur.

    public Iterable<ClientInterface> getNeighbours()
{
    return new Iterable<ClientInterface>()
    {
        @Override
        public Iterator<ClientInterface> iterator()
        {
            return new Iterator<ClientInterface>()
            {
                private int position;

                @Override
                public boolean hasNext()
                {
                    return false;
                }

                @Override
                public ClientInterface next()
                {
                    return null;
                }
            };
        }
    };
}

    Voici le problème: Ce que nous devons effectuer une itération? Il dépend de vous, un exemple pourrait être:

    public Iterable<ClientInterface> getNeighbours()
{
    return new Iterable<ClientInterface>()
    {
        @Override
        public Iterator<ClientInterface> iterator()
        {
            return new Iterator<ClientInterface>()
            {
                private int position;
                private ClientInterface[] items = new ClientInterface[]{new ClientInterface(), new ClientInterface()};

                @Override
                public boolean hasNext()
                {
                    return position != items.length;
                }

                @Override
                public ClientInterface next()
                {
                    if (!hasNext()) throw new NoSuchElementException();
                    return items[position++];
                }
            };
        }
    };
}

    Noter ici comment nous avons créé un tableau d'éléments et utilisé de nos deux méthodes hasNext et next de fournir un moyen pour effectuer une itération sur elle.

    Chaque appel de next incrémenter le pointeur interne, et notre méthode hasNext vérifie juste si le pointeur atteint la fin du tableau.

    Collections comme ArrayList, LinkedList etc. déjà fait le travail pour vous et meilleur (implémente remove méthode), vous pouvez obtenir cet itérateur en utilisant ArrayList.iterator()

    Maintenant vous pouvez écrire quelque chose comme:

    for (ClientInterface el : yourClass.getNeighbours())
{
    System.out.println(el);
}
    merci pour l'explication! privé ClientInterface[] items = new ClientInterface[]{new ClientInterface(), new ClientInterface()};comment sa possiable pour créer un objet à partir de l'interface ?et quand je veux ajouter plus de clientInterface puis ce qui se passe ?
    Dans ce cass vous ne créez pas une interface, vous créez une classe anonyme qui implémente l'interface (note {}) dans ce cas, c'était tout de même un exemple de vos données doit être à l'intérieur de l'extérieur de la classe pas dans l'itérateur ou vous allez créer une copie de celui-ci à chaque fois

    OriginalL'auteur Marco Acierno

  3. 2

    Iterable<T> est une interface. Ce que cela signifie est que lorsque vous l'avez reçu une valeur de retour d'une méthode, vous la recevrez un mise en œuvre. Donc, si vous ne savez pas ce que le nom de la mise en oeuvre (le nom de la classe qui implémente l' Iterable<T> interface), vous pouvez toujours accéder aux méthodes qu'elle met en œuvre, et d'agir sur elle.

    Certains intégrés dans les implémentations inclure ArrayList, LinkedList, HashSet, PriorityQueue, et Stack.

    Lorsque vous avez besoin de retourner un type d'interface, vous devez retourner une mise en œuvre.

    un exemple de comment je suis censé faire serait génial..

    OriginalL'auteur d3dave