Liste filtern nach Prädikaten verschiedener Typen

[looparda]

Ich möchte gern Listen mit Hilfe von mehreren Prädikaten filtern. Meine Anforderungen dabei:

1. die Funktion zum Filtern ist gleich für Listen verschiedener Typen (bspw. gleich für List<Thread> und List<Comment>)
2. die Prädikate sind anwendbar auf mehrere Typen (durch Implementierung des Interfaces HasXXX)
3. die Typen der Prädikate, die zum Filtern in die Methode gesteckt werden werden von den Elementen des Liste implementiert.

Ich habe ein kleines Beispiel gebastelt. Im ersten Schritt sollen List<Thread> und List<Comment> mit Hilfe eines gemeinsamen Prädikats gefiltert werden. Hierzu wird als Beispiel auf die Länge des Autorennamens gefiltert.

public interface HasAuthorName {
    String getAuthorName();
}

public interface HasApprovedStatus {
    boolean isApproved();
}

public class Thread implements HasAuthorName
//, HasApprovedStatus
{
    private final Author author;
    private final boolean isApproved;

    public Thread(Author author, boolean isApproved) {
        this.author = author;
        this.isApproved = isApproved;
    }

    @Override
    public String getAuthorName() {
        return author.getName();
    }


//    @Override
    public boolean isApproved() {
        return isApproved;
    }
}

public class Comment implements HasAuthorName {
    private final Author author;

    public Comment(Author author) {
        this.author = author;
    }

    @Override
    public String getAuthorName() {
        return author.getName();
    }
}

public abstract class Filter {

    private Filter() {}

    public static <T extends HasAuthorName> List<T> filter(List<T> list, Predicate<HasAuthorName>... predicates) {
        return list.stream()
                   .filter(Arrays.stream(predicates).reduce($ -> true, Predicate::and))
                   .collect(Collectors.toList());
    }

}

Das ist super. Ich kann Listen mit Threads und Comments gleichermaßen filtern.

class FilterTest {

    private static List<Thread> threads;
    private static List<Comment> comments;

    private Predicate<HasAuthorName> authorNameLongerThan4CharsPredicate = o -> o.getAuthorName().length() > 4;
    //private Predicate<HasApprovedStatus> approvedStatusPredicate = HasApprovedStatus::isApproved;

    @BeforeAll
    static void setUp() {

        final Author a1 = new Author("Lisa");
        final Author a2 = new Author("Theo");
        final Author a3 = new Author("Alfred");

        comments = Collections.unmodifiableList(Lists.list(
                new Comment(a1),
                new Comment(a2),
                new Comment(a3)
        ));

        threads = Collections.unmodifiableList(Lists.list(
                new Thread(a1, true),
                new Thread(a1, false)
        ));
    }


    @Test
    void testNamePredicate() {
        assertThat(authorNameLongerThan4CharsPredicate.test(() -> "a")).isFalse();
        assertThat(authorNameLongerThan4CharsPredicate.test(() -> "abcd")).isFalse();
        assertThat(authorNameLongerThan4CharsPredicate.test(() -> "abcde")).isTrue();
    }

    //@Test
    //void testApprovedPredicate() {
    //    assertThat(approvedStatusPredicate.test(new Thread(new Author(""), true))).isTrue();
    //    assertThat(approvedStatusPredicate.test(new Thread(new Author(""), false))).isFalse();
    //}

    @Test
    void filterAuthorNames() {
        assertThat(Filter.filter(comments, authorNameLongerThan4CharsPredicate)).hasSize(1);
        assertThat(Filter.filter(threads, authorNameLongerThan4CharsPredicate)).hasSize(0);
    }

    //@Test
    //void filterCombined() {
    //    assertThat(Filter.filter(comments, authorNameLongerThan4CharsPredicate)).hasSize(1);
    //    assertThat(Filter.filter(threads, authorNameLongerThan4CharsPredicate, approvedStatusPredicate)).hasSize(0);
    //}
}

Allerdings möchte ich Listen nach verschiedenen Prädikaten filtern. (Die auskommentierten Stellen ergänzen ein weiteres Attribut zum Filtern). Ich bekomme meine filter-Methode jedoch nicht dazu verschiedene Prädikate zu akzeptieren. Es ist logisch, da die Liste momentan an <T extends HasAuthorName> Elemente gebunden ist. Ich komme leider nicht weiter, wie ich das erreichen kann.
Ich habe das Projekt in den Anhang gepackt, falls jemand probieren möchte.

 

[MoxxiManagarm]

Das ist kein guter Ansatz für jedes Attribut ein neues Interface einzuführen. Am besten du erstellst genau ein Interface, welches genau eine Filtermethode enthält, sagen wir canBeDisplayed. Jede Klasse implementiert diese Methode dann selbst. Equals muss auch jede Klasse selbst definieren.

 

[mrBrown]

Allerdings möchte ich Listen nach verschiedenen Prädikaten filtern. (Die auskommentierten Stellen ergänzen ein weiteres Attribut zum Filtern). Ich bekomme meine filter-Methode jedoch nicht dazu verschiedene Prädikate zu akzeptieren. Es ist logisch, da die Liste momentan an <T extends HasAuthorName> Elemente gebunden ist. Ich komme leider nicht weiter, wie ich das erreichen kann.
Ich habe das Projekt in den Anhang gepackt, falls jemand probieren möchte.

Man müsste in der Filter-Klasse ein bisschen mit Generics spielen, was ginge wäre etwas sowas:

public static <T> List<T> filter(List<? extends T> list, Predicate<? super T>... predicates) {
    return list.stream()
            .filter(t -> Arrays.stream(predicates).allMatch(p -> p.test(t)))
            .collect(Collectors.toList());
}

Das ist kein guter Ansatz für jedes Attribut ein neues Interface einzuführen. Am besten du erstellst genau ein Interface, welches genau eine Filtermethode enthält, sagen wir canBeDisplayed. Jede Klasse implementiert diese Methode dann selbst. Equals muss auch jede Klasse selbst definieren.

Den Vergleich mit equals finde ich schwierig, ob ein Objekte "gültig" ist, ist ja nicht vom Objekt kontrollierbar, sondern hängt von den Bedingungen, die von außen kommen, ab. Ist eher vergleichbar mit Comparable/Comparator, wo es auch völlig üblich ist, das ganze außerhalb der Klasse zu definieren.

Wenn es am Ende wirklich ein Interface pro Attribut gibt, fände ich das zwar auch nicht so schön, glaube aber auch nicht, dass es darauf hinausläuft. Klingt eher danach, dass es am Ende ein paar zu der Domäne passende Interfaces gibt, damit hätte ich kein wirkliches Problem.

 

[looparda]

Vielen Dank, so hatte ich es mir vorgestellt und auch selbst versucht. Predicates.and wurde mir jedoch immer angemeckert und deswegen dachte ich, dass ich auf dem Holzweg sei.

Ich hatte mich an PECS erinnert und dachte somit die Liste müsste nach der Regel definitiv List<? super T> list lauten. Hatte ich aber auch falsch erinnert, da Producer das Lesen meint.

Der Hintergrund ist, dass ich eine Schicht über meine generierten Models legen möchte, weil sie sich ändern werden. Im Prinzip ein einfaches Delegate auf die richtigen Methoden.