Question

需要根据N个属性字段对List<Object>进行分组，此字段在运行时决定。我怎样才能做到这一点？

Group by multiple field names in java 8 提到这个问题，它使用固定数量的字段。

例如：

Person{ int age, String city, Date doj, double salary}
record1: 25, NYC, 02/25/2018, 50000
record2: 25, MEX, 02/25/2017, 70000
record3: 26, MEX, 02/25/2017, 80000

GroupBy(city, doj)

Record1: = MEX, 02/25/2017, 150000
Record2: = NYC, 02/25/2018, 50000

将增加工资。

我将结果存储在Map<Object, List<Object>> 我已经完成了大部分工作。我面临的唯一问题是如何改变groupingBy中的键。

Collectors.groupingBy( date )：第二次迭代会混淆所有城市的数据，这些城市将按city+date分组。如果我可以将密钥更改为City+Date，这将解决如何在第二次迭代Collectors.groupingBy( date )

中更改我的密钥

Answer 1

这是一个完整的例子：

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;

public class Grouping {

    static final class Person {
        private final int age;
        private final String city;
        private final String doj;
        private final double salary;

        public Person(int age, String city, String doj, double salary) {
            this.age = age;
            this.city = city;
            this.doj = doj;
            this.salary = salary;
        }

        public int getAge() {
            return age;
        }

        public String getCity() {
            return city;
        }

        public String getDoj() {
            return doj;
        }

        public double getSalary() {
            return salary;
        }

        @Override
        public String toString() {
            return "Person{" +
                "age=" + age +
                ", city='" + city + '\'' +
                ", doj='" + doj + '\'' +
                ", salary=" + salary +
                '}';
        }
    }

    enum Property {
        AGE {
            @Override
            protected Object extractValue(Person person) {
                return person.getAge();
            }
        },
        CITY {
            @Override
            protected Object extractValue(Person person) {
                return person.getCity();
            }
        },
        DOJ {
            @Override
            protected Object extractValue(Person person) {
                return person.getDoj();
            }
        };

        protected abstract Object extractValue(Person person);

        public PropertyValue toValue(Person person) {
            return new PropertyValue(this, extractValue(person));
        }
    }

    static final class PropertyValue {
        private final Property property;
        private final Object value;

        public PropertyValue(Property property, Object value) {
            this.property = property;
            this.value = value;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (o == null || getClass() != o.getClass()) {
                return false;
            }
            PropertyValue that = (PropertyValue) o;
            return property == that.property &&
                Objects.equals(value, that.value);
        }

        @Override
        public int hashCode() {
            return Objects.hash(property, value);
        }

        @Override
        public String toString() {
            return "PropertyValue{" +
                "property=" + property +
                ", value=" + value +
                '}';
        }
    }

    private static List<PropertyValue> createGroupingKey(List<Property> properties, Person person) {
        return properties.stream().map(property -> property.toValue(person)).collect(Collectors.toList());
    }

    public static void main(String[] args) {
        List<Person> persons = Arrays.asList(
            new Person(25, "NYC", "02/25/2018", 50000),
            new Person(25, "MEX", "02/25/2017", 70000),
            new Person(26, "MEX", "02/25/2017", 80000)
        );

        // TODO ask the user, rather than hardcoding
        List<Property> groupingProperties = Arrays.asList(Property.CITY, Property.DOJ);

        Map<List<PropertyValue>, Double> salaryAggregatedByChosenProperties =
            persons.stream()
                   .collect(Collectors.groupingBy(p -> createGroupingKey(groupingProperties, p),
                                                  Collectors.summingDouble(Person::getSalary)));

        System.out.println("salaryAggregatedByChosenProperties = " + salaryAggregatedByChosenProperties);
    }
}

它的作用：

询问用户应该使用哪些属性进行分组（这实际上没有完成，但是模拟，因为那不是你问题的核心）。您返回List<Property>，其中包含（例如）CITY和DOJ
您将每个人转换为List<PropertyValue>类型的分组键，因此，第一个人将转换为[NYC，02/25/201]，而第二个和第三个人都将被转换进入[MEX，02/25/2017]（因此具有相同的密钥）。
您按人数分组
您对同一组人员的工资总结

Answer 2

使用JB Nizet建议的解决方案，我整理了一个完整的工作解决方案，您可以在其中按n个字段分组。

可以对任意多个字段进行分组
结果与分组字段顺序无关
用户可以定义聚合策略

此嵌套属性将帮助我们存储用于分组的密钥。

.then(...)

此处的字段是一个简单的对象，将在运行时提供。我们可以有更好的选择来决定其类型。

public class NestedProperty {
    private final Field property;
    private final Object value;
}

此接口应由POGO实现，以定义什么是聚合策略。

public class Field{
        String name;
        Class type;
    }

然后使用NestedProperty对象，使用streams.groupby函数将记录分组到n-1个字段。

public interface Aggregatable<T> {
        public void add(T o);
    }

然后我们可以运行主要的聚合方法

Map<List<NestedProperty>, List<T>> aggregatedRecords = objects.stream()
                    .collect(Collectors.groupingBy(r -> createGroupingKey(Nminus1fields, r), Collectors.toList()));


private static List<NestedProperty> createGroupingKey(java.util.List<Field> fields, Object r) {
            return fields.stream().map(p -> p.toValue(r, p)).collect(Collectors.toList());
        }

请参考以下链接中的答案： http://www.unbounded.in/group-by-n-fields-in-java-like-sql-using-streams-api/

使用流API在Java中分组n个字段

2 个答案: