Java spect表示，在大多数情况下，运行两个流会更高效……我非常喜欢使用limit（）。好主意！！不幸的是，解决方案仍然存在一个问题，即模型的临时映射可能会消耗大量内存。我用过汽车，但想象一下现在是人，我有数百万人。在这种情况下，如果两个人在列表的末尾，临时映

---

spect表示，在大多数情况下，运行两个流会更高效……我非常喜欢使用limit（）。好主意！！不幸的是，解决方案仍然存在一个问题，即模型的临时映射可能会消耗大量内存。我用过汽车，但想象一下现在是人，我有数百万人。在这种情况下，如果两个人在列表的末尾，临时映射可以在内存中保存数百万个字符串以查找两个人：（@ByeBye No，在

distinct（）

之后，可能存在一个无限流，其中只包含通过过滤器的不同项。限制为

限制（2）

，当流发出第二个项目时，流的处理停止。这使短路快速成功。是的，我想这可能是答案。小而微妙的细节。@123 xyz只是想装模作样/偷懒。

.filter（model->model.equals（“Focus”）| model.equals（“Civic”））

会起作用，而且可能更快。但是由于要搜索的项目数量更多（比如10个特定型号），临时设置和

包含的

应该更快。不会有其他短路解决方案；如果需要，则必须坚持当前的方法。不过：而不是

。过滤器（…）.findFirst（）.isPresent（）

，您应该只写

.anyMatch（…）

@LouisWasserman关于anyMatch（）的好观点。我走了更长的路，因为我正在尝试各种额外的技巧。对于这样一项简单的任务，你可能不应该使用

流

，尤其是对于1000万辆汽车。为什么不维护一个你已经拥有的

汽车类型集

，然后在需要检查是否存在类型时调用

集#contains

？你可以躲闪通过手动迭代所有汽车进行大量迭代，因为您不需要对迭代所有元素的

Stream#filter

进行完全过滤：如果

reportElements

有1000万条条目，而

Honda

和

Civic

占据了前两个索引，那么您就浪费了大量时间来过滤这些条目e rest.我用过汽车，但很可能是人。我只是觉得从性能上看汽车更容易。无论哪种方式，你仍然需要循环浏览数百万辆汽车的整个列表，才能在第一时间创建场景，所以你仍然在运行O（n）如果您创建了一个预设。而且，如果列表依赖于某个查询，则可能无法维护汽车的缓存集。这是一个更好的例子；）@VinceEmigh True，但我选择的答案实际上会缩短搜索时间，因此在找到我想要的前两个项目时，搜索就会停止。而且它对内存的要求也很低。因此，在不维护O（n）集的情况下，这是可能的；）这些操作是流api不想做的吗？它不修改任何数据，是一个兼容的lambda表达式。

boolean hasCivic = reportElements.stream()
        .filter(car -> "Civic".equals(car.getModel()))
        .findFirst()
        .isPresent();

boolean hasFocus = reportElements.stream()
        .filter(car -> "Focus".equals(car.getModel()))
        .findFirst()
        .isPresent();

return hasCivic && hasFocus;

reportElements.stream()
    .filter(car -> "Civic".equals(car.getModel()) || "Focus".equals(car.getModel()))
    .collect(Collectors.toMap(
            c -> c.getModel(),
            c -> c,
            (c1, c2) -> c1
    )).size() == 2;

reportElements.stream()
    .filter(car -> "Civic".equals(car.getModel()) || "Focus".equals(car.getModel()))
    .map(car -> car.getModel())
    .collect(Collectors.toSet())
    .size() == 2;

reportElements.stream()
    .filter(car -> "Civic".equals(car.getModel()) || "Focus".equals(car.getModel()))
    .map(car -> car.getModel())
    .distinct()
    .count() == 2L;

Set<String> models = reportElements.stream()
       .map(Car::getModel)
       .filter(model -> model.equals("Focus") || model.equals("Civic"))
       .collect(Collectors.toSet());
return models.contains("Focus") && models.contains("Civic");

return reportElements.stream()
           .map(Car::getModel)
           .filter(model -> model.equals("Focus") || model.equals("Civic"))
           .distinct()
           .limit(2)
           .count() == 2;

           .map(Car::getModel)

           .filter(model -> model.equals("Focus") || model.equals("Civic"))

           .distinct()

           .limit(2)

           .count() == 2;

boolean matched = IntStream.iterate(1, i -> i + 1)
    .mapToObj(i -> i % 3 == 0 ? "Civic" : i % 7 == 0 ? "Focus" : "Model "+i)
    .peek(System.out::println)
    .filter(model -> model.equals("Civic") || model.equals("Focus"))
    .peek(model -> System.out.println("  After filter:   " + model))
    .distinct()
    .peek(model -> System.out.println("  After distinct: " + model))
    .limit(2)
    .peek(model -> System.out.println("  After limit:    " + model))
    .count() == 2;
System.out.println("Matched = "+matched);

Model 1
Model 2
Civic
  After filter:   Civic
  After distinct: Civic
  After limit:    Civic
Model 4
Model 5
Civic
  After filter:   Civic
Focus
  After filter:   Focus
  After distinct: Focus
  After limit:    Focus
Matched = true

Set<String> models = Set.of("Focus", "Civic");

return reportElements.stream()
           .map( Car::getModel )
           .filter( models::contains )
           .distinct()
           .limit( models.size() )
           .count() == models.size();

boolean hasFocus = false, hasCivic = false;
for (Car c : reportElements) {
    if ("Focus".equals(c.getModel())) hasFocus = true;
    if ("Civic".equals(c.getModel())) hasCivic = true;
    if (hasFocus & hasCivic) return true;
}
return false;