Quoi de plus efficace/moins cher, casting ou appel de méthode?

Question

J'ai un Double que je veux frapper les chiffres supplémentaires après la décimale de (je ne suis pas trop préoccupé par la précision, mais n'hésitez pas à le mentionner dans votre réponse) avant la conversion en String.

Je me demandais s'il ne serait pas préférable de lancer à int ou d'utiliser un DecimalFormat et d'appeler format(..). Aussi, est-il plus efficace de spécifier String.valueOf() ou de le laisser tel quel et de laisser le compilateur le comprendre? Désolé si je semble un peu ignorant, je suis vraiment curieux d'apprendre plus des détails techniques.

Pour référence, je dessine texte et toile Android:

c.drawText("FPS: " + String.valueOf((int)lastFps), xPos, yPos, paint); 

Answer 1

J'ai fait un programme qui a utilisé System.nanoTime() pour calculer le temps d'exécution de ces deux méthodes:

public static void cast() { 
    for (int i=0; i<1000000; i++) { 
     int x= (int)Math.random(); 
    } 
} 

public static void format() { 
    for (int i=0; i< 1000000; i++) { 
     DecimalFormat df = new DecimalFormat("#"); 
     df.format(Math.random()); 
    } 
} 

Voici les résultats respectifs:

Accordé mes tests ne sont probablement pas des exemples parfaits. J'utilise simplement math.random(), qui génère un nombre qui sera toujours converti en 0, ce qui peut affecter les résultats. Cependant, ces résultats ont du sens - le moulage devrait être bon marché, car il ne fonctionne probablement pas sur les bits - la JVM ne traite que les bits différemment. Editer: Si je sors l'instanciation du formateur pour le second exemple, le programme s'exécute en 3155165182ns. Si je multiplie les nombres aléatoires par Integer.MAX_VALUE dans les deux cas (avec l'instanciation retirée), les résultats sont: 82100170 et 4174558079. On dirait que le casting est la voie à suivre.

Answer 2

D'une manière générale, la fonction/appels de méthode venir au coût des frais généraux de performance. Mon vote est que le typage serait plus rapide, mais comme @Zefiryn l'a suggéré, la meilleure façon est de créer une boucle et de faire chaque action une multitude de fois et de mesurer la performance avec une minuterie.

Answer 3

Le moulage sera probablement plus efficace. Ceci est implémenté comme du code natif alors que l'utilisation d'une méthode devra passer par le code java. De plus c'est beaucoup plus lisible.

Pour le string.valueof, je m'attends à ce que la performance soit strictement la même. Je trouve plus facile à lire pour le faire "string" + intValue que "string" + String.valueof(intValue)

Answer 4

Je ne suis pas sûr de l'efficacité de l'une ou l'autre, mais voici une troisième option qui pourrait être intéressant de comparer:

String.valueOf(doubleValue).substring(0, endInt) 

qui donnerait un ensemble nombre de caractères plutôt que des nombres décimaux/nombres, et passerait le typecasting mais faire deux appels de fonction à la place.

EDIT: était trop curieux, donc j'ai essayé de courir chaque option:

integerNumberFormat.format(number) 
String.valueOf(doubleValue).substring(0, endInt) 
String.valueOf((int)doubleValue) 

10^6 cycles avec les résultats étant ~ 800 ms, 300 ms et ~ ~ 40 ms, respectivement. Je suppose que mes résultats ne seront pas immédiatement traduisibles à votre situation, mais ils pourraient laisser entendre que le dernier est en effet, comme l'ont suggéré les affiches précédentes, le plus rapide.

Answer 5

C'est un travail pour Math.floor().