PR Problem

import java.util.*;
import java.util.stream.Collectors;
import com.oracle.net.*;
import com.oracle.jrockit.jfr.FlightRecorder;
import java.util.Set;


class Solution {

  /*
   * Also-In Groups
   * Given a many to many relation between members <-> groups, 
   * A starting group ID, and a max number of groups to return
   * return a List of group IDs that have the highest amount of shared members
   * with the starting group, ordered by amount of shared members in descending order
   */
  public static List<Integer> getAlsoIn( Integer startId, Integer limit, DbQueries db ) {
      // Get all members to look at
      List<Integer> memOfStrtGrpIntList = db.getMembersForGroup( startId );

      // Get a list of all the groups the members are in
      List<Integer> a = new ArrayList<>();
      for ( Integer memberId : memOfStrtGrpIntList ) {
          List<Integer> memberGroups = db.getGroupsForMember( memberId );
          for ( Integer x : memberGroups ) {
              a.add(x); 
          }
      }

      // Get a list of every group in the database to make sure
      List<Integer> everyGroup = db.getAllGroups();
        List<Integer> b = new ArrayList<>();
      for ( Integer i : a ) {
          if ( everyGroup.contains( i ) ) {
                  b.add( i );   
          }
      }

      // Count the list of groups
      Map<Integer,Integer> groupCounts = new TreeMap<>();
      for ( Integer i : b ) {
          if ( groupCounts.containsKey( i ) ) {
              groupCounts.put( i, groupCounts.get(i ) +   1 );
          } else {
              groupCounts.put( i, 1 );   
          }
      }

      // Get the keys from the map as a sortable list
      Set<Integer> grpCtKeyIntSet = groupCounts.keySet();
      Integer[] grpctkeyintarray = grpCtKeyIntSet.toArray(new Integer[7]);
       List<Integer> candidates = Arrays.asList( grpctkeyintarray );
      

      // return stuff
      return candidates.stream()
      .sorted( (k1, k2) -> groupCounts.get(k1) - groupCounts.get(k2) )
      .limit( limit )
      .collect( Collectors.toList() );
  }

  public interface DbQueries {
      public List<Integer> getMembersForGroup( Integer groupId );
      public List<Integer> getGroupsForMember( Integer memberId );
      public List<Integer> getAllGroups();
      public List<Integer> getAllMembers();
  }
  
  // TESTS
  public static void main(String[] args) {
    System.out.println("STUFF");
    DbQueries queries = new DbQueriesMock();
    List<Integer> res = getAlsoIn(7, 3, queries);
    System.out.println(res); // should print as expected
  }
  
   public static class DbQueriesMock implements DbQueries {
      public Map<Integer, List<Integer>> memberToGroups = new HashMap<>();
      public Map<Integer, List<Integer>> groupToMembers = new HashMap<>();
      public List<Integer> groups = new ArrayList<>();
      public List<Integer> members = new ArrayList<>();
    
      public DbQueriesMock() {
        this.memberToGroups.put(1, Arrays.asList(1,2,3,4,7));
        this.memberToGroups.put(2, Arrays.asList(2,3,4,5));
        this.memberToGroups.put(3, Arrays.asList(4));
        this.memberToGroups.put(4, Arrays.asList(4,5,6,7));
        this.memberToGroups.put(5, Arrays.asList(4,7));
        
        this.groupToMembers.put(1, Arrays.asList(1));
        this.groupToMembers.put(2, Arrays.asList(1,2));
        this.groupToMembers.put(3, Arrays.asList(1,2));
        this.groupToMembers.put(4, Arrays.asList(1,2,3,4,5));
        this.groupToMembers.put(5, Arrays.asList(2,4));
        this.groupToMembers.put(6, Arrays.asList(4));
        this.groupToMembers.put(7, Arrays.asList(1,4,5));

        this.groups.addAll(Arrays.asList( 1,2,3,4,5,6,7));
      }
    
      public List<Integer> getMembersForGroup( Integer groupId ) {
          return groupToMembers.get( groupId ); 
      }
      public List<Integer> getGroupsForMember( Integer memberId ) {
          return memberToGroups.get( memberId );
      }
      public List<Integer> getAllGroups() {
          return groups; 
      }
      public List<Integer> getAllMembers() {
          return members; 
      }
  }

}