Java Stream API で複数のフィルターを一度に適用するメソッドを作ってみたけど、これでよかったのか？

/**
 * フィルター条件を複数持つインプット.
 * <p>
 * ※実際はもっと複雑だったり、複合的だったり...
 */
@Data
class InputDto {

    /** フィルターに利用する条件1 */
    private boolean conditions1;
    /** フィルターに利用する条件2 */
    private boolean conditions2;
    /** フィルターに利用する条件3 */
    private boolean conditions3;
    /** フィルターに利用する条件4 */
    private boolean conditions4;
    /** フィルターに利用する条件5 */
    private boolean conditions5;

    // ...
}

private void count(List<InputDto> inputs) {

    // インプットに条件1 を適用したときの件数
    inputs.stream()
        .filter(i -> i.isConditions1())
        .count();

    // インプットに条件2 を適用したときの件数
    inputs.stream()
        .filter(i -> i.isConditions2())
        .count();

    // インプットに条件3, 4 を適用したときの件数
    inputs.stream()
        .filter(i -> i.isConditions3())
        .filter(i -> i.isConditions4())
        .count();

    // インプットに条件1, 3, 5 を適用したときの件数
    inputs.stream()
        .filter(i -> i.isConditions1())
        .filter(i -> i.isConditions3())
        .filter(i -> i.isConditions5())
        .count();
}

/**
 * 集計結果を持つアウトプット.
 */
@Data
class OutputDto {

    /** 条件1 を適用した件数 */
    private Long count1;
    /** 条件2 を適用した件数 */
    private Long count2;
    /** 条件3, 4 を適用した件数 */
    private Long count3And4;
    /** 条件1, 3, 5 を適用した件数 */
    private Long count1And3And5;

    // ...
}

private void makeOutput(List<InputDto> inputs) {

    OutputDto.builder()
        .count1(inputs.stream()
                .filter(i -> i.isConditions1())
                .count())
        .count2(inputs.stream()
                .filter(i -> i.isConditions2())
                .count())
        .count3And4(inputs.stream()
                    .filter(i -> i.isConditions3())
                    .filter(i -> i.isConditions4())
                    .count())
        .count1And3And5(inputs.stream()
                        .filter(i -> i.isConditions1())
                        .filter(i -> i.isConditions3())
                        .filter(i -> i.isConditions5())
                        .count())
        .build();
}

Long フィルターして集計する(List<InputDto> インプットのリスト, Predicate<? super InputDto>... たくさんのフィルター) {
    // ごにょごにょ
    return 件数;
}

Predicate<? super InputDto> とあるフィルター() {
    return インプット -> インプットを使ったフィルター処理;
}
// ... 省略

フィルターして集計する(インプットのリスト, とあるフィルター(), ほかのフィルター());

/**
 * 可変引数で渡されたフィルターをすべてインプットのリストに適用し、その件数を返す.
 *
 * @param inputs
 * @param filters
 * @return フィルター適用後の件数
 */
private final Long filterCount(List<InputDto> inputs, Predicate<? super InputDto>... filters) {
    Stream<InputDto> work = inputs.stream();
    for (Predicate<? super InputDto> filter : filters) {
        work = work.filter(filter);
    }
    return work.count();
}

/**
 * @return {@link InputDto#isConditions1()} を利用したフィルター
 */
private Predicate<? super InputDto> filter1() {
    return i -> i.isConditions1();
}

/**
 * @return {@link InputDto#isConditions2()} を利用したフィルター
 */
private Predicate<? super InputDto> filter2() {
    return i -> i.isConditions2();
}

// ... 中略

/**
 * @return {@link InputDto#isConditions5()} を利用したフィルター
 */
private Predicate<? super InputDto> filter5() {
    return i -> i.isConditions5();
}

private void makeOutput(List<InputDto> inputs) {

    OutputDto.builder()
        .count1(filterCount(inputs, filter1()))
        .count2(filterCount(inputs, filter2()))
        .count3And4(filterCount(inputs, filter3(), filter4()))
        .count1And3And5(filterCount(inputs, filter1(), filter3(), filter5()))
        .build();
}