Complex if/else logic in java with multiple variables

Question

There can be two types of groups- private and public. Each group can have members in it. I have three parameters id, includePrivate, includePublic to be passed into a method to return the groups as per the rules below. For eg.

public List<Group> getListofGroups(String id, Boolean isPrivate, Boolean   isPublic){}

All groups {}
all private groups {"includePrivate": true}
all public groups {"includePublic": true}
all private groups with membership {"id":"id1", "includePrivate": true }
all private groups with membership + all public groups {"id":"id1", "includePrivate": true, "includePublic": true }

What is the best way to implement this complex if/else logic? Is it a good option to create a rules engine just for this api?

 For eg. if(isPrivate && isPublic && id=!null) {
    return publicAndPrivateWIthMembership();
} else if(isPrivate && id=!null ) {
    return privateGroupsWithMembership();
} else if((isPublic && !isPrivate) ||(isPublic && isPrivate == null) ) {
    return allPublicGroups();
} else if((isPrivate && !isPublic) ||(isPrivate && isPublic == null) ) {
    return allPrivateGroups();
}........

It's pretty unclear what you are asking, but it doesn't look all that complex. Have you tried just writing it as a few if/else statements? — Andy Turner, Jan 06 '16 at 23:23
I have added some context to the problem now. Also each of those variables can be null as well which brings in the complexity. — Meghashyam Sandeep V, Jan 06 '16 at 23:36
@MeghashyamSandeepV please update the code in your question so it is more readable. — Atri, Jan 06 '16 at 23:37
`id=!null` is not valid java. I suspect you mean `id!=null`. — Andy Turner, Jan 06 '16 at 23:40
`(isPublic && !isPrivate) || (isPublic && isPrivate == null)` will yield a `NullPointerException` if `isPublic == true` and `isPrivate == null`, because of the evaluation of `!isPrivate`. — Andy Turner, Jan 06 '16 at 23:46

Andreas · Accepted Answer · 2016-01-06T23:44:45.810

1

Something like this, not really that complex, assuming null means false:

public List list(String id, Boolean includePrivate, Boolean includePublic) {
    boolean inclPrivate = (includePrivate != null && includePrivate);
    boolean inclPublic = (includePublic != null && includePublic);
    List result = new ArrayList();
    if (inclPublic || ! inclPrivate)
        result.addAll(getAllPublic());
    if (inclPrivate && id != null)
        result.addAll(getPrivateMembers(id));
    else if (inclPrivate || ! inclPublic)
        result.addAll(getAllPrivate());
    return result;
}

Of course, if you're actually querying a database, you could dynamically build the WHERE clause, but since you don't say....

edited Jan 06 '16 at 23:44

answered Jan 06 '16 at 23:40

Andreas

154,647
11
152
247

The boolean variables can also be null. How to account for it? – Meghashyam Sandeep V Jan 06 '16 at 23:41
@MeghashyamSandeepV you make the parameters `Boolean` instead of `boolean`, and check if their values are `null` or not in the conditions. – Andy Turner Jan 06 '16 at 23:44
@MeghashyamSandeepV Updated to support null `Boolean` parameters. – Andreas Jan 06 '16 at 23:45

Bohemian · Answer 2 · 2016-01-06T23:44:56.777

You could use the "null means don't care" paradigm. Something like:

private List<Group> groups;

public List<Group> getGroups(String id, Boolean includePrivate, Boolean includePublic) {
    return groups.stream()
        .filter(g -> id == null || g.getId().equals(id))
        .filter(g -> includePrivate == null || g.isPrivate() == includePrivate)
        .filter(g -> includePublic== null || g.isPublic() == includePublic)
        .collect(Collectors.toList());
}

The above does AND logic. If you want OR logic, do it in one filter:

public List<Group> getGroups(String id, Boolean includePrivate, Boolean includePublic) {
    return groups.stream()
        .filter(g -> (id == null || g.getId().equals(id))) || 
           (includePrivate == null || g.isPrivate() == includePrivate)) ||
           (includePublic== null || g.isPublic() == includePublic)))
        .collect(Collectors.toList());
}

or defer the predicate to the caller for a totally flexible API:

public List<Group> getGroups(Predicate<Group> predicate) {
     return groups.stream().filter(predicate).collect(Collectors.toList());
}

Complex if/else logic in java with multiple variables

2 Answers2