用java从列表中获取所需输出的效率如何？

现在，我必须创建一个列表，其中包含以下条件的记录：

在每个电路id中，我需要获得最高小时数的记录，但如果存在重复的小时数，我需要与电力部门一起获取记录

上述结果的结果应如下所示：

CircuitID   Department  Hours

--------------------------------

Circuit A   Electricity      60

Circuit A   Hydel            70

Circuit B   Hydel            30

Circuit C   Electricity      40

Circuit B   Electricity      80

Circuit C   Hydel            50

Circuit A   Electricity      70

让我知道如何使用Java8/java以最有效的方式进行迭代以获得最终列表

我写的代码一点也不完美，我的方法如下所示：

Circuit A  Electricity   70

Circuit B  Electricity   80

Circuit C  Hydel          50

公共静态映射getMaxHours（最终列表电路列表）{
最终映射mappedCircuitsById=新HashMap（）；
用于（最终回路：回路列表）{
如果（！mappedCircuitsById.containsKey（circuit.getCircuitID（）））{
mappedCircuitsById.put（circuit.getCircuitID（），circuit）；
}否则{
最终电路存在max=mappedCircuitsById.get（Circuit.getCircuitID（））；
if（circuit.getHours（）>existingMax.getHours（））mappedCircuitsById.put（circuit.getCircuitID（），circuit）；
else if（circuit.getHours（）==existingMax.getHours（））{
if（circuit.getDepartment（）等于（“电”）mappedCircuitsById.put（circuit.getCircuitID（），circuit）；
else如果（existingMax.getDepartment（）.equals（“电”））mappedCircuitsById.put（circuit.getCircuitID（），existingMax）；
}
}
}
返回MappedCircuitsByd；
}

---

创建一个映射，其中映射的键是

电路ID

，值是满足“最大小时”要求的

电路

对象。迭代列表中的元素，并相应地更新映射以存储新的“最大小时数”

电路

对象

您可以通过带合并功能的

toMap（）

采集器来执行此操作

public static Map<String, Circuit> getMaxHours(final List<Circuit> circuitsList) {
    final Map<String, Circuit> mappedCircuitsById = new HashMap<String, Circuit>();

    for (final Circuit circuit : circuitsList) {
        if (!mappedCircuitsById.containsKey(circuit.getCircuitID())) {
            mappedCircuitsById.put(circuit.getCircuitID(), circuit);
        } else {
            final Circuit existingMax = mappedCircuitsById.get(circuit.getCircuitID());
            if (circuit.getHours() > existingMax.getHours()) mappedCircuitsById.put(circuit.getCircuitID(), circuit);
            else if (circuit.getHours() == existingMax.getHours()) {
                if (circuit.getDepartment().equals("Electricity")) mappedCircuitsById.put(circuit.getCircuitID(), circuit);
                else if (existingMax.getDepartment().equals("Electricity")) mappedCircuitsById.put(circuit.getCircuitID(), existingMax);
            }
        }
    }

    return mappedCircuitsById;
}

Map Map=circuitList
.stream（）
.collect（Collectors.toMap（Circuit:：getCircuitID，Function.identity（），merge））；

合并功能是：

Map<String, Circuit> map = circuitList
             .stream()
             .collect(Collectors.toMap(Circuit::getCircuitID, Function.identity(),merge));

