在使用类似Java Lambda的映射时，如何在group-2中使用group-1结果键1<；键1，地图<；键2，列表<；Obj>&燃气轮机&燃气轮机；

如何通过Java Lambda在group-2中使用group-1结果

此问题是从我的已解决问题中更新的：

您可以看到最后一个代码。 函数键2要使用函数键1的结果，如何操作

class Person{
   int age;
   int cityCode;
   String name;
}

method:

// Map<age, Map<cityCode, List<Person>>>
public Map<Integer, Map<Integer, List<Person>>> covertListToMap(List<Person> list){

      // TODO: How to make List<Person> to Map<age, Map<cityCode, List<Person>>>

}

班级人员{
智力年龄；
国际城市代码；
字符串名；
}
方法：
//地图
公共映射CovertListMap（列表）{
//TODO:如何将列表制作成地图
}

功能键1=（人员p）->{
//做很多事情然后得到一个关键结果：
int key1Result=p.getAge（）*新随机数（10.nextInt（）；
返回键1result；
};
功能键2=（人员p）->{
//问题：如何获取和使用功能键1键1结果：
int key1Result=0；
int result=p.getCityCode（）+key1Result；
返回结果；
};
Map collect=list.stream（）.collect（groupingBy（key1，groupingBy（key2））；

我写了一个错误的示例来说明我的意思：

Map<Integer, Map<Integer, List<Person>>> collect = list.stream().collect(groupingBy((Person p) -> {
            int key1Result = p.getAge() * new Random(10).nextInt();
            return key1Result;  // perhaps, now, key1Result is 10
        }, groupingBy((Person p) -> {

            // now, I want to get the key1Result which is 10, How to do it?  
            int key1Result = 0;

            int result = p.getCityCode() + key1Result;
            return result;
        })));

Map collect=list.stream（）{
int key1Result=p.getAge（）*新随机数（10.nextInt（）；
return key1Result；//现在，key1Result可能是10
}，分组依据（（个人p）->{
//现在，我想得到key1Result，也就是10，怎么做？
int key1Result=0；
int result=p.getCityCode（）+key1Result；
返回结果；
})));

您可以使用功能

apply（T）

。根据报告：

将此函数应用于给定参数

就你而言，这意味着：

int key1Result = key1.apply(p)

编辑：当您修改您的问题时，我添加了一个答案，如果我理解您想做什么，那么答案应该是正确的：

AtomicInteger atomicInteger = new AtomicInteger(0);
Map<Integer, Map<Integer, List<Person>>> collect = personList.stream().collect(Collectors
        .groupingBy(p -> {
                int age = p.getAge() * new Random(10).nextInt();
                atomicInteger.set(age);
                return age;
            }, Collectors.groupingBy(p2 -> p2.getCityCode() + atomicInteger.get())));

AtomicInteger AtomicInteger=新的AtomicInteger（0）；
Map collect=personList.stream（）.collect（收集器
.分组依据（p->{
int age=p.getAge（）*新的Random（10.nextInt（）；
原子整数集（年龄）；
回归年龄；
}，Collectors.groupingBy（p2->p2.getCityCode（）+atomicInteger.get（））；

---

如果要阅读有关原子整数的更多信息，请参阅。基本上，它是一个包装器，将在线程之间保持其变量。

您可以使用函数

apply（T）

。根据报告：

将此函数应用于给定参数

就你而言，这意味着：

int key1Result = key1.apply(p)

编辑：当您修改您的问题时，我添加了一个答案，如果我理解您想做什么，那么答案应该是正确的：

AtomicInteger atomicInteger = new AtomicInteger(0);
Map<Integer, Map<Integer, List<Person>>> collect = personList.stream().collect(Collectors
        .groupingBy(p -> {
                int age = p.getAge() * new Random(10).nextInt();
                atomicInteger.set(age);
                return age;
            }, Collectors.groupingBy(p2 -> p2.getCityCode() + atomicInteger.get())));

AtomicInteger AtomicInteger=新的AtomicInteger（0）；
Map collect=personList.stream（）.collect（收集器
.分组依据（p->{
int age=p.getAge（）*新的Random（10.nextInt（）；
原子整数集（年龄）；
回归年龄；
}，Collectors.groupingBy（p2->p2.getCityCode（）+atomicInteger.get（））；

---

如果要阅读有关原子整数的更多信息，请参阅。基本上，它是一个包装器，它将在线程之间保持其变量。

首先，使用修改过的密钥收集所需的映射

Map<Integer, Map<Integer, List<Person>>> collect2 = personList.stream().collect(Collectors
        .groupingBy(p -> p.getAge() * new Random(10).nextInt(),
                Collectors.groupingBy(Person::getCityCode)));

---

首先，使用修改过的密钥收集所需的地图

Map<Integer, Map<Integer, List<Person>>> collect2 = personList.stream().collect(Collectors
        .groupingBy(p -> p.getAge() * new Random(10).nextInt(),
                Collectors.groupingBy(Person::getCityCode)));

---

---

当你说Key2想要使用key1的结果时，这意味着什么？你能提供一个例子吗？

int-key1Result=key1.apply（person）

？？我更新了我的问题，以解释我在第三个代码区域中的意思。也许可以尝试链接groupBys，而不是嵌套groupBys。这里真正的问题是数组的映射。当你说Key2想要使用key1的结果时，这意味着什么？你能提供一个例子吗？

int-key1Result=key1.apply（person）

？？我更新了我的问题，以解释我在第三个代码区域的意思。也许可以尝试链接groupBys，而不是嵌套groupBys。这里真正的问题是阵列的地图对不起，我没有解释我的问题。我已经更新了我的问题来解释我在第三个代码区的意思。@PaulLemarchand，你为什么使用AtomicInteger？你能详细说明一下吗？只是好奇：）+1@paullemarch使用

AtomicInteger（AI）

作为容器是个好主意。也就是说，如果有人使用

parallelStream

而不是

stream

，这个实现将无法工作。因为在这种情况下，多个线程可以访问相同的

AI

（一个接一个地访问）。例如，第一个线程在

AI

中写入值x，并假设在创建值端时，

AI

将具有其写入的值。但是，当第二个线程将值y写入

AI

时，此实现将失败。但再次强调，OP似乎并不需要并行流。所以a+1。只是为了添加一个不同的视角，流是用来支持函数式编程的。对一些常见变量进行变异，这与功能范式哲学背道而驰。但现实世界中的用例有时确实需要违背哲学。酋长大师，保罗，你让我对兰姆达了解了很多，我必须花很多时间来消化知识，非常感谢。我认为大师的方式很奇妙，保罗的方式更适合这种情况。对不起，我没有解释我的问题。我已经更新了我的问题来解释我在第三个代码区的意思。@PaulLemarchand，你为什么使用AtomicInteger？你能详细说明一下吗？只是好奇：）+1@paullemarch使用

AtomicInteger（AI）

作为容器是个好主意。也就是说，如果有人使用

parallelStream

而不是

stream

，这个实现将无法工作。因为在这种情况下，多个线程可以访问相同的

AI

（一个接一个地访问）。例如，第一个线程在

AI

中写入值x，并假设在创建值端时，

AI

将具有其写入的值。但是，当第二个线程将值y写入

AI

时，此实现将失败。但是后来