web-dev-qa-db-fra.com

(String) ou .toString ()?

J'ai une méthode avec un paramètre Object o.

Dans cette méthode, je sais exactement qu'il y a un String dans "o" qui n'est pas nul. Il n'est pas nécessaire de vérifier ou de faire autre chose. Je dois le traiter exactement comme un objet String.

Juste curieux - ce qui est moins cher - le cast dans String, ou utilisez Object.toString()? Ou est-ce la même chose par le temps/cpu-/mem- price?

Mise à jour: La méthode accepte Object car c'est l'implémentation d'une interface. Il n'y a aucun moyen de changer le type de paramètre.

Et ça ne peut pas être null du tout. Je voulais juste dire que je n'ai pas besoin de vérifier la nullité ou le vide. Dans mon cas, il y a toujours une chaîne non vide.

javacasting
83
Vugluskr

la conversion en chaîne est moins chère car cela ne nécessite pas d'appel de fonction externe, juste une vérification de type interne.

66
euphoria83

J'utiliserais un casting. Cela valide votre "connaissance" qu'il s'agit d'une chaîne. Si pour une raison quelconque vous vous retrouvez avec un bogue et que quelqu'un passe quelque chose d'autre qu'une chaîne, je pense qu'il serait préférable de lever une exception (ce qu'un casting fera) que de continuer à exécuter avec des données erronées.

45
Jon Skeet

Selon Réflexions stupides sur la performance: x.toString () vs (String) x

À la fin, les résultats sont étonnamment clairs: il est au moins deux fois plus rapide de convertir Object en String que d'appeler Object.toString ()

34
cletus

Si vous savez que l'objet o est une chaîne, je dirais simplement que vous le transformez en chaîne et l'appliquez de cette façon. Appeler toString () sur un objet dont vous savez avec certitude qu'il s'agit d'une chaîne pourrait simplement ajouter de la confusion.

Si l'objet o peut être autre chose qu'une chaîne, vous devrez appeler toString ().

7
Andy White

Je ne serais pas trop préoccupé par les performances, si cette opération est effectuée même quelques milliers de fois par seconde - il n'y a pas de différence tangible.

Je serais cependant préoccupé de "connaître" l'entrée. Vous avez une méthode qui accepte un Object et vous devez le traiter comme tel, c'est-à-dire que vous ne devriez pas savoir quoi que ce soit sur le paramètre, à part qu'il adhère au Object interface, qui se trouve avoir une méthode toString(). Dans ce cas, je suggère fortement d'utiliser cette méthode au lieu de simplement supposer quoi que ce soit.

OTOH, si l'entrée est toujours soit String ou null, changez simplement la méthode pour accepter Strings, et vérifiez explicitement nulls (ce que vous devez faire quand vous traitez avec des non-primitifs ...)

3
Henrik Paul

Il ne peut pas y avoir de 'chaîne nulle en o'. Si o est nul, il ne contient pas de chaîne nulle, il est juste nul. Vérifiez d'abord o pour null en premier. Si vous jeter ou appelez ToString () sur null, vous planterez.

1
Ed S.

Étant donné que le type de référence est un objet et que tous les objets ont un toString (), appelez simplement object.toString (). String.toString () renvoie juste ceci.

  • toString () est moins de code à taper.
  • toString () est moins de bytecode.
  • la coulée est une opération coûteuse VS un appel polymorphe.
  • le casting pourrait échouer.
  • Utilisez String.valueOf (object) qui appelle simplement object.toString () s'il n'est pas nul.
1
mP.

Si ce que vous avez dans "o" est une chaîne, alors il n'y a pas beaucoup de différence (la conversion est probablement plus rapide, mais c'est une chose d'implémentation VM/Library).

Si "o" n'est peut-être pas une chaîne mais qu'il est censé être une chaîne, le cast est ce que vous voulez (mais vous devez faire en sorte que la méthode prenne une chaîne au lieu d'un objet).

Si "o" peut être de n'importe quel type, vous devez utiliser la chaîne toString - mais assurez-vous de vérifier d'abord null.

void foo(final Object o)
{
    final String str;

    // without this you would get a class cast exception
    // be wary of using instanceof though - it is usually the wrong thing to do
    if(o instanceof String)
    {
        str = (String)o;
    }    
}

ou

void foo(final Object o)
{
    final String str;

    // if you are 100% sure that o is not null then you can get rid of the else
    if(o != null)
    {
        str = o.toString();
    }
}

Je préfère coder le dernier comme:

void foo(final Object o)
{
    final String str;

    if(o == null)
    {
        throw new IllegalArgumentException("o cannot be null");
    }

    str = o.toString();
}
1
TofuBeer

J'ai trouvé étrangement que le casting était plus lent que la recherche de table implicite impliquée par l'appel tostring.

1
Joshua