What is an efficient method of collision detection for handling lots of objects?

What you want to do is register collision callbacks for each kind of body.

// You have a map from bodies to functions of bodies.
Map<BodyData, Function<BodyData> > collisionCallbacks;
// Invoke the function associated with that kind of body.
collisionCallbacks[firstBodyUserData].Invoke(secondBodyUserData);

// An example collision function
void resolveRocketCollision(BodyData data)
{
     // This is also really horrible. You don't want to be checking conditions 
     // like this. Instead, you will want to indirect this one step further to
     // the *type* of the object, using virtual function calls.
     if(data == "car_body") ...
     else if(data == "gas_tank") ...

     // That is, it should look like this:
     if (data.HasProperty(Health))
          ...
     if (data.HasProperty(Explodes))
          ..
     ...
}

// Registering the function
collisionCallbacks["rocket"] = resolveRocketCollision;

Avoiding function pointers

In Java, you don't have function pointers, so it might be better to have an interface with a "resolvecollision" method like this:

public interface CollisionResolver
{
    void Resolve(BodyData bodyData, CollisionData collision);
}

Then your map would be something like this:

Map<BodyData, CollisionResolver> collisionCallbacks;

And you invoke it like this:

collisionCallbacks[firstBodyUserData].Resolve(secondBodyData, collisionData);

Avoiding a big static map

Obviously it's bad practice to carry around a big map of collision callbacks. You will have to use (drum roll) object oriented programming. Instead of storing strings as your user data, store the objects themselves. Then your function just becomes:

void ResolveCollision(BodyData body1, BodyData body2, CollisionData collisionData)
{
    body1.Resolve(body2, collisionData);
}

And, each of your bodies implements the CollisionResolver interface. For example, if you want a rocket to explode anything that has "health" you do this:

class Rocket implements CollisionResolver
{
   public void Resolve(BodyData otherBody, CollisionData collisionData)
   {
       if (otherBody.HasProperty(Health))
       {
           ExplodeRocket();
           otherBody.Die();
       }
   }
}