Java：如何从列表转换 到地图 无需迭代

Question

我有一个对象列表，需要将其转换为映射，键是每个元素的函数，值是每个元素的另一个函数的列表。实际上，这是根据元素的功能对元素进行分组。

例如，假设一个简单的元素类：

class Element {
    int f1() { ... }
    String f2() { ... }
}

以及这些的列表：

[
    { f1=100, f2="Alice" },
    { f1=200, f2="Bob" },
    { f1=100, f2="Charles" },
    { f1=300, f2="Dave" }
]

然后我想要一张地图，如下所示：

{
    {key=100, value=[ "Alice", "Charles" ]},
    {key=200, value=[ "Bob" ]},
    {key=300, value=[ "Dave" ]}
}

任何人都可以提出在Java中 无需进行迭代
的简洁方法吗？LambdaJ的group方法与Guava的组合Maps.transform几乎到达了那里，但group没有生成地图。

Answer 1

番石榴具有Maps.uniqueIndex（可迭代值，功能keyFunction）和Multimaps.index（可html" target="_blank">迭代值，功能keyFunction），但是它们不转换值。有一些 请求添加实用工具方法来满足您的要求，但是现在，您必须使用Multimaps.index（）和Multimaps.transformValues（）自行滚动它：

static class Person {
    private final Integer age;
    private final String name;

    public Person(Integer age, String name) {
        this.age = age;
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public String getName() {
        return name;
    }
}

private enum GetAgeFunction implements Function<Person, Integer> {
    INSTANCE;

    @Override
    public Integer apply(Person person) {
        return person.getAge();
    }
}

private enum GetNameFunction implements Function<Person, String> {
    INSTANCE;

    @Override
    public String apply(Person person) {
        return person.getName();
    }
}

public void example() {
    List<Person> persons = ImmutableList.of(
            new Person(100, "Alice"),
            new Person(200, "Bob"),
            new Person(100, "Charles"),
            new Person(300, "Dave")
    );

    ListMultimap<Integer, String> ageToNames = getAgeToNamesMultimap(persons);

    System.out.println(ageToNames);

    // prints {100=[Alice, Charles], 200=[Bob], 300=[Dave]}
}

private ListMultimap<Integer, String> getAgeToNamesMultimap(List<Person> persons) {
    ImmutableListMultimap<Integer, Person> ageToPersons = Multimaps.index(persons, GetAgeFunction.INSTANCE);
    ListMultimap<Integer, String> ageToNames = Multimaps.transformValues(ageToPersons, GetNameFunction.INSTANCE);

    // Multimaps.transformValues() returns a *lazily* transformed view of "ageToPersons"
    // If we want to iterate multiple times over it, it's better to create a copy
    return ImmutableListMultimap.copyOf(ageToNames);
}

可重用的实用程序方法可以是：

public static <E, K, V> ImmutableListMultimap<K, V> keyToValuesMultimap(Iterable<E> elements, Function<E, K> keyFunction, Function<E, V> valueFunction) {
    ImmutableListMultimap<K, E> keysToElements = Multimaps.index(elements, keyFunction);
    ListMultimap<K, V> keysToValuesLazy = Multimaps.transformValues(keysToElements, valueFunction);
    return ImmutableListMultimap.copyOf(keysToValuesLazy);
}

我想我们可以通过使用Function<? extends E, K>或某些方法来改进签名中的泛型，但是我没有时间进一步研究…