如何将以列表为值的映射拆分为以较小列表为值的映射

Question

我有个问题。我在enter中得到了一个csv，其值如下：

99,TEST_ABDC,AB01,0000001
99,TEST_ABDC,AB01,0000002
99,TEST_ABDC,AB01,0000003
99,TEST_ABDC,AB01,0000004
99,TEST_ABDC,AB01,0000005
01,TEST_ABDC,AB01,0000006
01,TEST_ABDC,AB01,0000007
02,TEST_ABDC,AB01,0000007

该文件的名称类似于:AB01_TEST_ABDC_YYYYMMDd.csv

[Bar[99,TEST_ABDC,AB01,0000001], 
Bar[99,TEST_ABDC,AB01,0000002], 
Bar[99,TEST_ABDC,AB01,0000003], 
Bar[99,TEST_ABDC,AB01,0000004], 
Bar[99,TEST_ABDC,AB01,0000005],
Bar[01,TEST_ABDC,AB01,0000006], 
Bar[01,TEST_ABDC,AB01,0000007],
Bar[02,TEST_ABDC,AB01,0000007]]

我需要把它们放到一张地图上，就像：

baz = HashMap<Foo, List<Bar>>

Bar是csv中一行的bean，Foo是由Bar的一些元素创建的bean

现在，我成功地通过CSV的第一列值将列表拆分为一个映射。这给了：

Foo[99, TEST_ABDC, AB01_TEST_ABDC_YYYYMMDD.csv, 0]=[Bar[99,TEST_ABDC,AB01,0000001], Bar[99,TEST_ABDC,AB01,0000002], Bar[99,TEST_ABDC,AB01,0000003], Bar[99,TEST_ABDC,AB01,0000004], Bar[99,TEST_ABDC,AB01,0000005]
Foo[01, TEST_ABDC, AB01_TEST_ABDC_YYYYMMDD.csv, 0]=[Bar[01,TEST_ABDC,AB01,0000006], Bar[01,TEST_ABDC,AB01,0000007]]
Foo[02, TEST_ABDC, AB01_TEST_ABDC_YYYYMMDD.csv, 0]=[Bar[02,TEST_ABDC,AB01,0000007]

我是这样做的：

baz = listBar.stream().distinct()
            .collect(Collectors.groupingBy(b -> b.getFooFromBar(fileAbsolutePath)));

baz必须被csv的第一列和每个第一列值的行的itération拆分。因为它在一个键的列表中不能有超过N个元素。（如下面的例子：2）

Foo[99, TEST_ABDC, AB01_TEST_ABDC_YYYYMMDD.csv, 0]=[Bar[99,TEST_ABDC,AB01,0000001], Bar[99,TEST_ABDC,AB01,0000002]]
Foo[99, TEST_ABDC, AB01_TEST_ABDC_YYYYMMDD.csv, 1]=[Bar[99,TEST_ABDC,AB01,0000003], Bar[99,TEST_ABDC,AB01,0000004]]
Foo[99, TEST_ABDC, AB01_TEST_ABDC_YYYYMMDD.csv, 2]=[Bar[99,TEST_ABDC,AB01,0000005]
Foo[01, TEST_ABDC, AB01_TEST_ABDC_YYYYMMDD.csv, 0]=[Bar[01,TEST_ABDC,AB01,0000006], Bar[01,TEST_ABDC,AB01,0000007]]
Foo[02, TEST_ABDC, AB01_TEST_ABDC_YYYYMMDD.csv, 0]=[Bar[02,TEST_ABDC,AB01,0000007]

我需要拆分列表在n元素最大每个键。我有大量的数据（大约10,000 K+)。它必须分成2K的列表。

请问我怎么做？

Answer 1

我建议首先将您的列表划分为子列表的长度，并获得map >> 。为此，只需将以下方法添加到主类中：

static <T> List<List<T>>  chunk(List<T> list, int n){
    final AtomicInteger counter = new AtomicInteger();

    return new ArrayList<>(list.stream()
                                .collect(Collectors.groupingBy(it -> counter.getAndIncrement() / n))
                                .values());
}

然后将另一个构造函数添加到foo类中，该类接受foo和int，通过复制前三个字段创建新的foo，并将新的参数应用到forth字段

public Foo(final Foo foo, int field4) {
    this.field1 = foo.field1;
    this.field2 = foo.field2;
    this.field3 = foo.field3;
    this.field4 = field4;
}

现在，您可以使用上面的代码在baz映射上进行流式传输，将值分块到子列表中，为每个条目创建新的键值对和flatmap并最终收集到map。示例：

    import java.io.IOException;
import java.util.AbstractMap;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

import lombok.AllArgsConstructor;
import lombok.Getter;

public class Example {

    public static void main(String[] args) throws IOException {
    Map<Foo,List<Bar>> baz =
            Map.of(new Foo("99", "TEST_ABDC", "AB01_TEST_ABDC_YYYYMMDD.csv", 0),
                    List.of(new Bar("99","TEST_ABDC","AB01","0000001"),
                            new Bar("99","TEST_ABDC","AB01","0000002"),
                            new Bar("99","TEST_ABDC","AB01","0000003"),
                            new Bar("99","TEST_ABDC","AB01","0000004"),
                            new Bar("99","TEST_ABDC","AB01","0000005")),

                    new Foo("01", "TEST_ABDC", "AB01_TEST_ABDC_YYYYMMDD.csv", 0),
                    List.of(new Bar("01","TEST_ABDC","AB01","0000006"),
                            new Bar("01","TEST_ABDC","AB01","0000007")),

                    new Foo("02", "TEST_ABDC", "AB01_TEST_ABDC_YYYYMMDD.csv", 0),
                    List.of(new Bar("02","TEST_ABDC","AB01","0000007")));


        Map<Foo,List<Bar>> result =
        baz.entrySet()
            .stream()
            .collect(Collectors.toMap(Map.Entry::getKey, e -> chunk(e.getValue(),2)))
                .entrySet()
                .stream()
                .flatMap(e -> IntStream.range(0, e.getValue().size())
                                       .mapToObj(i -> new AbstractMap.SimpleEntry<>(new Foo(e.getKey(),i),e.getValue().get(i))))
                .collect(Collectors.toMap(Map.Entry::getKey,Map.Entry::getValue));

        result.entrySet().forEach(System.out::println);

    }

    static <T> List<List<T>>  chunk(List<T> list, int n){
        final AtomicInteger counter = new AtomicInteger();

        return new ArrayList<>(list.stream()
                                    .collect(Collectors.groupingBy(it -> counter.getAndIncrement() / n))
                                    .values());
    }

    @AllArgsConstructor
    @Getter
    static class Foo{
        String field1;
        String field2;
        String field3;
        int    field4;

    public Foo(final Foo foo, int field4) {
        this.field1 = foo.field1;
        this.field2 = foo.field2;
        this.field3 = foo.field3;
        this.field4 = field4;
    }

        @Override
        public String toString() {
            return "Foo[" + field1 + ", " + field2 + ", " + field3 + ", " + field4 + ']';
        }
    }

    @AllArgsConstructor
    @Getter
    static class Bar{
        String field1;
        String field2;
        String field3;
        String field4;

        @Override
        public String toString() {
            return "Bar[" + field1 + ", " + field2 + ", " + field3 + ", " + field4 + ']';
        }
    }
}