Return Object[] while connecting to DB once

Transform Bookable into an actual object.

I tried writing 3 different answers, and it just didn't work. You always end up with a long, long complicated mess.

If you transform Bookable into an actual object, you can add it to a list. You can then pass a list of TheatrePlanResourceData to some TypeData mapper.

This way you can split up your code into four parts:

Part 1:

   List<TheatreResourceData> assistants = new ArrayList<TheatreResourceData>();
   List<TheatreResourceData> surgeons = new ArrayList<TheatreResourceData>();
   Map<Long, Integer> bookableResourceKeyToCountMap = new LinkedHashMap<Long, Integer>();

   TheatrePlanResourceData planResourceData = new TheatrePlanResourceData();
   planResourceData.theatreActivityKey = activityEntry.getKey();
   List<TheatreResourceData> resourceData = (activityEntry.getValue() != null) ? activityEntry.getValue() : new ArrayList<TheatreResourceData>();


   if (resourceData.size() > 0){
     planResourceData.stateKey = ((TheatreResourceData) resourceData.get(0)).stateKey;
   }



   for (TheatreResourceData resData : resourceData){
     switch (resData.type){
      case TheatreResourceType.SURGEON1:
           planResourceData.staff.surgeon1 = resData;
           break;
      case TheatreResourceType.ASSISTANT:
           assistants.add(resData);
           break;
      case TheatreResourceType.OTHER_SURGEONS:
           surgeons.add(resData);
           break;
      case TheatreResourceType.BOOKABLE_RESOURCE:
           bookableResourceKeyToCountMap.put(Long.parseLong(resData.resourceID), resData.count);
           bookableResourceKeyToCountMapOutter.put(Long.parseLong(resData.resourceID), resData.count);
           break;
      }
    }

    reverseBookableResMap.put(activityEntry.getKey(), bookableResourceKeyToCountMap);

    planResourceData.staff.assistants = assistants.toArray(new TheatreResourceData[assistants.size()]);
    planResourceData.staff.otherSurgeons = surgeons.toArray(new TheatreResourceData[surgeons.size()]);


    result[count++] = planResourceData;

the inner loop of your first for loop, where you make a TheatrePlanResourceData out of a theatreActivity.

Part 2:

The part where you make all your objects.

 TheatrePlanResourceData[] result = new TheatrePlanResourceData[theatreActivities.size()];

 int count = 0;

 for (Map.Entry<Long, List<TheatreResourceData>> activityEntry : theatreActivities.entrySet())
 {
     result[count++] = part1(activityEntry);
 }

Part 3:

The part where you take all the objects you've made, and use .bookables to get a list of ids, so you can call InternalTheatreBookableResourceTypeToolkit .getInstance().getByKeys(CollectionUtils.toPrimitive(bookableResourceKeyList)); with the right values. ... Try using a Set<Long>.

Part 4:

The part where you take all the objects you've made, and use the retrieved database objects to clone TheatreBookableResourceTypeData and set the objects into the TheatrePlanResourceDatas.

It's up to you to do the actual cutting and pasting. Ask for a follow up review with a new question once you're done, maybe then we can take a look at writing some "parser class" that handles all the crap for you.

Result:

  private TheatrePlanResourceData[] buildTheatrePlanResourceData(Map<Long, List<TheatreResourceData>> theatreActivities)
  throws SpiderException{
    //method one
    TheatrePlanResourceData[] result = new TheatrePlanResourceData[theatreActivities.size()];

     int count = 0;

     for (Map.Entry<Long, List<TheatreResourceData>> activityEntry : theatreActivities.entrySet())
     {
         //method 3, for you to write
         result[count++] = part1(activityEntry);
     }

     //method 2
     Set<Long> keys = new HashSet<Long>();
     for(TheatrePlanResourceData data : result){
         List<Bookable> bookables = data.getBookables();
         for(Bookable b : bookables){
             keys.add(b.getResourceID());
         }
     }

     TheatreBookableResourceTypeData[] allBookableResourceTypeList = InternalTheatreBookableResourceTypeToolkit
.getInstance().getByKeys(CollectionUtils.toPrimitive(bookableResourceKeyList));

     //method 4
           for (TheatrePlanResourceData resourceDataObj : result){
    List<TheatreBookableResourceTypeData> relevantResourceList = new ArrayList<TheatreBookableResourceTypeData>();

    for (Bookable b : resourceDataObj.getBookables()){

      for (TheatreBookableResourceTypeData resTypeObj : allBookableResourceTypeList){

        if (b.getResourceID() == resTypeObj.key){
          try{
            TheatreBookableResourceTypeData clonedResourceType = (TheatreBookableResourceTypeData) resTypeObj.clone();
            clonedResourceType.count = b.getValue();
            relevantResourceList.add(clonedResourceType);
          }catch (CloneNotSupportedException e){
            TheatreModuleException.convert(e);
            continue;
          }

        }
      }

    }

    resourceDataObj.bookableRes = relevantResourceList.toArray(new TheatreBookableResourceTypeData[relevantResourceList.size()]);

  }
}

You probably can't reduce the amount of for loops, but what you can do it is migrate it to separate methods and make it understandable. Complexity isn't that bad when you know what's going on.