Goyave - Comment faire pour supprimer à partir d'une liste, basée sur un prédicat, en gardant une trace de ce qui a été enlevé?

J'ai un ArrayList à filtrer, et de divers Goyave Predicates pour le filtre avec. Cette liste sera que de 50 à 100 éléments.

J'avais l'intention de Iterables.removeIf à l'aide de chaque prédicat à son tour. C'est peut-être pas au maximum efficace mais jamais l'esprit (au moins removeIf a certains d'optimisation pour RandomAccess listes)

Pour le débogage, je veux, de façon concise, journal de ce que chaque prédicat n'. par exemple,

Pred0 removed [a, c, g]
Pred1 removed []
Pred2 removed [b, f]

Il y a quelques évident hack des solutions, mais que voulez-vous suggérer que le plus propre?

Pour les points de bonus, il devrait être raisonnablement efficace aussi. 😉

InformationsquelleAutor Iain | 2011-06-27

Je capture les éléments supprimés dans votre Prédicat code.

List<String> removedElements = Lists.newArrayList();
final Iterables.removeIf(list, new Predicate<String>() {
    @Override
    public boolean apply(String input) {
        if ("a".equals(input)) {
            removedElements.add(input);
            return true;
        }
        return false;
    }
});

Merci, c'est ce que je me suis retrouvé avec trop - j'aime sa simplicité. Je suis sûr que c'est pas 100% casher pour un Prédicat à avoir des effets secondaires, mais je n'ai pas vraiment de soins (nous pourrions faire idempotent etc. si nous ne de soins)

InformationsquelleAutor JanRavn

Cela peut être une occasion lors de l'utilisation d'une boucle est plus simple.

List<MyType> list =
Predicate<MyType>[] predicates =
Map<Predicate, List<MyType>> removed = 
      new LinkedHashMap<Predicate, List<MyType>>();
for(Iterator<MyType> iter=list.iterator();list.hasNext();) {
   MyType mt = iter.next();
   for(Predicate<MyType> pred: predicates) 
       if(pred.apply(mt)) {
          List<MyType> mts = removed.get(pred);
          if(mts == null)
              removed.put(pred, mts = new ArrayList<MyType>());
          mts.add(mt);
          iter.remove();
          break;
       }
 }

Un Multimap<Predicate, MyType> rendrait les choses plus concis là aussi.
Merci, je peux voir que cela fonctionne. ...Ça me donne des frissons à remove'ing choses à partir d'un ArrayList.iterator() mais je suppose que pas pire dans la pratique, pour ces petite liste de tailles. (J'ai été intéressé de voir qu'il n'existe pas de stratégie personnalisée pour ArrayList.iterator().remove() la façon dont la Goyave n'en Iterables.removeIf).

InformationsquelleAutor Peter Lawrey

4

J'aimerais étudier dans observables prédicats. L'idée: à chaque fois, un prédicats apply méthode est sur le point de retourner vrai, cela va déclencher une notification aux auditeurs:
```
Iterable<?> iterable = getIterable();
Collection<ObservablePredicate> predicates = getPredicates();
PredicatesLogger log = new PredicatesLogger(predicates);  //listens to all predicates
for (ObservablePredicate pred : predicates) {
  Iterables.removeIf(iterable, pred);
  log.print();
  log.reset();
}
```
La ObservableLogger est un décorateur pour Predicate :
```
public class ObservableLogger implements Predicate {
  private Predicate predicate;

  private List<Listener> listeners = new ArrayList<Listener>();
  //usual stuff for observer pattern

  @Override
  public boolean apply(Object input) {
    boolean result = predicate.apply(input);
    fire(result);
    return result;
  }

  //a fire method
}
```
La PredicateLogger besoin d'un constructeur qui ajoute de lui-même en tant qu'auditeur à la prédicats. Il recevra les notifications et cache les prédicats qui a déclenché les événements (la Event les besoins de la classe un domaine approprié pour cette information). print va créer le message de log, reset va vider les enregistreurs de cache (pour la prochaine course).
- Merci pour l'idée. Pour mon cas, il est probablement trop plaqué or. Aucun point de la construction réutilisables infrastructure lorsque j'ai peut-être jamais besoin de nouveau...
- quid de l'or-plaque pour vos compétences 😀
InformationsquelleAutor Andreas_D

Je suis d'accord avec Peter anwser.

Mais si vous voulez vous amuser, vous pouvez également envelopper chacun de vos prédicat à l'intérieur d'un prédicat qui serait délégué à la enveloppé de prédicat, et de stocker les valeurs pour lesquelles la valeur true est retourné à l'intérieur d'un Map<Predicate, List<Foo>> removedByPredicate :

class PredicateWrapper implements Predicate<Foo> {
    private Predicate<Foo> delegate;

    public PredicateWrapper(Predicate<Foo> delegate) {
        this.delegate = delegate;
    }

    @Override
    public boolean apply(Foo foo) {
        boolean result = delegate.apply(foo);
        if (result) {
            List<Foo> objectsRemoved = removedByPredicate.get(delegate);
            if (objectsRemoved == null) {
                objectsRemoved = Lists.newArrayList();
                removedByPredicate.put(delegate, objectsRemoved);
            }
            objectsRemoved.add(foo);
        }
        return result;
    }
}

Ah ouais même idée que @JanRavn - grâce. (J'aime @PeterLawrey est concis deux-liner façon de gérer une multimap; jamais pensé à ça...)

InformationsquelleAutor JB Nizet

-4

Je suppose que vous avez besoin de:

Predicate<XXX> predicate1 = new Predicate<XXX>(){  
    @Override  
    public boolean apply(XXX input) {  
        if(...) //satisfy your filter
            return true;  
        else  
            return false;  
}};  

Predicate<XXX> predicate2 = new Predicate<XXX>(){  
    @Override  
    public boolean apply(XXX input) {  
        if(...) //satisfy your filter
            return true;  
        else  
            return false;  
}};
Predicate allPredicates = Predicates.and(predicate1, predicate2);
//or Predicates.or(predicate1, predicate2);

Collection<XXX> list2 = Collections2.filter(list, allPredicates);

Ceci ne répond pas à la question.
Ce drôle de if (...) return true; else return false; peut être réduite à ....

InformationsquelleAutor 卢声远 Shengyuan Lu

Vous devez vous connecter pour publier un commentaire.