Java 如何按对流的键进行分组

假设我有以下流：

...
import javafx.util.Pair;
...
Pair[] testPairs = {
        new Pair<>("apple", "James"),
        new Pair<>("banana", "John"),
        new Pair<>("grapes", "Tom"),
        new Pair<>("apple", "Jenkins"),
        new Pair<>("banana", "Edward"),
        new Pair<>("grapes", "Pierre")
};

Map<String, List<String>> result1 = Arrays.stream(testPairs)...;

Map<String, String> result2 = Arrays.stream(testPairs)...;

。。。
导入javafx.util.Pair；
...
对[]测试对={
新的一对（“苹果”、“詹姆斯”），
新的一双（“香蕉”、“约翰”），
新的一对（“葡萄”、“汤姆”），
新的一对（“苹果”、“詹金斯”），
新的一对（“香蕉”、“爱德华”），
新的一对（“葡萄”，“皮埃尔”）
};
Map result1=Arrays.stream（testPairs）。。。；
Map result2=Arrays.stream（testPairs）。。。；

对于result1，我想按对的键进行分组，并获得所有对应的名称。 对于result2，我希望按键分组，并获取字符串列表中的任何一个（前一个结果的）

如何通过使用java 8流api实现这一点？

您可以这样做

Map<String, List<String>> result1 = Arrays.stream(testPairs)
    .collect(Collectors.groupingBy(Pair::getS, 
        Collectors.mapping(Pair::getT, Collectors.toList())));

Map<String, String> result2 = Arrays.stream(testPairs)
    .collect(Collectors.toMap(Pair::getS, Pair::getT, (v1, v2) -> v1));

Map result1=Arrays.stream（测试对）
.collect（收集器）.groupingBy（对：：获取，
Collectors.mapping（Pair:：getT，Collectors.toList（））；
Map result2=Arrays.stream（测试对）
.collect（Collectors.toMap（Pair:：get，Pair:：getT，（v1，v2）->v1））；

如果您将行类型与数组一起使用，下面是YCF_L在下面的注释中指定的具有必要强制转换的版本

Map<String, List<String>> result1 = Arrays.stream(testPairs)
        .collect(Collectors.groupingBy(p -> (String) p.getKey(),
                Collectors.mapping(p -> (String) p.getValue(), Collectors.toList())));

Map<String, String> result2 = Arrays.stream(testPairs)
                .collect(Collectors.toMap(
                        p -> (String) p.getKey(), 
                        p -> (String) p.getValue(), 
                        (a, b) -> b)
                );
    }

Map result1=Arrays.stream（测试对）
.collect（收集器.groupingBy（p->（字符串）p.getKey（），
Collectors.mapping（p->（String）p.getValue（），Collectors.toList（））；
Map result2=Arrays.stream（测试对）
.collect（collector.toMap）(
p->（字符串）p.getKey（），
p->（字符串）p.getValue（），
（a，b）->b）
);
}

你可以这样做

Map<String, List<String>> result1 = Arrays.stream(testPairs)
    .collect(Collectors.groupingBy(Pair::getS, 
        Collectors.mapping(Pair::getT, Collectors.toList())));

Map<String, String> result2 = Arrays.stream(testPairs)
    .collect(Collectors.toMap(Pair::getS, Pair::getT, (v1, v2) -> v1));

Map result1=Arrays.stream（测试对）
.collect（收集器）.groupingBy（对：：获取，
Collectors.mapping（Pair:：getT，Collectors.toList（））；
Map result2=Arrays.stream（测试对）
.collect（Collectors.toMap（Pair:：get，Pair:：getT，（v1，v2）->v1））；

如果您将行类型与数组一起使用，下面是YCF_L在下面的注释中指定的具有必要强制转换的版本

Map<String, List<String>> result1 = Arrays.stream(testPairs)
        .collect(Collectors.groupingBy(p -> (String) p.getKey(),
                Collectors.mapping(p -> (String) p.getValue(), Collectors.toList())));

Map<String, String> result2 = Arrays.stream(testPairs)
                .collect(Collectors.toMap(
                        p -> (String) p.getKey(), 
                        p -> (String) p.getValue(), 
                        (a, b) -> b)
                );
    }

Map result1=Arrays.stream（测试对）
.collect（收集器.groupingBy（p->（字符串）p.getKey（），
Collectors.mapping（p->（String）p.getValue（），Collectors.toList（））；
Map result2=Arrays.stream（测试对）
.collect（collector.toMap）(
p->（字符串）p.getKey（），
p->（字符串）p.getValue（），
（a，b）->b）
);
}

Pair的定义类似于so

Pair

因此键和值是一个对象，您的解决方案是正确的您只需强制转换键和值我遇到以下错误：无法解析方法“get”，我想您的意思是“Pair:：getKey”，但如果我这样做，我将得到另一个错误：无法从静态上下文引用非静态方法。

getS

和

getT

这里分别指

getKey

和

getValue

方法。因此，将它们替换为在

Pair

类中定义的对应项。Pair的定义类似于So

Pair

，因此键和值是一个对象，您的解决方案是正确的，您只需同时强制转换键和值。我发现以下错误：无法解析方法“get”，我认为您的意思是“Pair:：getKey”，但如果我这样做，我将得到另一个错误：非静态方法不能从静态上下文引用。

getS

和

getT

这里分别指

getKey

和

getValue

方法。因此，用

对中定义的对应项替换它们。