Integer.toString (int i) vs String.valueOf (int i)

Je me demande pourquoi la méthode String.valueOf(int i)existe? J'utilise cette méthode pour convertir inten Stringet juste découvert la Integer.toString(int i)méthode.

Après avoir regardé l'implémentation de ces méthodes, j'ai vu que la première appelle la seconde. En conséquence, tous mes appels String.valueOf(int i)impliquent un appel de plus que d'appeler directementInteger.toString(int i)

Juste deux façons différentes de faire la même chose. Cela peut être une raison historique (je ne me souviens pas si l'un est venu avant l'autre).

Dans le type String, nous avons plusieurs méthodes valueOf

static String   valueOf(boolean b) 
static String   valueOf(char c) 
static String   valueOf(char[] data) 
static String   valueOf(char[] data, int offset, int count) 
static String   valueOf(double d) 
static String   valueOf(float f) 
static String   valueOf(int i) 
static String   valueOf(long l) 
static String   valueOf(Object obj) 

Comme nous pouvons le voir, ces méthodes sont capables de résoudre toutes sortes de nombres

chaque implémentation de méthode spécifique comme vous l'avez présentée: Donc, pour les entiers, nous avons

Integer.toString(int i)

pour double

Double.toString(double d)

etc

À mon avis, ce n'est pas quelque chose d'historique, mais il est plus utile pour un développeur d'utiliser la méthode valueOfde la classe String que du type approprié, car cela entraîne moins de modifications à apporter.

Échantillon 1:

public String doStuff(int num) {

  // Do something with num...

  return String.valueOf(num);

 }

Échantillon2:

public String doStuff(int num) {

 // Do something with num...

 return Integer.toString(num);

 }

Comme nous le voyons dans l'exemple 2, nous devons faire deux changements, contrairement à l'exemple 1.

Dans ma conclusion, l'utilisation de la valueOfméthode de la classe String est plus flexible et c'est pourquoi elle y est disponible.

Une énorme différence est que si vous invoquez toString()dans un objet null, vous obtiendrez un NullPointerExceptionalors, en utilisant String.valueOf()vous ne pouvez pas vérifier null.

La classe String fournit des méthodes valueOf pour tous les types primitifs et le type Object, donc je suppose que ce sont des méthodes pratiques auxquelles toutes peuvent accéder via la classe unique.

NB Profilage des résultats

Moyenne intToString = 5368 ms, moyenne stringValueOf = 5689 ms (pour 100 000 000 opérations)

public class StringIntTest {


    public static long intToString () {
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 100000000; i++) {
            String j = Integer.toString(i);
        }
        long finishTime = System.currentTimeMillis();

        return finishTime - startTime;
    }

    public static long stringValueOf () {

        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 100000000; i++) {
            String j = String.valueOf(i);
        }
        long finishTime = System.currentTimeMillis();

        return finishTime - startTime;
    }

    public static void main(String[] args) {
        long intToStringElapsed = 0;
        long stringValueOfElapsed = 0;
        for (int i = 0; i < 10; i++) {
            intToStringElapsed += intToString();
            stringValueOfElapsed+= stringValueOf();
        }
        System.out.println("Average intToString = "+ (intToStringElapsed /10));
        System.out.println("Average stringValueOf = " +(stringValueOfElapsed / 10));
    }
}

À partir des sources Java:

/**
 * Returns the string representation of the {@code int} argument.
 * <p>
 * The representation is exactly the one returned by the
 * {@code Integer.toString} method of one argument.
 *
 * @param   i   an {@code int}.
 * @return  a string representation of the {@code int} argument.
 * @see     java.lang.Integer#toString(int, int)
 */
public static String valueOf(int i) {
    return Integer.toString(i);
}

Donc, ils donnent exactement le même résultat et l'un appelle en fait l'autre. String.valueOf est plus flexible si vous pouvez modifier le type ultérieurement.

Si vous regardez le code source de la Stringclasse, il appelle en fait Integer.toString()lorsque vous appelez valueOf().

