Java 8中获取属性列表的优化方法？

Question

我的问题是这个问题的延伸。

要获得属性列表，我们可以使用以下代码：

List<String> namesList = personList.stream()
                                   .map(Person::getName)
                                   .collect(Collectors.toList());

但是如果我想得到100个不同的属性。

选项#1：

List<Integer> ageList = personList.stream()
                                   .map(Person::getAge)
                                   .collect(Collectors.toList());

List<String> surnamesList = personList.stream()
                                   .map(Person::getSurname)
                                   .collect(Collectors.toList());

List<String> fathersNamesList = personList.stream()
                                   .map(Person::getFathersName)
                                   .collect(Collectors.toList());

List<String> mothersNamesList = personList.stream()
                                   .map(Person::getMothersName)
                                   .collect(Collectors.toList());

那么，重写这一行100次会更好吗？或者我应该简单地运行1个循环并收集那里的所有属性。

选项2：

for(Person person : persons) {
    namesList.add(person.getName());
    surnamesList.add(person.getSurname());
    fathersNamesList.add(person.getFathersName());
    ...
}

Answer 1

使用Streams，更接近循环方法的解决方案是创建自定义聚合类型：

class AggregatedPersonDetails {
    List<Integer> ageList = new ArrayList<>();
    List<String> surnamesList = new ArrayList<>();
    List<String> fathersnamesList = new ArrayList<>();
    List<String> mothersnamesList = new ArrayList<>();

    public void add(Person person) {
        ageList.add(person.getAge());
        surnamesList.add(person.getSurName());
        fathersnamesList.add(person.getFathersName());
        mothersnamesList.add(person.getMothersName());
    }

    public AggregatedPersonDetails merge(AggregatedPersonDetails other) {
        ageList.addAll(other.ageList);
        surnamesList.addAll(other.surnamesList);
        fathersnamesList.addAll(other.fathersnamesList);
        mothersnamesList.addAll(other.mothersnamesList);
        return this;
    }
}

您可以将其用作：

personList.stream().collect(
        AggregatedPersonDetails::new,
        AggregatedPersonDetails::add,
        AggregatedPersonDetails::merge);

这只允许进行一次迭代。

如果需要在多个位置执行此操作，可以从中提取可重用的收集器：

Collector<Person, AggregatedPersonDetails, AggregatedPersonDetails> collector =
        Collector.of(AggregatedPersonDetails::new, AggregatedPersonDetails::add, AggregatedPersonDetails::merge);

（否则您可以更改并合并（）方法返回无效）

Answer 2

只需使用循环：

// Allocate correct size to avoid resizing
List<String> names = new ArrayList<>(persons.size());
List<String> surnames = new ArrayList<>(persons.size());
List<String> ages = new ArrayList<>(persons.size());
// etc

for (Person person : persons) {
    names.add(person.getName);
    surnames.add(person.getSurname);
    ages.add(person.getAge);
    // etc
}

这将在很大程度上优于使用流，并且易于阅读和理解。

Answer 3

复制同样的逻辑不是一种选择。

为此，最好创建一个通用方法，该方法采用两个参数：源列表和函数：

    public static void main(String[] args) {
        List<Integer> ageList = getListOfAttributes(personList, Person::getAge);
        List<String> surnamesList = getListOfAttributes(personList, Person::getSurName);
    }

    public static <T, R> List<R> getListOfAttributes(List<T> source,
                                                     Function<T, R> func) {
        return source.stream()
                .map(func)
                .collect(Collectors.toList());
    }