Comment effectuer une itération et effectuer une opération arbitraire sur chaque élément?

Question

J'ai une classe abstraite Iterator qui a cette fonction

void iterate(){ 
    while(this.hasnext()){ 
     ..this.next().. 
    } 
} 

Comment puis-je passer dans une fonction arbitraire qui sera appliquée à l'élément suivant. Par exemple, est-il un moyen de faire iterate(print)?

Answer 1

En Java, il est impossible de transmettre directement des fonctions en tant que paramètres. Au lieu de cela, vous devez configurer une interface avec une méthode comme ceci:

interface Operate { 
    public void operate(Object o); 
} 

, vous devez ensuite implémenter l'interface pour chaque opération différente que vous souhaitez effectuer sur le Object.

Un exemple de mise en œuvre.

class Print implements Operate { 
    public void operate(Object o){ 
     System.out.println(o.toString()); 
    } 
} 

mise en œuvre dans votre code:

iterate(Operate o){ 
    while(this.hasnext()){ 
     o.operate(this.next()); 
    } 
} 

Answer 2

partons du principe que l'impression vous est une fonction? Java n'a pas de pointeurs de fonction ou de véritables fermetures ou quoi que ce soit qui vous permette de passer des fonctions arbitraires à d'autres fonctions, comme vous le verriez dans des langages plus fonctionnels. Vous pouvez simuler cela en créant une interface de fonction, qui a une méthode,

void apply(Object arg) 

Vous pouvez ensuite créer différentes classes qui mettent en œuvre la fonction et passent ceux dans votre méthode itérer. Dans votre exemple, vous feriez quelque chose comme ça peut-être:

public class PrintFunction implements Function { 
     void apply(Object arg) { 
       System.out.println(arg.toString()); 
     } 
    } 

Answer 3

Je réexaminerait la dénomination de clarifier la sémantique:

Avoir une méthode dans la iterator:

public <T> Object[] apply (Action<T> action, Object context) { 
    List<T> results = new ArrayList<T>(); 
    while(hasNext()) { 
     results.add(action.invoke(this.next(), context)); 
    } 
    T[] r = new T[results.size()]; 
    return results.toArray(r); 
} 


public interface Action <T> { 
    public T invoke (Object target, Object context); 
} 

Contexte peut être null, mais dans certains cas vous avez vraiment besoin d'une sorte de pseudo-fermeture pour prendre des actions qui nécessitent un contexte. Pour rendre cela plus robuste, vous pouvez envisager d'ajouter une gestion des exceptions.