流Java 8中的本地存储

我想写一个流方法，它可能需要基于“lastGoodVersion”忽略几个并发值，但我找不到在流中共享值的方法。下面是我想做的。关于如何完成这样的事情有什么建议吗

---

[编辑不要这样做，这与java流的工作方式无关]

显然，您将无法修改lambda body中的局部变量。您需要某种包装，其中包含要修改的内容。数组通常用于此目的

VERSION[] lastCanonicalVersion = {null}

....

                            if(...lastCanonicalVersion[0]...)
                                lastCanonicalVersion[0] = v;

---

显然，您将无法修改lambda body中的局部变量。您需要某种包装，其中包含要修改的内容。数组通常用于此目的

VERSION[] lastCanonicalVersion = {null}

....

                            if(...lastCanonicalVersion[0]...)
                                lastCanonicalVersion[0] = v;

---

显然，您将无法修改lambda body中的局部变量。您需要某种包装，其中包含要修改的内容。数组通常用于此目的

VERSION[] lastCanonicalVersion = {null}

....

                            if(...lastCanonicalVersion[0]...)
                                lastCanonicalVersion[0] = v;

---

显然，您将无法修改lambda body中的局部变量。您需要某种包装，其中包含要修改的内容。数组通常用于此目的

VERSION[] lastCanonicalVersion = {null}

....

                            if(...lastCanonicalVersion[0]...)
                                lastCanonicalVersion[0] = v;

---

我认为仅使用Java8流是不可能的。但是，对于您想要执行的操作，一个可能的解决方案可以使用一个助手函数，该函数可能类似于以下内容：

private static <T> Stream<T> progressiveFilter(Stream<T> stream,
                                               BiPredicate<T, T> predicate) {
    List<T> list = stream.collect(Collectors.toList());
    List<T> result = new ArrayList<>();
    T previousValue = null;
    for (T entry : list) {
        if (previousValue == null) {
            previousValue = entry;
        } else {
            if (predicate.test(entry, previousValue)) {
                result.add(previousValue);
            } else {
                previousValue = entry;
            }
        }
    }
    if(previousValue != null) {
        result.add(previousValue);
    }
    return result.stream();
}

progressiveFilter(
    allVersionsStream().filter(NSTimestamp::isApproved),
    (v, lastCanonicalVersion) -> !v.isEffectiveBefore(relativeDate)
                               && v.isEffectiveBefore(lastCanonicalVersion));

---

很可能这可以进一步优化。但我希望，原则是明确的。

我认为仅使用Java8流不可能做到这一点。但是，对于您想要执行的操作，一个可能的解决方案可以使用一个助手函数，该函数可能类似于以下内容：

private static <T> Stream<T> progressiveFilter(Stream<T> stream,
                                               BiPredicate<T, T> predicate) {
    List<T> list = stream.collect(Collectors.toList());
    List<T> result = new ArrayList<>();
    T previousValue = null;
    for (T entry : list) {
        if (previousValue == null) {
            previousValue = entry;
        } else {
            if (predicate.test(entry, previousValue)) {
                result.add(previousValue);
            } else {
                previousValue = entry;
            }
        }
    }
    if(previousValue != null) {
        result.add(previousValue);
    }
    return result.stream();
}

progressiveFilter(
    allVersionsStream().filter(NSTimestamp::isApproved),
    (v, lastCanonicalVersion) -> !v.isEffectiveBefore(relativeDate)
                               && v.isEffectiveBefore(lastCanonicalVersion));

---

很可能这可以进一步优化。但我希望，原则是明确的。

我认为仅使用Java8流不可能做到这一点。但是，对于您想要执行的操作，一个可能的解决方案可以使用一个助手函数，该函数可能类似于以下内容：

private static <T> Stream<T> progressiveFilter(Stream<T> stream,
                                               BiPredicate<T, T> predicate) {
    List<T> list = stream.collect(Collectors.toList());
    List<T> result = new ArrayList<>();
    T previousValue = null;
    for (T entry : list) {
        if (previousValue == null) {
            previousValue = entry;
        } else {
            if (predicate.test(entry, previousValue)) {
                result.add(previousValue);
            } else {
                previousValue = entry;
            }
        }
    }
    if(previousValue != null) {
        result.add(previousValue);
    }
    return result.stream();
}

progressiveFilter(
    allVersionsStream().filter(NSTimestamp::isApproved),
    (v, lastCanonicalVersion) -> !v.isEffectiveBefore(relativeDate)
                               && v.isEffectiveBefore(lastCanonicalVersion));

---

很可能这可以进一步优化。但我希望，原则是明确的。

我认为仅使用Java8流不可能做到这一点。但是，对于您想要执行的操作，一个可能的解决方案可以使用一个助手函数，该函数可能类似于以下内容：

private static <T> Stream<T> progressiveFilter(Stream<T> stream,
                                               BiPredicate<T, T> predicate) {
    List<T> list = stream.collect(Collectors.toList());
    List<T> result = new ArrayList<>();
    T previousValue = null;
    for (T entry : list) {
        if (previousValue == null) {
            previousValue = entry;
        } else {
            if (predicate.test(entry, previousValue)) {
                result.add(previousValue);
            } else {
                previousValue = entry;
            }
        }
    }
    if(previousValue != null) {
        result.add(previousValue);
    }
    return result.stream();
}

progressiveFilter(
    allVersionsStream().filter(NSTimestamp::isApproved),
    (v, lastCanonicalVersion) -> !v.isEffectiveBefore(relativeDate)
                               && v.isEffectiveBefore(lastCanonicalVersion));

---

很可能这可以进一步优化。但我希望原则是明确的。

你能更详细地描述一下你真正想要的结果吗？从代码中不清楚您只是在寻找“最佳”答案（处理后的最后一个规范版本），还是一组候选条目的最大排序子序列（很难想象您为什么想要这个，但这与您发布的代码最接近）对于涉及循环的任何事情，流并不总是最好的解决方案。。。这看起来像是一个问题，可以用一个简单的

for

循环而不是流以更清晰、更简单的方式解决。你能更详细地描述一下你真正想要的结果吗？从代码中不清楚您只是在寻找“最佳”答案（处理后的最后一个规范版本），还是一组候选条目的最大排序子序列（很难想象您为什么想要这个，但这与您发布的代码最接近）对于涉及循环的任何事情，流并不总是最好的解决方案。。。这看起来像是一个问题，可以用一个简单的

for

循环而不是流以更清晰、更简单的方式解决。你能更详细地描述一下你真正想要的结果吗？从代码中不清楚您只是在寻找“最佳”答案（处理后的最后一个规范版本），还是一组候选条目的最大排序子序列（很难想象您为什么想要这个，但这与您发布的代码最接近）对于涉及循环的任何事情，流并不总是最好的解决方案。。。这看起来像是一个问题，可以用一个简单的

for

循环而不是流以更清晰、更简单的方式解决。你能更详细地描述一下你真正想要的结果吗？从代码中不清楚您只是在寻找“最佳”答案（处理后的最后一个规范版本），还是一组候选条目的最大排序子序列（很难想象您为什么想要这个，但这与您发布的代码最接近）对于涉及循环的任何事情，流并不总是最好的解决方案。。。这看起来像是一个问题，可以通过一个简单的

for

循环而不是流以更清晰、更简单的方式解决。