Question

Which is less expensive and preferable: put1 or put2?

Map<String, Animal> map = new Map<String, Animal>();

void put1(){
 for (.....)
  if (Animal.class.isAssignableFrom(item[i].getClass())
   map.put(key[i], item[i]);

void put2(){
 for (.....)
  try{
   map.put(key[i], item[i]);}
  catch (...){}

Question revision:
The question wasn’t that clear. Let me revise the question a little. I forgot the casting so that put2 depends on cast exception failure. isAssignableFrom(), isInstanceOf() and instanceof are similar functionally and therefore incur the same expense just one is a method to include subclasses,while the 2nd is for exact type matching and the 3rd is the operator version. Both reflective methods and exceptions are expensive operations.

My question is for those who have done some benchmarking in this area – which is less expensive and preferable: instanceof/isassignablefrom vs cast exception?

void put1(){
 for (.....)
  if (Animal.class.isAssignableFrom(item[i].getClass())
   map.put(key[i], (Animal)item[i]);

void put2(){
 for (.....)
  try{
   map.put(key[i], (Animal)item[i]);}
  catch (...){}

Answer 1

Probably you want:

if (item[i] instanceof Animal)
    map.put(key[i], (Animal) item[i]);

This is almost certainly much better than calling isAssignableFrom.

Or in C# (since you added the c# tag):

var a = item[i] as Animal;
if (a != null)
    map[key[i]] = a;

EDIT: The updated question is which is better: instanceof or cast-and-catch. The functionality is basically the same. The performance difference might not be significant and I would have to measure it; generally throwing an exception is slow, but I don’t know about the rest. So I would decide based on style. Say what you mean.

If you always expect expect item[i] to be an Animal, and you’re just being extra careful, cast-and-catch. Otherwise I find it much clearer to use instanceof, because that plainly says what you mean: “if this object is an Animal, put it in the map”.