BinaryOperator合并=（左、右）->{
如果（left.hours>right.hours）返回left；
否则如果（left.hours

并得到最终结果：

BinaryOperator<Circuit> merge = (left, right) -> {
        if (left.hours > right.hours) return left;
        else if (left.hours < right.hours) return right;
        //if (left.department.equals("Electricity")) return left;
        if (right.department.equals("Electricity")) return right;
        return left;
};

List result=newarraylist（map.values（））；

我们必须首先根据CircuitID进行分组，并根据我们的要求编写自定义比较器进行过滤。可按如下所示进行：

List<Circuit> result = new ArrayList<>(map.values());

List filteredList=new ArrayList（）；
list.stream（）.collect（Collectors.groupingBy（Circuits:：getCircuitID））.forEach（（key，value）->filteredList.add（compare（value））；
专用静态电路比较（列表）{
电路=零；
用于（电路c：列表）{
if（null==电路）{
电路=c；
}
if（c.getHours（）>circuits.getHours（））{
电路=c；
}else if（c.getHours（）==circuits.getHours（））{
电路=c.getDepartment（）.等效信号（“电”）？c:电路；
}
}
回路；
}

首先编写一个自定义比较器，检查最高小时数，并评估重复小时数情况，以使用

电力

部门：

List<Circuits> filteredList = new ArrayList<>();
list.stream().collect(Collectors.groupingBy(Circuits::getCircuitID)).forEach((key, value) -> filteredList.add(compare(value)));


private static Circuits compare (List<Circuits> list) {
    Circuits circuits = null;
    for (Circuits c : list) {
        if (null == circuits) {
            circuits = c;
        }
        if (c.getHours() > circuits.getHours()) {
            circuits = c;
        } else if (c.getHours() == circuits.getHours()) {
            circuits = c.getDepartment().equalsIgnoreCase("Electricity") ? c : circuits;
        }
    }
    return circuits;
}

---

请显示

电路

类的外观。另外，如果您更正了诸如

getCircuitId

、

getCircuitId（）

、

“电”

、

circuitList（）

以及缩进和右括号之类的打字错误，那就太好了。请使用

groupingBy

按电路收集

。使用下游的
maxBy
和收集器排序，首先按小时排序，然后按类型排序。如果（left.department.equals（“电”）返回left，则可以删除
全部检查。为什么不干脆
maxBy
？@Boristeider，是的，我也想过了<代码>比较器比较器=比较器。比较（电路：：getHours）。然后比较（电路->电路。电路ID。等于（“电”）？1:-1）Map=circuitList.stream（）.collect（Collectors.groupingBy（Circuit:：getCircuitID，Collectors.maxBy（comparator））你的比较器是错误的，因为它从不返回
0
-但是，是的，类似的东西。@Joka Lee
result.forEach（circuit->System.out.printLn（“[circuit id:+circuit.CircuitID+”部门：“+circuit.Department+”小时：“+circuit.Hours+”）
List<Circuit> result = new ArrayList<>(map.values());

List<Circuits> filteredList = new ArrayList<>();
list.stream().collect(Collectors.groupingBy(Circuits::getCircuitID)).forEach((key, value) -> filteredList.add(compare(value)));


private static Circuits compare (List<Circuits> list) {
    Circuits circuits = null;
    for (Circuits c : list) {
        if (null == circuits) {
            circuits = c;
        }
        if (c.getHours() > circuits.getHours()) {
            circuits = c;
        } else if (c.getHours() == circuits.getHours()) {
            circuits = c.getDepartment().equalsIgnoreCase("Electricity") ? c : circuits;
        }
    }
    return circuits;
}

Comparator<Circuit> cmp = new Comparator<Circuit>() {
    @Override
    public int compare(Circuit o1, Circuit o2) {
        
        int compare = Integer.compare(o1.getHours(), o2.getHours());
        
        if(compare==0) {  // equal hours so check for department

            // the element with 'Electricity' value must seem to be have max value
            if(o1.getDepartment().equals("Electricity")) {
                compare = 1;
            }
            if(o2.getDepartment().equals("Electricity")) {
                compare = -1;
            }
        }
        
        return compare;
    }
};

Map<String, Optional<Circuit>> resultMap = circuitList.stream().collect(
                Collectors.groupingBy(Circuit::getCircuitId, Collectors.maxBy(cmp)));
Collection<Optional<Circuit>> result = resultMap.values();
result.forEach(x -> System.out.println(x.get().getCircuitId() + "  " + x.get().getDepartment() + "\t" + x.get().getHours()));