流：筛选子项，返回父项

Question

假设一个类MyClass：

public class MyClass {

    private final Integer myId;
    private final String myCSVListOfThings;

    public MyClass(Integer myId, String myCSVListOfThings) {
        this.myId = myId;
        this.myCSVListOfThings = myCSVListOfThings;
    }

    // Getters, Setters, etc
}

这条流：

final Stream<MyClass> streamOfObjects = Stream.of(
        new MyClass(1, "thing1;thing2;thing3"),
        new MyClass(2, "thing2;thing3;thing4"),
        new MyClass(3, "thingX;thingY;thingZ"));

我想返回myCSVListOfThings中包含条目"thing2"的MyClass的每个实例。

如果我想要一份清单

List<String> filteredThings = streamOfObjects
        .flatMap(o -> Arrays.stream(o.getMyCSVListOfThings().split(";")))
        .filter("thing2"::equals)
        .collect(Collectors.toList()); 

但我真正需要的是一个列表

这就是我现在拥有的：

List<MyClass> filteredClasses = streamOfObjects.filter(o -> {
     Stream<String> things = Arrays.stream(o.getMyCSVListOfThings().split(";"));
     return things.anyMatch(s -> s.equals("thing2"));
}).collect(Collectors.toList());

但不知怎的，这感觉不太对。除了在谓词中打开一个新的流之外，还有什么更清洁的解决方案吗？

Answer 1

在我看来，你有三个选择。

1） 在字符串中查找特定条目而不拆分它-仍然看起来很混乱

List<MyClass> filteredClasses = streamOfObjects
              .filter(o -> o.getMyCSVListOfThings().contains(";thing2;"))
              .collect(Collectors.toList());

2） 地图两次-仍然凌乱

List<MyClass> filteredClasses = streamOfObjects
              .map(o -> Pair<MyClass, List<String>>.of(o, toList(o.getMyCSVListOfThings()))
              .filter(pair -> pair.getRight().contains("thing2"))
              .map(pair -> pair.getLeft())
              .collect(Collectors.toList());

其中toList是一个将String转换为List的方法

3） 创建其他字段-我建议的方法

扩展类MyClass-向类添加字段

List<String> values;

并在构造函数中初始化它：

public MyClass(Integer myId, String myCSVListOfThings) {
    this.myId = myId;
    this.myCSVListOfThings = myCSVListOfThings;
    this.values = toList(myCSVListOfThings);
}

然后在溪流中简单地：

List<MyClass> filteredClasses = streamOfObjects
          .filter(o -> o.getValues().contains("thing2"))
          .collect(Collectors.toList());

当然，如果需要，可以在第一次getValues方法调用期间以延迟模式初始化字段值。

Answer 2

一种解决方案是使用避免拆分和流操作的模式匹配：

Pattern p=Pattern.compile("(^|;)thing2($|;)");
List<MyClass> filteredClasses = streamOfObjects
    .filter(o -> p.matcher(o.getMyCSVListOfThings()).find())
    .collect(Collectors.toList());

由于参数为字符串。split定义为正则表达式模式，上面的模式与在split的结果中查找匹配项具有相同的语义；您正在两个边界之间查找单词thing2，第一个是行的开头或分号，第二个是行的结尾或分号。

除此之外，在谓词中使用另一个流操作也没有错。但是有一些方法可以改进它。如果省略保存流的过时局部变量，lambda表达式会变得更简洁。通常，您应该避免将流实例保存在局部变量中，因为直接链接操作将减少尝试多次使用流的风险。其次，您可以使用Pattern类对分割操作的结果元素进行流式处理，而无需首先将它们全部收集到一个数组中：

Pattern p=Pattern.compile(";");
List<MyClass> filteredClasses = streamOfObjects
    .filter(o -> p.splitAsStream(o.getMyCSVListOfThings()).anyMatch("thing2"::equals))
    .collect(Collectors.toList());

或

Pattern p=Pattern.compile(";");
List<MyClass> filteredClasses = streamOfObjects
    .filter(o -> p.splitAsStream(o.getMyCSVListOfThings()).anyMatch(s->s.equals("thing2")))
    .collect(Collectors.toList());

请注意，您还可以将原始代码重写为

List<MyClass> filteredClasses = listOfObjects.stream()
    .filter(o -> Arrays.asList(o.getMyCSVListOfThings().split(";")).contains("thing2"))
    .collect(Collectors.toList());

现在，谓词中的操作不是Stream而是Collection操作，但这不会改变语义或代码的正确性......

Answer 3

首先，我建议您向MyClass添加额外的方法，以便您可以像这样转换代码：

List<MyClass> filteredClasses = streamOfObjects
  .filter(o -> o.containsThing("thing2"))
  .collect(Collectors.toList());

现在您可以根据输入数据实现此方法：拆分为Stream，拆分为Set，甚至搜索substring（如果可能并且有意义），如果需要，缓存结果。

你们对这个类的用法了解得更多，所以你们可以做出正确的选择。