As far as I can remember from my old days of reading bytecode, the number of catch clauses has no significant effect on performance.
When an exception occurs, the JVM knows to jump to the bytecode sequence which implements the catch clause by looking up the exception in a table that is part of the class' bytecode. In general, each method that catches an exception is associated with an exception table that is part of the class file, along with the method's bytecode. The exception table has an entry for each exception that's caught, by each try-block. Each entry contains: the start and end points, the program counter (PC) offset within the bytecode sequence to jump to, and a constant pool index of the exception type (i.e. class) that is being caught.
If an exception is thrown during the execution of a method, the JVM searches through the exception table for a match. A matches occurs if the current PC is within the range specified by the entry, and if the exception class thrown is the one specified by the entry (or is a subclass of it).
So the answer to your question depends on how this search is implemented. As far as I know, the JVM searches through the table in the same order in which the entries appear in the table and when the first match is found, the JVM sets the PC to the new location and continues execution from there.
I think that unless you have A LOT of exceptions you wouldn't notice a significant impact, but if I were you and if this issue was critical to me, I would benchmark this on the particular JVM that you're using.