如何在集合和ArrayList上使用lambda表达式

我有一个比较两个类的私有void代码。在这段典型代码中，我希望能够在最初不使用lambda的地方使用/应用lambda表达式。已经尝试了多种方法，如映射、流或过滤器，但似乎没有得到代码的确切格式， 下面是我想要应用lambda表达式的代码。只需要这个代码

private void checkPrivileges（用户）{
集合角色=user.getAllRoles（）；
List requiredPrivs=new ArrayList（）；
for（角色r：角色）{
if（r.getRole（）.equals）（RoleConstants.SUPERUSER）
&&！Context.hasPrivilege（privilegeContents.ASSIGN\u SYSTEM\u DEVELOPER\u ROLE））{
抛出新APIException（“User.you.must.have.role”，新对象[]{RoleConstants.SUPERUSER}）；
}
如果（r.getPrivileges（）！=null）{
对于（权限p:r.getPrivileges（））{
如果（！Context.hasPrivilege（p.getPrivilege（）））{
requiredprives.add（p.getPrivilege（））；
}
}
}
}
if（requiredPrivs.size（）==1）{
抛出新APIException（“User.you.must.have.privilege”，新对象[]{requiredPrivs.get（0）}）；
}else if（requiredPrivs.size（）>1）{
StringBuilder txt=new StringBuilder（“您必须具有以下权限才能分配它们：”）；
for（字符串s:requiredPrivs）{
附加（“，”）；
}
抛出新的APIException（text.substring（0，text.length（）-2））；
}
}

它有相应的Roles.java和Privilege.java类。 我的问题是只在void类上使用lambda表达式。这是我做的试验，但它是我任务的一半

role.getPrivileges（）.stream（）
.filter（（）->{
返回可选的.of（特权）
.filter（给定->给定.p.get权限（））
.getOrElse（“所需特权：+p）}）；

我会将if的层次结构展平，并提取一个常量+一个checkmethod，如：

private static final String ERROR_FORMAT = "You must have the following privileges in order to assign them: %s";

private void checkPrivileges(User user) {
    List<String> requiredPrivs = new ArrayList<>();
    for (Role r : user.getAllRoles()) {
        checkSuperUserPrivilege(r);
        Iterable<Privilege> privileges = r.getPrivileges() != null ? r.getPrivileges() : Collections.emptySet();
        for (Privilege p : privileges) {
            if (!Context.hasPrivilege(p.getPrivilege())) {
                requiredPrivs.add(p.getPrivilege());
            }
        }
    }
    if (requiredPrivs.size() == 1) {
        throw new APIException("User.you.must.have.privilege", new Object[] { requiredPrivs.get(0) });
    } else if (requiredPrivs.size() > 1) {
        throw new APIException(String.format(ERROR_FORMAT, String.join(", ", requiredPrivs)));
    }
}

private void checkSuperUserPrivilege(Role r) {
    if(r.getRole().equals(RoleConstants.SUPERUSER)
            && !Context.hasPrivilege(PrivilegeConstants.ASSIGN_SYSTEM_DEVELOPER_ROLE)) {
        throw new APIException("User.you.must.have.role", new Object[] { RoleConstants.SUPERUSER });
    }
}

private static final String ERROR\u FORMAT=“您必须具有以下权限才能分配它们：%s”；
私有无效检查权限（用户）{
List requiredPrivs=new ArrayList（）；
对于（角色r:user.getAllRoles（））{
checkSuperUserPrivilege（r）；
Iterable privileges=r.getPrivileges（）！=null？r.getPrivileges（）：Collections.emptySet（）；
for（特权p：特权）{
如果（！Context.hasPrivilege（p.getPrivilege（）））{
requiredprives.add（p.getPrivilege（））；
}
}
}
if（requiredPrivs.size（）==1）{
抛出新APIException（“User.you.must.have.privilege”，新对象[]{requiredPrivs.get（0）}）；
}else if（requiredPrivs.size（）>1）{
抛出新的APIException（String.format（ERROR_format，String.join（“，”，requiredPrivs））；
}
}
私有void checkSuperUserPrivilege（角色r）{
if（r.getRole（）.equals）（RoleConstants.SUPERUSER）
&&！Context.hasPrivilege（privilegeContents.ASSIGN\u SYSTEM\u DEVELOPER\u ROLE））{
抛出新APIException（“User.you.must.have.role”，新对象[]{RoleConstants.SUPERUSER}）；
}
}

正如我在评论中所说的，用流处理这个问题是一个坏主意，但你可以这样做：

private static final String ERROR_FORMAT = "You must have the following privileges in order to assign them: %s";

private void checkPrivileges(User user) {
    List<String> requiredPrivs = user.getAllRoles().stream()
            .peek(this::checkSuperUserPrivilege)
            .map(Role::getPrivileges)
            .filter(Objects::nonNull)
            .flatMap(Collection::stream)
            .map(Privilege::getPrivilege)
            .filter(p -> !Context.hasPrivilege(p))
            .collect(Collectors.toList());
    if (requiredPrivs.size() == 1) {
        throw new APIException("User.you.must.have.privilege", new Object[] { requiredPrivs.get(0) });
    } else if (requiredPrivs.size() > 1) {
        throw new APIException(String.format(ERROR_FORMAT, String.join(", ", requiredPrivs)));
    }
}

private void checkSuperUserPrivilege(Role r) {
    if(r.getRole().equals(RoleConstants.SUPERUSER)
            && !Context.hasPrivilege(PrivilegeConstants.ASSIGN_SYSTEM_DEVELOPER_ROLE)) {
        throw new APIException("User.you.must.have.role", new Object[] { RoleConstants.SUPERUSER });
    }
}

private static final String ERROR\u FORMAT=“您必须具有以下权限才能分配它们：%s”；
私有无效检查权限（用户）{
List requiredPrivs=user.getAllRoles（）.stream（）
.peek（此：：checkSuperUserPrivilege）
.map（角色：：getPrivileges）
.filter（对象：：非空）
.flatMap（集合：：流）
.map（特权：：getPrivilege）
.filter（p->！Context.hasPrivilege（p））
.collect（Collectors.toList（））；
if（requiredPrivs.size（）==1）{
抛出新APIException（“User.you.must.have.privilege”，新对象[]{requiredPrivs.get（0）}）；
}else if（requiredPrivs.size（）>1）{
抛出新的APIException（String.format（ERROR_format，String.join（“，”，requiredPrivs））；
}
}
私有void checkSuperUserPrivilege（角色r）{
if（r.getRole（）.equals）（RoleConstants.SUPERUSER）
&&！Context.hasPrivilege（privilegeContents.ASSIGN\u SYSTEM\u DEVELOPER\u ROLE））{
抛出新APIException（“User.you.must.have.role”，新对象[]{RoleConstants.SUPERUSER}）；
}
}

不要使用lambda，而是尝试改进你的迭代代码。既然你在循环中抛出了一个异常，你就不能使用

Streams

及其阶段而不进行任何肮脏的攻击。@Ravindra Ranwala知道我该怎么做吗谢谢你的好主意，为什么你会说这是一个bda的主意来在Streams中赞美它，谢天谢地，我认为声明式的方式比简单的迭代式更臃肿。事实上，它对我来说很有效，尽管你称之为一个坏主意。谢天谢地，这不是关于工作，而是关于可读性，而这在迭代式中要好得多。