Java 我可以使用流将一个元素映射到多个元素吗？

是否可以使用Java流将一个集合映射到另一个集合，但第二个集合必须与第一个集合具有不同的元素计数

我有地图

"1" -> 10, "2-3" -> 20

想把它转换成

List<Node> = Node(1,10), Node(2,20), Node(3,20)

List=节点（1,10）、节点（2,20）、节点（3,20）

如何使用streams实现这一点

我的代码是：

import com.google.common.collect.ImmutableMap;

import java.util.*;

import static java.util.stream.Collectors.toList;

public class MapOneToManyQuestion {

    public static void main(String[] args) {
        new MapOneToManyQuestion().run();
    }

    void run() {
        final Map<String, Integer> map = ImmutableMap.of("1", 10, "2-3", 20);

        List<Node> nodes = map.entrySet().stream().map(entry -> {
            if (Objects.equals(entry.getKey(), "1")) {
                return new Node(1, entry.getValue());
            } else {
                //return new Node(2, entry.getValue());
                //return new Node(3, entry.getValue());
            }
        }).collect(toList());
    }

    class Node {
        private Integer key;
        private Integer value;

        public Node(Integer key, Integer value) {
            this.key = key;
            this.value = value;
        }

        public Integer key() {
            return this.key;
        }

        public Integer value() {
            return this.value;
        }
    }
}

import com.google.common.collect.ImmutableMap；
导入java.util.*；
导入静态java.util.stream.Collectors.toList；
公共类MapOneToManyQuestion{
公共静态void main（字符串[]args）{
新建MapOneToManyQuestion（）.run（）；
}
无效运行（）{
最终地图=不可变地图（1,10,2-3,20）；
列表节点=map.entrySet（）.stream（）.map（条目->{
if（Objects.equals（entry.getKey（），“1”））{
返回新节点（1，entry.getValue（））；
}否则{
//返回新节点（2，entry.getValue（））；
//返回新节点（3，entry.getValue（））；
}
}).collect（toList（））；
}
类节点{
私钥；
私有整数值；
公共节点（整型键、整数值）{
this.key=key；
这个值=值；
}
公共整数密钥（）{
返回此.key；
}
公共整数值（）{
返回此.value；
}
}
}

您可以使用

flatMap

进行此操作

List<Node> nodes = map.entrySet()
        .stream()
        .flatMap(entry -> {
            String key = entry.getKey();
            Integer value = entry.getValue();
            return Arrays.stream(key.split("-"))
                    .map(splitKey -> new Node(Integer.valueOf(splitKey), value));
        })
        .collect(Collectors.toList());

List nodes=map.entrySet（）
.stream（）
.flatMap（条目->{
String key=entry.getKey（）；
整数值=entry.getValue（）；
返回Arrays.stream（key.split（“-”））
.map（splitKey->new节点（Integer.valueOf（splitKey），value））；
})
.collect（Collectors.toList（））；

---

它流经每个映射元素，并按

-

分割键，为分割产生的每个键部分和该条目的映射值创建一个

节点

对象，最后将其收集到一个列表中。

您可以使用

平面映射

List<Node> nodes = map.entrySet()
        .stream()
        .flatMap(entry -> {
            String key = entry.getKey();
            Integer value = entry.getValue();
            return Arrays.stream(key.split("-"))
                    .map(splitKey -> new Node(Integer.valueOf(splitKey), value));
        })
        .collect(Collectors.toList());

List nodes=map.entrySet（）
.stream（）
.flatMap（条目->{
String key=entry.getKey（）；
整数值=entry.getValue（）；
返回Arrays.stream（key.split（“-”））
.map（splitKey->new节点（Integer.valueOf（splitKey），value））；
})
.collect（Collectors.toList（））；

---

它流经每个映射元素，并按

-

拆分键，为拆分后的每个键部分创建一个

节点

对象以及该条目的映射值，最后将其收集到列表中。

是的，您可以。这就是

flatMap

的用途。是的，你可以。这就是

flatMap

的用途。