Java 对于这种层次结构，实现过滤器的最佳方式是什么

我有这样的层次结构：

public class Category {

    private Integer id;
    private String name;

    public Category(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

public class SubCategory {

    private String name;
    private Category category;

    public SubCategory(String name, Category category) {
        this.name = name;
        this.category = category;
    }

    public String getName() {
        return name;
    }

    public Category getCategory(){
        return category
    }
}

public class Event {

    private String name;
    private SubCategory subCategory;
    private Collection<Result> result;

    public Event(String name, SubCategory subCategory,
            Collection<Result> result) {
        this.name = name;
        this.subCategory = subCategory;
        this.result = result;
    }

    public String getName() {
        return name;
    }

    public SubCategory getSubCategory() {
        return subCategory;
    }

    public Collection<Result> getResult() {
        return result;
    }

}

public class Result {

    private Integer id;
    private String result;

    public Result(String result) {
        this.result = result;
    }

    public String getResult() {
        return result;
    }
}

公共类类别{
私有整数id；
私有字符串名称；
公共类别（字符串名称）{
this.name=名称；
}
公共字符串getName（）{
返回名称；
}
}
公共类子类别{
私有字符串名称；
私人类别；
公共子类别（字符串名称、类别）{
this.name=名称；
this.category=类别；
}
公共字符串getName（）{
返回名称；
}
公共类别getCategory（）{
退货类别
}
}
公开课活动{
私有字符串名称；
私有子类别子类别；
私人收藏结果；
公共事件（字符串名称、子类别、子类别、，
收集结果）{
this.name=名称；
this.subCategory=子类别；
this.result=结果；
}
公共字符串getName（）{
返回名称；
}
公共子类别getSubCategory（）{
返回子类别；
}
公共集合getResult（）{
返回结果；
}
}
公开课成绩{
私有整数id；
私有字符串结果；
公共结果（字符串结果）{
this.result=结果；
}
公共字符串getResult（）{
返回结果；
}
}

我需要实现以下方法：

public Collection<Event> filter(String category, String subcategory, String result);

公共集合筛选器（字符串类别、字符串子类别、字符串结果）；

如果某些参数为null，则应返回所有可能性

我所创造的（非常愚蠢，但只是在我脑海中）：

公共集合筛选器（字符串类别、字符串子类别、字符串结果）{
Collection res=new HashSet（）；
对于（事件：事件）{
if（event.getSubCategory（）.getCategory（）.getName（）.equals（category））{
决议添加（事件）；
}
if（event.getSubCategory（）.getName（）.equals（subcategory））{
决议添加（事件）；
}
for（结果：event.getResult（））{
if（result.getName（）.equals）（结果）
&&event.getSubCategory（）.getName（）.equals（子类别）
&&event.getSubCategory（）.getCategory（）.getName（）.equals（category））{
决议添加（事件）；
}
}
}
返回res；
}

我不想使用Java8！ 而且结构是固定的。我不能改变它。我可以添加方法和类并更改现有方法，但根本不更改结构。

您可以使用以下方法筛选数据：

public Collection<Event> filter(String category, String subcategory, String result) {
    Stream<Event> s = events.stream();
    if (category != null) { // filter for category
        s = s.filter(e -> e.getSubCategory().getCategory().equals(category));
    }
    if (subCategory != null) { // filter for sub category
        s = s.filter(e -> e.getSubCategory().equals(subCategory));
    }
    if (result != null) { // filter for result
        s = s.filter(e -> e.getResult()
                           .stream()
                           .anyMatch(r -> getResult().equals(result))
                    );
    }

    return s.collect(Collectors.toList());
}

公共集合筛选器（字符串类别、字符串子类别、字符串结果）{
streams=events.Stream（）；
如果（category！=null）{//类别的筛选器
s=s.filter（e->e.getSubCategory（）.getCategory（）.equals（category））；
}
if（subCategory！=null）{//子类别的筛选器
s=s.filter（e->e.getSubCategory（）.equals（subCategory））；
}
如果（result！=null）{//result的过滤器
s=s.filter（e->e.getResult（）
.stream（）
.anyMatch（r->getResult（）.equals（结果））
);
}
返回s.collect（Collectors.toList（））；
}

我建议使用

枚举

而不是使用带有单个

字符串名

字段的类。这只是一个示例。我不想更改结构。例如，应该使用

enum

而不是类来完成。您可以通过在

类别

类上实现

equals

方法来简化所有代码。好了，现在我们在类中没有单个字段。我可以问一下，为什么在子类别中有类别？尽管如此，我认为您需要使子类别成为category的子类别，并在类中实现可比较的接口。然后子类别可以覆盖compareTo方法，您可以将其用于过滤器。

public Collection<Event> filter(String category, String subcategory, String result) {
    Stream<Event> s = events.stream();
    if (category != null) { // filter for category
        s = s.filter(e -> e.getSubCategory().getCategory().equals(category));
    }
    if (subCategory != null) { // filter for sub category
        s = s.filter(e -> e.getSubCategory().equals(subCategory));
    }
    if (result != null) { // filter for result
        s = s.filter(e -> e.getResult()
                           .stream()
                           .anyMatch(r -> getResult().equals(result))
                    );
    }

    return s.collect(Collectors.toList());
}