Combine 2 Lists and set value once there is a match

Question

I have 2 list for Organizations, one that followed by users and another is the all Organizations in the database, I made 2 loops inside each others to set the value of followed for original list with true if user following this organization (that can be known from user organizations list)

List<Organization> organizationList = getServiceInstance().getOrganizationService().findOrganizationList();
List<Organization> organizations = getServiceInstance().getOrganizationService().findFollowedOrganizationList(userId);
for (Organization fOrg: organizations) {
    for (Organization organization : organizationList) {
        if (Objects.equals(fOrg.id, organization.id)) {
            fOrg.followed = true;
        }
    }
}

I believe there is better way to do this.

Couldn't you use `organizations.contains(organizationList);` ? — Wavemaster, Mar 08 '16 at 11:48
@Wavemaster that would be true provided his scope - if he is just comparing by Id which in turn, hits some kind of relational database with PK, then that's all he needs to check — ha9u63a7, Mar 08 '16 at 11:55
You will find the answer in http://stackoverflow.com/questions/5943330/common-elements-in-two-lists — Imesha Sudasingha, Mar 08 '16 at 12:01

Thomas · Accepted Answer · 2016-03-09T08:47:22.163

Try to use a map id->organization. That way you'd have 2 non-nested loops, one for building the map and one to loop over organizations and match the objects.

Example:

//build the map
Map<Integer, Organization> orgsInDB = new HashMap<>();
for( Organization org : organizationList ) {
  orgsInDB.put(org.getId(), org );
}

//match
for( Organization org : organizations ) {
  Organization orgInDB = orgsInDB.get( org.getId() );
  if( orgInDB != null ) {
    orgInDB.setFollowed( true );
  }
}

The complexity for this drops from O(n*m) to O(n + m).

Edit: As Al-Mothafar correctly pointed out we should consider the worst case which would be following all organizations. Thus complexity of his approach would be O(n²) while the approach above would be O(n+n) (or, since constant factors are generally left out in big-oh notation, just O(n)).

Sounds good, but nore about complexity, actually its O(n*n) to O(n+n) (so ots from n^2 to n , since user might follow all organizations. — Al-Mothafar, Mar 09 '16 at 08:41

score 1 · Answer 2 · answered Mar 08 '16 at 12:32

1

I have used CollectionUtils from Apache commons library. It has static intersection, union and subtract methods which are suitable for your case as well. Pretty neat as well.

Nicely explained here with relation to set theory :)

answered Mar 08 '16 at 12:32

Sheetal Mohan Sharma

2,908
1
23
24

score 0 · Answer 3 · answered Mar 08 '16 at 11:52

0

I don't think, that there is a better way to do this, at least not in terms of performance: You've got to iterate over the organizations somewhere. Readability could be improved by packaging some lines into a private method.

The only suggestion I have is that you might replace Organization.followed (boolean) with Organization.followers (List). If so, you could simply check, whether the list is empty, or not. OTOH, this might slow down database accesses.

answered Mar 08 '16 at 11:52

user1774051

843
1
6
18

2

Of course there is a better way in terms of performance :) - The code above has O(n*m) complexity which is unnecessary. – Thomas Mar 08 '16 at 11:54

Combine 2 Lists and set value once there is a match

3 Answers3