Cela étant dit, cela Integer.toString()pourrait être un peu plus rapide si les appels de méthode ne sont pas optimisés au moment de la compilation (ce qu'ils sont probablement).

L'implémentation de ce String.valueOf()que vous voyez est le moyen le plus simple de respecter le contrat spécifié dans l'API: "La représentation est exactement celle renvoyée par la Integer.toString()méthode d'un argument."

Pour répondre à la question des OP, c'est simplement un wrapper d'aide pour avoir l'autre appel, et cela revient au choix de style et c'est tout. Je pense qu'il y a beaucoup de désinformation ici et la meilleure chose qu'un développeur Java puisse faire est de regarder l'implémentation de chaque méthode, c'est à un ou deux clics dans n'importe quel IDE. Vous verrez clairement que cela vous String.valueOf(int)appelle simplement Integer.toString(int).

Par conséquent, il n'y a absolument aucune différence, en ce sens qu'ils créent tous les deux un tampon de caractères, parcourent les chiffres du nombre, puis copient cela dans une nouvelle chaîne et la renvoient (par conséquent, chacun crée un objet String). La seule différence est un appel supplémentaire, que le compilateur élimine de toute façon en un seul appel.

Donc, peu importe ce que vous appelez, à part peut-être la cohérence du code. Quant aux commentaires sur les nulls, il faut une primitive, donc il ne peut pas être nul! Vous obtiendrez une erreur de compilation si vous n'initialisez pas l'int en cours de transmission. Il n'y a donc aucune différence dans la façon dont il gère les valeurs nulles car elles n'existent pas dans ce cas.

Vous ne devriez pas vous inquiéter du fait que cet appel supplémentaire vous coûte des problèmes d'efficacité. S'il y a un coût, ce sera minime et devrait être négligeable dans une vue d'ensemble des choses.

Peut-être que la raison pour laquelle les deux existent est d'offrir une lisibilité. Dans le contexte de nombreux types en cours de conversion String, divers appels à String.valueOf(SomeType)peuvent être plus lisibles que divers SomeType.toStringappels.

mon ouverture est valueof () toujours appelée tostring () pour la représentaion et donc pour la représentation du type primitif valueof est généralisée.et java par défaut ne prend pas en charge le type de données mais définit son travail avec objaect et class son fait tout dans cllas et fait object .here Integer.toString (int i) crée une limite de conversion pour uniquement un entier.

Il n'y a aucune différence entre Integer.toString (5) et String.valueOf (5);

car String.valueOf renvoie:

public static String valueOf(int i) {
    return Integer.toString(i);
}
public static String valueOf(float f) {
    return Float.toString(f);
}

etc..

En utilisant la méthode String.valueOf (), vous n'avez pas à vous soucier des données (qu'elles soient int, long, char, char [], boolean, Object), vous pouvez simplement appeler:

• static String valueOf ()

en utilisant la seule syntaxe String.valueOf () peut tout ce que vous passez en paramètre est converti en String et renvoyé.

Sinon, si vous utilisez Integer.toString (), Float.toString () etc. (ie SomeType.toString ()) alors vous devrez vérifier le type de données du paramètre que vous voulez convertir en chaîne. Il est donc préférable d'utiliser String.valueOf () pour de telles conversions.

Si vous avez un tableau de classe d'objets qui contient différentes valeurs comme Integer, Char, Float, etc., alors en utilisant la méthode String.valueOf (), vous pouvez convertir facilement les éléments d'un tel tableau en forme de chaîne. Au contraire, si vous voulez utiliser SomeType.toString (), vous aurez d'abord besoin de connaître leurs classes de types de données (peut-être en utilisant l'opérateur "instanceOf") et ensuite vous seul pouvez procéder à un transtypage.

La méthode String.valueOf () lorsqu'elle est appelée correspond au paramètre qui est passé (que ce soit son Integer, Char, Float, etc.) et en utilisant la surcharge de méthode appelle cette méthode "valueOf ()" dont le paramètre est mis en correspondance, puis à l'intérieur de cette méthode, c'est un appel direct à la méthode "toString ()" correspondante.

Ainsi, nous pouvons voir comment la surcharge liée à la vérification du type de données et à l'appel de la méthode "toString ()" correspondante est supprimée. Il suffit d'appeler la méthode String.valueOf (), sans se soucier de ce que nous voulons convertir en String.

Conclusion: La méthode String.valueOf () a son importance juste au prix d'un appel supplémentaire.

toString ()

1. est présent dans la classe Object, généralement remplacé dans la classe dérivée
2. typecast à la classe appropriée est nécessaire pour appeler la méthode toString ().

valeur de()

1. Méthode statique surchargée présente dans la classe String.

2. gère les types primitifs ainsi que les types d'objets.

   Integer a = null;
   System.out.println(Integer.toString()) ; NUll pointer exception
   System.out.println(String.valueOf() ; give NULL as value

vérifiez ce lien c'est très bon. http://code4reference.com/2013/06/which-one-is-better-valueof-or-tostring/