Java 流问题：从列表中获取属性的最佳方法

我已经创建了一个列表，比如说，100个配置。我已将该列表划分为10组，因此现在我有了

list

。所有这些配置都有一个公共属性值，

domainCode

。对我来说，获得该属性的最佳方式是什么？假设配置域类如下所示：

public class Config {

    private String configId;
    private String portfolioId;
    private String domainCode;

    public Config(String configId, String portfolioId, String domainCode) {
        this.configId = configId;
        this.portfolioId = portfolioId;
        this.domainCode = domainCode;
    }

    public String getConfigId() { return configId;}
    public String getPortfolioSymbolCode() { return portfolioId;}
    public String getDomainCode() { return domainCode; }
}

我构建了100个，然后将它们分组：

List<Config> configs = getAllConfigs();
List<List<Config>> partitionedConfigs = new ArrayList<>();
if (configs != null) {
    AtomicInteger counter = new AtomicInteger();
    partitionedConfigs.addAll(configs.stream()
            .collect(Collectors.groupingBy(it -> counter.getAndIncrement() / 10))
            .values());
}

List configs=getAllConfigs（）；
List partitionedConfigs=new ArrayList（）；
如果（配置！=null）{
AtomicInteger计数器=新的AtomicInteger（）；
partitionedConfigs.addAll（configs.stream（）
.collect（Collectors.groupingBy（it->counter.getAndIncrement（）/10））
.values（））；
}

---

我将

partitionedConfigs

传递给一个方法。该方法需要

domainCode

。从

partitionedConfigs

中获取单个

domainCode

的有效方法是什么？即使有100个

Config

对象，域代码也是唯一的，也只有一个域代码。这就是我的方法需要查找的内容。

您可以从

configs

自己列出它

List<String> domains = configs.stream()
                              .map(Config::getDomainCode)
                              .collect(Collectors.toList());

若列表中的每个对象都有相同的域名，那个么您可以使用

findFirst

String domain = configs.stream()
                       .findFirst()
                       .map(Config::getDomainCode)
                       .orElse(null); // if list is empty give some default value

从

partitionedConfigs

列表

String domain = partitionedConfigs.stream()
                                  .flatMap(List::stream)
                                  .findFirst()
                                  .map(Config::getDomainCode)
                                  .orElse(null); // if list is empty give some 

---

如果您知道域代码在

Config

对象中是唯一的，您仍然应该检查这个假设

    List<List<Config>> partitionedConfigs = // get from somewhere;

    Set<String> uniqueDomainCode = partitionedConfigs.stream()
            .flatMap(List::stream)
            .map(Config::getDomainCode)
            .collect(Collectors.toSet());
    if (uniqueDomainCode.size() == 1) { // as expected
        String domainCode = uniqueDomainCode.iterator().next();
        // Do something with domain code
    } else {
        throw new IllegalStateException("Found " + uniqueDomainCode.size() + " domain codes, require 1");
    }

---

谢谢但是如果我知道这个领域是独一无二的呢？我只想从流中获取一个值，而不是一个列表。嗯，我只需要执行

findFirst（）

。谢谢你帮我想清楚了！注意还有

findAny

有时可能更快。您希望

partitionedConfigs

有1个或10个

domainCode

s吗？如果在所有100个条目中都是相同的域代码，为什么不

configs.get（0）.getDomainCode（）

？如果有100个

Config

对象，您想要其中哪一个的域代码？即使有100个，也只有一个域代码。谢谢！我确实喜欢溪流。：-）

    List<List<Config>> partitionedConfigs = // get from somewhere;

    Set<String> uniqueDomainCode = partitionedConfigs.stream()
            .flatMap(List::stream)
            .map(Config::getDomainCode)
            .collect(Collectors.toSet());
    if (uniqueDomainCode.size() == 1) { // as expected
        String domainCode = uniqueDomainCode.iterator().next();
        // Do something with domain code
    } else {
        throw new IllegalStateException("Found " + uniqueDomainCode.size() + " domain codes, require 1");
    }

    String firstDomainCode = partitionedConfigs.stream()
            .flatMap(List::stream)
            .map(Config::getDomainCode)
            .findAny()
            .orElseThrow( () -> new IllegalStateException("Empty list, so no domain code found"));
    boolean domainCodeIsUnique = partitionedConfigs.stream()
            .flatMap(List::stream)
            .map(Config::getDomainCode)
            .allMatch(firstDomainCode::equals);
    if (domainCodeIsUnique) {
        // Do something with firstDomainCode
    } else {
        throw new IllegalStateException("Domain code is not unique, it is required to be");
    }