Existe-t-il une implémentation Java de type "réduire"?

Question

J’ai souvent besoin d’exécuter java pour réduire les éléments d’un Itterable (appelé également foldl / foldr, en fonction de vos contextes).

Réduire prend une collection / iterable / etc, une fonction de deux paramètres et une valeur de départ facultative (selon les détails de la mise en oeuvre). La fonction est appliquée successivement à un élément de la collection et à la sortie de l'appel précédent de réduire jusqu'à ce que tous les éléments aient été traités et renvoie la valeur finale.

Existe-t-il une implémentation digne de ce type de réduire dans une API java commune? Google Collections il semble qu'il devrait en avoir un, mais je n'ai pas pu le faire. pour le trouver. (peut-être parce que je ne sais pas quels autres noms il utiliserait.)

Answer 1

vous pourriez probablement lancer votre propre générique assez facilement, en fonction de votre description:

public interface Reducer<A, T>
{
    public A foldIn(A accum, T next);
}

Ensuite, en utilisant le modèle de stratégie:

public class Reductor<A, T>
{
    private Reducer<A, T> worker;
    public Reductor<A, T>(Reducer<A, T> worker)
    {
        this.worker = worker;
    }

    public A fold(A rval, Iterator<T> itr)
    {
        while(itr.hasNext())
        {
            A rval = worker.foldIn(rval, itr.next());
        }
        return rval;
    }
}

Je suis sûr qu’il ya une tonne d’erreurs de syntaxe, mais c’est l’essentiel (il ya quelques choix à faire pour obtenir la valeur d’accumulateur vide. Ensuite, pour l’utiliser sur un itérateur particulier, définissez simplement votre réducteur sur le voler:

Reductor r = new Reductor<A, T>(new Reducer<A, T>()
{
    public A foldIn(A prev, T next)
    {
        A rval;
       //do stuff...
       return rval;
     }
 }

 A fold = r.fold(new A(), collection.getIterator());

En fonction du fonctionnement de votre itérateur, celui-ci peut être plié à gauche ou à droite tant que l'itérateur va dans la bonne direction.

espérons que cela aide.

Answer 2

Sur la base de la suggestion de Luke, voici une implémentation Java légitime:

public interface Reducer<A,T>
{
    A foldIn(A accum, T next);
}

public static <T> T reduce(final Reducer<T,T> reducer, 
        final Iterable<? extends T> i)
{
    T result = null;
    final Iterator<? extends T> iter = i.iterator();
    if (iter.hasNext())
    {
        result = iter.next();
        while (iter.hasNext())
        {
            result = reducer.foldIn(result, iter.next());
        }
    }
    return result;
}

public static <A,T> A reduce(final Reducer<A,T> reducer, 
        final Iterable<? extends T> i, 
        final A initializer)
{
    A result = initializer;
    final Iterator<? extends T> iter = i.iterator();
    while (iter.hasNext())
    {
        result = reducer.foldIn(result, iter.next());
    }
    return result;
}

Answer 3

Essayez le paquet Functor commons . Il est dans le bac à sable depuis toujours, mais je pense que ça fera ce que vous voulez.