如何将集合中的所有对象与同一集合中的所有对象进行比较？

Question

如何将集合中的所有对象与同一集合中的所有其他对象进行比较？我目前将 for 循环与另一个嵌套的 for 循环一起使用。但是，这很慢，我想优化我的方法。

请参阅下面的示例。具体来说，如何优化personsGroupedByFirstName 方法？该方法检索Person 的列表并将其转换为地图，其中每个Person 与具有相同firstName 的其他人分组。

谢谢。

import java.util.*;

class Scratch {
    public static void main(String[] args) {
        new Scratch().start();
    }

    public void start() {
        List<Person> persons = getPersons();
        Map<String, List<Person>> stacks = personsGroupedByFirstName(persons);

        for (Map.Entry<String, List<Person>> entrySet : stacks.entrySet()) {
            String key = entrySet.getKey();
            List<Person> value = entrySet.getValue();

            System.out.println("First name: " + key);
            System.out.println("People: " + value);
        }
    }

    private List<Person> getPersons() {
        return List.of(
                new Person("Andrew", "Red"), new Person("Bob", "Red"),
                new Person("Craig", "Red"), new Person("Daniel", "Red"),
                new Person("Andrew", "Yellow"), new Person("Bob", "Yellow"),
                new Person("Craig", "Yellow"), new Person("Daniel", "Yellow"),
                new Person("Andrew", "Pink"), new Person("Bob", "Pink"),
                new Person("Craig", "Pink"), new Person("Daniel", "Pink"),
                new Person("Andrew", "Green"), new Person("Bob", "Green"),
                new Person("Craig", "Green"), new Person("Daniel", "Green"),
                new Person("Andrew", "Orange"), new Person("Bob", "Orange"),
                new Person("Craig", "Orange"), new Person("Daniel", "Orange"),
                new Person("Andrew", "Purple"), new Person("Bob", "Purple"),
                new Person("Craig", "Purple"), new Person("Daniel", "Purple"),
                new Person("Andrew", "Blue"), new Person("Bob", "Blue"),
                new Person("Craig", "Blue"), new Person("Daniel", "Blue")
        );
    }

    private Map<String, List<Person>> personsGroupedByFirstName(List<Person> persons) {
        Map<String, List<Person>> stacks = new HashMap<>();

        int loop = 0;
        for (Person outer : persons) {
            if (!outer.isReachable()) {
                continue;
            }

            String outerFirstName = outer.getFirstName();
            List<Person> stack = new ArrayList<>();
            for (Person inner : persons) {
                loop = loop + 1;
                if (!inner.isReachable()) {
                    continue;
                }

                if (isSimilar(outerFirstName, inner.getFirstName())) {
                    inner.setReachable(false);
                    stack.add(inner);
                }
            }

            List<Person> tmp = stacks.get(outerFirstName);
            if (tmp == null) {
                tmp = new ArrayList<>();
            }

            tmp.addAll(stack);
            stacks.put(outerFirstName, tmp);
        }

        System.out.println("Total Loops: " + loop);
        return stacks;
    }

    /*
     * Trivial condition. My actual use case computes the Levenshtein Distance.
     * */
    private boolean isSimilar(String outerFirstName, String outerSecondName) {
        return outerFirstName.equals(outerSecondName);
    }
}

class Person {
    private final String firstName;
    private final String secondName;
    private boolean reachable = true;

    public Person(String firstName, String secondName) {
        this.firstName = firstName;
        this.secondName = secondName;
    }

    public String getFirstName() {
        return firstName;
    }

    public String getSecondName() {
        return secondName;
    }

    public boolean isReachable() {
        return reachable;
    }

    public void setReachable(boolean reachable) {
        this.reachable = reachable;
    }

    @Override
    public String toString() {
        return "Person{" +
                "firstName='" + firstName + '\'' +
                ", secondName='" + secondName + '\'' +
                '}';
    }
}

Answer 1

根本不需要执行两个嵌套循环。您是按属性分组，而不是“将每个对象相互比较”。您用来存储结果的映射已经通过键记住了所有遇到的对象。

你可以简单地使用

private Map<String, List<Person>> personsGroupedByFirstName(List<Person> persons) {
    Map<String, List<Person>> result = new HashMap<>();

    for(Person p: persons) {
        List<Person> list = result.get(p.getFirstName());
        if(list == null) {
            list = new ArrayList<>();
            result.put(p.getFirstName(), list);
        }
        list.add(p);
    }
    return result;
}

我认为这个isReachable() 测试是为了优化您的两个嵌套循环，而不是实际任务的一部分。

当您熟悉 lambda 表达式后，您可以进一步简化此循环，在地图上使用单个操作，而不是 get 和 put：

private Map<String, List<Person>> personsGroupedByFirstName(List<Person> persons) {
    Map<String, List<Person>> result = new HashMap<>();

    for(Person p: persons) {
        List<Person> list
            = result.computeIfAbsent(p.getFirstName(), key -> new ArrayList<>());
        list.add(p);
    }
    return result;
}

使用 Stream API 的等效操作是

private Map<String, List<Person>> personsGroupedByFirstName(List<Person> persons) {
    return persons.stream()
        .collect(Collectors.groupingBy(Person::getFirstName));
}

groupingBy(Person::getFirstName) 是groupingBy(Person::getFirstName, toList()) 的简写。