My answer is that using public key pairs is a much **wiser thing to do** than using passwords or lists of passwords. I will focus on things that are *not widely known* about different forms of SSH authentication, and I see no other answers mentioning them. In fact I believe that some answers given seem to be unaware of the facts below and are wrong in my personal opinion.

First of all, you must understand that user authentication is a different and separate process than the establishment of the *secure channel*. In laymans terms what this means is that first, the public key of the server is used (if accepted!) to construct the secure SSH channel, by enabling the negotiation of a symmetric key which will be used to protect the remaining session, enable channel confidentiality, integrity protection and server authentication.

*After* the channel is functional and secure, user authentication takes place.
The two usual ways of doing that is by providing a password and by using a client public key pair.
The password based authentication works as you can imagine: The client sends his password over the secure channel, the server verifies that this is indeed the password of the specific user and allows access.
In the public key case, we have a very different situation. In this case, the server has the public key of the user stored. What happens next is that the server creates a random value (nonce), encrypts it with the public key and sends it to he user.  If the user is who is supposed to be, he can decrypt the challenge and send it back to the server, who then makes sure he believes the user. It is the classic *challenge-response model*.

As you can imagine, in the first case the password is actually sent to the server, in the second your private key never leaves the client. In the imaginary scenario that someone intercepts the SSL traffic, and is able to decrypt it (using a compromised server private key, or if you accept a wrong public key when connecting to the server) - your private details will never fall in the hand of the attacker.

There are other advantages of using a public key pair: The private key is not stored 'as is' in your client pc (or it shouldn't be!). It is stored *encrypted*, and needs you to provide a usually long passphrase to decrypt it each time it is used. What this means is that if your pc is compromised, your keyfile will not make any sense without the passphrase.
Of course this means that you will have to provide the long passphrase each time you connect to a server, to unlock your private key - Thera are ways around that too. You can increase the usuability of the system by using an authentication agent: This is a piece of software that unlocks your keys for the current session, when you log in to gnome for example, so you can just type 'ssh remote-system-ip' and log in, without providing a passphrase, and do that multiple times until you log out of your session.

So, to sum up, **using public key pairs offers considerably more protection** than using passwords or password lists, which can be captured if the client or the secure session is compromised.