Java 8 减少到 2 个字符串

Question

我可以用流来做到这一点吗？

StringBuilder text = new StringBuilder();
StringBuilder dupText = new StringBuilder();
String lastLetter = "";

for (Container cont : containersList) {
    String letter = cont.getLetter();
    text.append(letter);
    if (letter.equals(lastLetter) == false) {
        dupText.append(letter);
    }
    lastLetter = letter;
}

System.out.println(text);
System.out.println(dupText);

我查看了大陆列表，每个大陆都有一个字符。我需要组装两个字符串 - 一个是所有字符组合，另一个是所有字符但没有耦合重复项 (ABABAAAB -> ABABAB)

这可以用流来完成吗？

我试过这样做:

Optional<String> text = containersList.stream()
            .map(Container::getLetter)
            .reduce((letter,accumalator) -> accumalator += letter);

Optional<String> dupText = session.containersList().stream()
            .map(Container::getLetter)
            .reduce((letter, accumalator) ->{
                if ((accumalator.endsWith(letter) == false)) {
                    accumalator += letter;
                }
                return accumalator;
            });

Answer 1

使用StreamEx图书馆

您可以使用 StreamEx 在单个 Stream 管道中执行此操作图书馆。

List<Container> containersList = Arrays.asList(new Container("A"), new Container("B"), new Container("A"), new Container("A"), new Container("B"));
    
String[] result =
        StreamEx.of(containersList)
                .map(Container::getLetter)
                .groupRuns(Object::equals)
                .collect(MoreCollectors.pairing(
                    MoreCollectors.flatMapping(List::stream, Collectors.joining()),
                    MoreCollectors.mapping(l -> l.get(0), Collectors.joining()),
                    (s1, s2) -> new String[] { s1, s2 }
                ));
    
System.out.println(result[0]);
System.out.println(result[1]);

此代码创建一个容器流并将每个容器映射到它们的字母。

然后，groupRuns 方法将与给定谓词匹配的连续元素折叠成 List。在这种情况下，谓词是字符串的相等性:因此，如果您从流 [A, A, B] 开始，此方法会将其折叠到流 [List(A , A), List(B)](第一个元素是输入中 2 个 A 连续元素的列表)。

最后，这是用配对收集器收集的，它允许收集到两个不同的收集器中。第一个加入每个列表的平面 map 结果，而第二个仅加入列表的第一个元素(因此删除连续元素)。

结果存储在一个数组中，该数组仅用作两个值的容器。

输出:

ABAAB
ABAB

---

直接使用 Stream API

如果您想继续使用当前的 API 而不是使用库，最好的办法是编写自定义 Collector:

public static void main(String[] args) {
    List<Container> containersList = Arrays.asList(new Container("A"), new Container("B"), new Container("A"), new Container("A"), new Container("B"));
    
    String[] result = containersList.stream().parallel().map(Container::getLetter).collect(ContainerCollector.collector());
    
    System.out.println(result[0]);
    System.out.println(result[1]);
}

private static final class ContainerCollector {
    
    private StringBuilder text = new StringBuilder();
    private StringBuilder dupText = new StringBuilder();
    
    private void accept(String letter) {
        text.append(letter);
        if (dupText.indexOf(letter, dupText.length() - letter.length()) < 0) {
            dupText.append(letter);
        }
    }
    
    private ContainerCollector combine(ContainerCollector other) {
        text.append(other.text);
        other.dupText.codePoints().forEach(i -> {
            String letter = new String(Character.toChars(i));
            if (dupText.indexOf(letter, dupText.length() - letter.length()) < 0) {
                dupText.append(letter);
            }
        });
        return this;
    }
    
    private String[] finish() {
        return new String[] { text.toString(), dupText.toString() };
    }
    
    private static Collector<String, ?, String[]> collector() {
        return Collector.of(ContainerCollector::new, ContainerCollector::accept, ContainerCollector::combine, ContainerCollector::finish);
    }
    
}

这个自定义收集器在接受每个字母时构建 text 和 dupText。对于 text 字符串，始终附加字母。对于 dupText，仅当最后一个字母不同时才附加字母。

组合器代码(在并行执行的情况下运行)对于 dupText 有点棘手:如果第二个代码不是从第一个代码的末尾开始，则附加第二个代码。否则，第一个字母被丢弃，其余的被附加。

输出是一样的。