Java中对象的拆分数组

我陷入了在对象的子数组中拆分数组的困境。我有以下资料：

输入/输出AClass：

 {
    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输入=/。。。
KStream输出=inputs.map（（key，aclass）->{
返回aclass.getAssets（）.stream（）.map（资产->{
AClass transform=新的AClass（）；
transform=aclass.clone（）；
transform.setAssets（Arrays.asList（asset））；
返回新的KeyValue（key，miatransitaset）；
});
});

正如你所见，这是行不通的。但我现在被困在如何用Java流实现这一点上。您可以忽略卡夫卡流，因为它基本相同

---

谢谢你的帮助

使用一个流是可以管理的，但是为了可读性，让mi拆分这个拳头：

为了简单起见，我自己创建了一个类（希望是从JSON描述中得到的）：

类输入{
字符串属性1；
字符串属性2；
列出资产清单；
公共输入（字符串属性1、字符串属性2、列表资产）{
this.attribute1=attribute1；
this.attribute2=attribute2；
这是资产=资产；
}
}

然后进行一些哑初始化，以便处理一些数据：

    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 assets=new ArrayList（）；
Map attributeMap1=新HashMap（）；
Map attributeMap2=新HashMap（）；
属性1.出售（“资产属性1”、“价值1”）；
属性2.出售（“资产属性2”、“价值2”）；
资产。添加（属性P1）；
资产。添加（属性P2）；
输入=新输入（“值1”、“值2”、资产）；
列表输入=数组.asList（输入）；

兰博达斯来了：

首先，必须获取要提取的所有属性（创建新对象的资产列表）：

List extractedAssets=输入
.stream（）
.map（e->e.assets）
.flatMap（集合：：流）
.collect（Collectors.toList（））；

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

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

List collect=extractedAssets.stream（）
.map（e->新输入(
input.attribute1，
input.attribute2，
集合。单音列表（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());

List collect1=输入。
流（）
.map（e->e.assets）
.flatMap（集合：：流）
.map（e->新输入(
输入。获取（0）。属性1，
inputs.get（0）.attribute2，
集合。单音列表（e）））
.collect（Collectors.toList（））；

谢谢您的帮助，普泽米斯·瓦希涅克先生。你激励我朝另一个方向思考，我想我现在找到了一个方法：

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;
            });

KStream输出=inputs.flatMap(
（键、值）->{
列表结果=新建ArrayList（）；
value.getAssets（）.forEach（资产->{
AClass transform=value.clone（）；
transform.setAssets（Arrays.asList（asset））；
add（KeyValue.pair（key，transform））；
});
返回结果；
});

@fps谢谢你的提问。不，那完全是动态的谢谢你详细的回答。我唯一没有从中得到的是输入。*在映射中（e->缺少，对吗？实际上是在我粘贴的这个数据初始化块中（从底部的第二个），但是，对于您的应用程序，您应该有类似于输入[0]的内容。getAttribute1，输入[0]。getAttribute2…：）我将编辑答案，因为它可能会误导。谢谢编辑。现在清楚了。我现在通过forEach找到了另一种方法。见下文。

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());

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;
            });