在Java流是peek真的只是调试?

我正在阅读有关Java流的资料，并在阅读过程中发现新的东西。我发现的一个新东西是peek()函数。几乎所有我读到的peek说它应该用来调试你的流。

如果我有一个流，其中每个帐户都有一个用户名，密码字段和login()和loggedIn()方法。

我还有

Consumer<Account> login = account -> account.login();

and

Predicate<Account> loggedIn = account -> account.loggedIn();

为什么会这么糟糕?

List<Account> accounts; //assume it's been setup
List<Account> loggedInAccount = 
accounts.stream()
    .peek(login)
    .filter(loggedIn)
    .collect(Collectors.toList());

现在，据我所知，这完全是它的目的。它;

获取一个帐户列表尝试登录每个帐户过滤掉任何未登录的帐户将已登录的帐户收集到一个新列表中

这样做的坏处是什么?有什么理由不让我继续吗?最后，如果不是这个解决方案，那么会是什么?

它的原始版本使用.filter()方法如下所示;

.filter(account -> {
        account.login();
        return account.loggedIn();
    })

当前回答

似乎需要一个helper类:

public static class OneBranchOnly<T> {
    public Function<T, T> apply(Predicate<? super T> test,
                                Consumer<? super T> t) {
        return o -> {
            if (test.test(o)) t.accept(o);
            return o;
        };
    }
}

然后切换偷看与地图:

.map(new OneBranchOnly< Account >().apply(                   
                    account -> account.isTestAccount(),
                    account -> account.setName("Test Account"))
)

结果:只重命名测试帐户的帐户集合(没有维护引用)

2022-08-14 18:24:45

其他回答

虽然我同意上面的大多数答案，但我有一个案例，使用peek似乎是最干净的方法。

与您的用例类似，假设您希望仅对活动帐户进行过滤，然后在这些帐户上执行登录。

accounts.stream()
    .filter(Account::isActive)
    .peek(login)
    .collect(Collectors.toList());

Peek有助于避免冗余调用，同时不必迭代集合两次:

accounts.stream()
    .filter(Account::isActive)
    .map(account -> {
        account.login();
        return account;
    })
    .collect(Collectors.toList());

2017-10-26 14:45:35

为了消除警告，我使用了函数子tee，以Unix的tee命名:

public static <T> Function<T,T> tee(Consumer<T> after) {
    return arg -> {
        f.accept(arg);
        return arg;
    };
}

你可以替换:

  .peek(f)

with

  .map(tee(f))

2022-10-23 14:16:42

功能性的解决方案是使帐户对象不可变。因此account.login()必须返回一个新的account对象。这意味着映射操作可以用于登录，而不是查看。

2019-02-28 20:11:36

似乎需要一个helper类:

public static class OneBranchOnly<T> {
    public Function<T, T> apply(Predicate<? super T> test,
                                Consumer<? super T> t) {
        return o -> {
            if (test.test(o)) t.accept(o);
            return o;
        };
    }
}

然后切换偷看与地图:

.map(new OneBranchOnly< Account >().apply(                   
                    account -> account.isTestAccount(),
                    account -> account.setName("Test Account"))
)

结果:只重命名测试帐户的帐户集合(没有维护引用)

2022-08-14 18:24:45

也许经验法则应该是，如果您确实在“调试”场景之外使用peek，那么只有在确定终止和中间过滤条件是什么时才应该这样做。例如:

return list.stream().map(foo->foo.getBar())
                    .peek(bar->bar.publish("HELLO"))
                    .collect(Collectors.toList());

似乎是一个有效的情况，在一个操作中，将所有的foo转换为bar，并告诉他们都是你好。

似乎比下面的东西更高效和优雅:

List<Bar> bars = list.stream().map(foo->foo.getBar()).collect(Collectors.toList());
bars.forEach(bar->bar.publish("HELLO"));
return bars;

而且你最终不会迭代一个集合两次。

2016-11-11 12:52:01

在Java流是peek真的只是调试?

推荐文章

最新文章

标签