Java 8 – 对列表进行分组并查找计数

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Java 8 – 对列表进行分组并查找计数，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含4314字，纯文字阅读大概需要7分钟。

内容图文

我有一个结果列表.我需要找到传递的结果数.但是列表中的某些项目之间存在关联.例如.我有这样的清单

1.0 - false
2.0 - true
3.0 - false
4.0 - true
1.1 - true
3.1 - true

然后传递的计数应该是2而不是4.因为我想基于id(1,1.2,1.3,1.xx in to single group)对列表进行分组,如果组中的所有项目都是,则将其标记为pass通过.我已经尝试过使用grouping的组,我有一张预期行为的地图.我可以迭代地图并获得计数.但我想知道有什么方法可以简单地使用Java 8来做到这一点.

public class Main {

static class Resultx {

    double id = 1;

    Boolean passed = false;

    public void setId(double id) {
        this.id = id;
    }

    public double getId() {
        return id;
    }

    public void setAsPassed() {
        this.passed = true;
    }

    public Boolean getPassed() {
        return passed;
    }

    @Override
    public String toString() {
        return getId() + " - " + getPassed();
    }
}


public static void main(String[] args) {
    List<Resultx> results = new ArrayList<>();
    for (int i = 1; i < 5; i++) {
        Resultx result = new Resultx();
        result.setId(i);
        if (i % 2 == 0) {
            result.setAsPassed();
        }
        results.add(result);
    }
    for (int i = 1; i < 5; i += 2) {
        Resultx result = new Resultx();
        result.setId(i + .1);
        result.setAsPassed();
        results.add(result);
    }
    System.out.println(results.size());
    results.forEach(System.out::println);
    System.out.println(results.stream().filter(Resultx::getPassed).count());
    System.out.println(results.stream().filter(e -> !e.getPassed()).count());
    System.out.println(results.stream().collect(Collectors.groupingBy(r -> (int) (r.getId()))));
}
}

产量

Total count - 6
1.0 - false
2.0 - true
3.0 - false
4.0 - true
1.1 - true
3.1 - true
Total pass count  - 4
Total fail count - 2
{1=[1.0 - false, 1.1 - true], 2=[2.0 - true], 3=[3.0 - false, 3.1 - true], 4=[4.0 - true]}

我想要总传球数和整体失败数.这是2和2

解决方法:

你的代码有一些奇怪的东西,比如使用双ID,你刚刚在分组操作中强制转换为int,或者使用布尔值传递属性而不是布尔值.如果想要这种可能性,使用引用类型Boolean将打开机会为null,您必须处理该机会.否则,只需使用布尔值.

它还不清楚,你真正想要的结果是什么.这个例子不足以描述它.

如果你只想计算组,其中true表示“all where true”,false表示“some where where false”,你可以这样做就像

Map<Boolean,Long> counts = results.stream()
    .collect(Collectors.collectingAndThen(
        Collectors.toMap(r -> (int)r.getId(), Resultx::getPassed, Boolean::logicalAnd),
        m -> m.values().stream()
            .collect(Collectors.partitioningBy(b -> b, Collectors.counting()))
    ));

如果要计算组的元素,它会变得更复杂.

int totalPassedCount = results.stream()
    .collect(Collectors.collectingAndThen(Collectors.groupingBy(r -> (int)r.getId(),
        Collector.of(() -> new Object() { int count = 0; boolean pass = true; },
            (o, r) -> { o.count++; o.pass &= r.getPassed(); },
            (x, y) -> { x.count += y.count; x.pass &= y.pass; return x; },
            o -> o.pass? o.count: 0
        )),
        (Map<Integer,Integer> x) -> x.values().stream().mapToInt(i -> i).sum()
    ));
System.out.println(totalPassedCount);

这使用自定义收集器作为groupingBy的下游收集器.此自定义收集器收集到包含元素计数的对象以及是否所有元素都通过,然后,在完成步骤中,如果组的所有元素都通过则将其替换为count,如果不通过则返回零.然后,将一个完成步骤添加到groupingBy收集器,该收集器将汇总所有这些值.

以上解决方案是为了获得通过的计数,正如您在问题的开头所要求的那样.既然你最后要求两者,你可以使用

Map<Boolean,Integer> counts = results.stream()
    .collect(Collectors.collectingAndThen(Collectors.groupingBy(r -> (int)r.getId(),
        Collector.of(() -> new Object() { int count = 0; boolean pass = true; },
            (o, r) -> { o.count++; o.pass &= r.getPassed(); },
            (x, y) -> { x.count += y.count; x.pass &= y.pass; return x; }
        )),
        m -> m.values().stream().collect(
            Collectors.partitioningBy(o -> o.pass, Collectors.summingInt(o -> o.count)))
    ));

获得两者.

或者,从单个示例中获取预期规则很棘手,

Map<Boolean,Integer> counts = results.stream()
    .collect(Collectors.collectingAndThen(Collectors.groupingBy(r -> (int)r.getId(),
        Collector.of(() -> new Object() { int passed, failed; },
            (o, r) -> { if(r.getPassed()) o.passed++; else o.failed++; },
            (x, y) -> { x.passed += y.passed; x.failed += y.failed; return x; }
        )),
        m -> m.values().stream()
            .filter(o -> o.passed == 0 || o.failed == 0)
            .collect(Collectors.partitioningBy(o -> o.failed==0,
                Collectors.summingInt(o -> o.failed==0? o.passed: o.failed)))
    ));

如果组的所有元素都通过或失败,那么这只会计算通过和失败.但既然你说过,你期望2和2,你可以删除.filter(o – > o.passed == 0 || o.failed == 0)行.然后,只有当组中的所有元素都通过时,它才会计数,但计数全部失败,即使组中的某些元素通过也是如此.然后,你得到2和2作为结果.

内容总结

以上是互联网集市为您收集整理的Java 8 – 对列表进行分组并查找计数全部内容，希望文章能够帮你解决Java 8 – 对列表进行分组并查找计数所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端