java对象中的流分割数组

wsxa1bj1  于 2021-07-03  发布在  Java
关注(0)|答案(2)|浏览(330)

我被困在分裂一个数组在一个对象的子数组。我有以下几点:
输入/输出类:

{
    attribute1: 'value1',
    attribute2: 'value2',
    // etc.
    assets: [
      {assetAttribute1: 'value1', // etc.},
      {assetAttribute2: 'value2', // etc.}
      // etc.
    ]
  }

流输入:

inputs = [
     {
        attribute1: 'value1',
        attribute2: 'value2',
        assets: [
          {assetAttribute1: 'value1', // etc.},
          {assetAttribute2: 'value2', // etc.}
          // etc.
        ]
      },

    ]

预期流输出:

outputs = [
     {
        attribute1: 'value1', // same as from the input
        attribute2: 'value2', // same as from the input
        assets: [
          {assetAttribute1: 'value1', // etc.} // input asset array index 0
        ]
      },
      {
        attribute1: 'value1', // same as from the input
        attribute2: 'value2', // same as from the input
        assets: [
          {assetAttribute2: 'value2', // etc.} // // input asset array index 1
        ]
      },
    ]

代码:

KStream<String, AClass> inputs = //...
KStream<String, AClass> output = inputs.map((key, aclass) -> {
                return aclass.getAssets().stream().map(asset -> {
                    AClass transform = new AClass();
                    transform = aclass.clone();
                    transform.setAssets(Arrays.asList(asset));
                    return new KeyValue<String, AClass>(key, miaTransitAsset);
                });
            });

如你所见,这是行不通的。但我现在被困在如何用java流实现这一点上。你可以忽略Kafka流,因为它基本上是一样的。
谢谢你的帮助!

zzoitvuj

zzoitvuj1#

使用一个流是可以管理的,但是,为了可读性,让我分开这个拳头:
为了简单起见,我自己创建了一个类(希望是从json描述中得到的):

class Input {
    String attribute1;
    String attribute2;
    List<Map<String, String>> assets;

    public Input(String attribute1, String attribute2, List<Map<String, String>> assets) {
        this.attribute1 = attribute1;
        this.attribute2 = attribute2;
        this.assets = assets;
    }
}

然后进行一些愚蠢的初始化以处理一些数据:

List<Map<String, String>> assets = new ArrayList<>();
    Map<String, String> attributeMap1 = new HashMap<>();
    Map<String, String> attributeMap2 = new HashMap<>();

    attributeMap1.put("assetAttribute1", "value1");
    attributeMap2.put("assetAttribute2", "value2");

    assets.add(attributeMap1);
    assets.add(attributeMap2);
    Input input = new Input("value1", "value2", assets);

    List<Input> inputs = Arrays.asList(input);

羔羊来了:
首先,必须获取要提取的所有属性(将在其上创建新对象的资产列表):

List<Map<String, String>> extractedAssets = inputs
            .stream()
            .map(e -> e.assets)
            .flatMap(Collection::stream)
            .collect(Collectors.toList());

然后,对于这些资产中的每一个,您都需要一个您以前在输入中拥有的内容的副本,但是“资产”列表内容有所不同。因此,最好的方法是为每个先前提取的资产创建一个新对象:

List<Input> collect = extractedAssets.stream()
            .map(e -> new Input(
                    input.attribute1,
                    input.attribute2,
                    Collections.singletonList(e)))
            .collect(Collectors.toList());

这应该有用:)
或使用一个流:

List<Input> collect1 = inputs.
            stream()
            .map(e -> e.assets)
            .flatMap(Collection::stream)
            .map(e -> new Input(
                    inputs.get(0).attribute1,
                    inputs.get(0).attribute2,
                    Collections.singletonList(e)))
            .collect(Collectors.toList());
zdwk9cvp

zdwk9cvp2#

谢谢你的帮助ław g公司ę西涅克。你激励我从另一个方向思考,我想我现在找到了一个方法:

KStream<String, AClass> output = inputs.flatMap(
            (key,value) -> {
                List<KeyValue<String, AClass>> result = new ArrayList<>();
                value.getAssets().forEach(asset -> {
                    AClass transform = value.clone();
                    transform.setAssets(Arrays.asList(asset));
                    result.add(KeyValue.pair(key, transform));
                });
                return result;
            });

相关问题