[Java] Comparaison de la vitesse de conversion de type

Tout le monde a également vu le code `double hoge = 1;` et a dit: "Est-ce que ça va si je ne règle pasdouble hoge = 1.0d; `?" Je pense que vous étiez peut-être inquiet. Alors je l'ai mesuré.

résultat

L'unité est en nanosecondes, mais la vitesse varie en fonction de l'environnement, ce n'est donc qu'un guide. Considérez-le comme ** relativement ** plus rapide ** car le nombre est ** plus petit. Gras est la conversion vers le même type.

En traitement\résultat(dst)Type int long float double
dst =variable de type int; 19.42 20.93 20.80 20.95
dst =variable de type long; 20.92 20.84 20.94
dst =variable de type float; 21.10 20.84
dst =variable de type double; 20.97
dst = (jeter)variable de type int; 19.95 20.93 20.81 20.95
dst = (jeter)variable de type long; 20.69 21.10 20.96 20.90
dst = (jeter)variable de type float; 21.19 21.11 20.88 21.20
dst = (jeter)variable de type double; 20.97 21.14 20.95 20.95
dst = 1; 20.72 20.86 20.82 21.00
dst = 1l; 20.84 20.75 20.99
dst = 1.0f; 20.72 21.07
dst = 1.0d; 20.94

Impressions

Après tout, il semble qu'il est fondamentalement plus rapide d'aligner les moules. Cependant, il existe certaines combinaisons où la conversion de type est plus rapide, elle peut donc être considérée comme une catégorie d'erreur.

double hoge = 1;Et double hoge= 1.0d;Quant à moi, j'ai trouvé que ça n'avait pas beaucoup changé, donc je peux enfin dormir avec l'oreiller levé d'aujourd'hui.



### Mise en garde
 Sur la base de ce résultat ** Veuillez ne pas essayer d'accélérer le programme par inadvertance **.
 La lisibilité et l'accélération de l'algorithme sont plus importantes que la modification forcée du programme et l'accélération légère telle qu'une erreur.

# Contenu d'exécution
 Le contenu de traitement effectivement saisi est le suivant.

static int    srcI = 1;
static long   srcL = 1l;
static float  srcF = 1.0f;
static double srcD = 1.0d;
static int    dstI;
static long   dstL;
static float  dstF;
static double dstD;

    TimeMeasure.Sample sampleI[] = {
        //Substituer tel quel
        ()->{ dstI = srcI; }

// , ()->{ dstI = srcL; } //Impossible // , ()->{ dstI = srcF; } //Impossible // , ()->{ dstI = srcD; } //Impossible //Diffuser et attribuer , ()->{ dstI = (int)srcI; } , ()->{ dstI = (int)srcL; } , ()->{ dstI = (int)srcF; } , ()->{ dstI = (int)srcD; } //Remplacez un nombre , ()->{ dstI = 1 ; } // , ()->{ dstI = 1l ; } //Impossible // , ()->{ dstI = 1.0f; } //Impossible // , ()->{ dstI = 1.0d; } //Impossible };

    TimeMeasure.Sample sampleL[] = {
        //Substituer tel quel
        ()->{ dstL = srcI; }
    ,   ()->{ dstL = srcL; }

// , ()->{ dstL = srcF; } //Impossible // , ()->{ dstL = srcD; } //Impossible //Diffuser et attribuer , ()->{ dstL = (long)srcI; } , ()->{ dstL = (long)srcL; } , ()->{ dstL = (long)srcF; } , ()->{ dstL = (long)srcD; } //Remplacez un nombre , ()->{ dstL = 1 ; } , ()->{ dstL = 1l ; } // , ()->{ dstL = 1.0f; } //Impossible // , ()->{ dstL = 1.0d; } //Impossible };

    TimeMeasure.Sample sampleF[] = {
        //Substituer tel quel
        ()->{ dstF = srcI; }
    ,   ()->{ dstF = srcL; }
    ,   ()->{ dstF = srcF; }

// , ()->{ dstF = srcD; } //Impossible //Diffuser et attribuer , ()->{ dstF = (float)srcI; } , ()->{ dstF = (float)srcL; } , ()->{ dstF = (float)srcF; } , ()->{ dstF = (float)srcD; } //Remplacez un nombre , ()->{ dstF = 1 ; } , ()->{ dstF = 1l ; } , ()->{ dstF = 1.0f; } // , ()->{ dstF = 1.0d; } //Impossible };

    TimeMeasure.Sample sampleD[] = {
        //Substituer tel quel
        ()->{ dstD = srcI; }
    ,   ()->{ dstD = srcL; }
    ,   ()->{ dstD = srcF; }
    ,   ()->{ dstD = srcD; }
        //Diffuser et attribuer
    ,   ()->{ dstD = (double)srcI; }
    ,   ()->{ dstD = (double)srcL; }
    ,   ()->{ dstD = (double)srcF; }
    ,   ()->{ dstD = (double)srcD; }
        //Remplacez un nombre
    ,   ()->{ dstD = 1   ; }
    ,   ()->{ dstD = 1l  ; }
    ,   ()->{ dstD = 1.0f; }
    ,   ()->{ dstD = 1.0d; }
    };

### Méthode de calcul
 1. Exécutez le processus à mesurer 1 million de fois et calculez le temps d'exécution moyen pour chaque fois.
 2. Exécutez 1 100 fois et calculez la valeur moyenne des résultats.

 * Le programme de calcul pièce est intégré à la bibliothèque maison, il est donc indécis. Si vous vous méfiez du résultat, essayez de le mesurer vous-même.

<details>
 <summary> Résultat d'exécution brut </ summary>
<div>

Substitution à int sample( 1 / 6 ) set times : 1000000 x 100 set avelage : 19.416518 ns |=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=| sample( 2 / 6 ) set times : 1000000 x 100 set avelage : 19.949821 ns |=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=| sample( 3 / 6 ) set times : 1000000 x 100 set avelage : 20.694315 ns |=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=| sample( 4 / 6 ) set times : 1000000 x 100 set avelage : 21.191030 ns |=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=| sample( 5 / 6 ) set times : 1000000 x 100 set avelage : 20.969548 ns |=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=| sample( 6 / 6 ) set times : 1000000 x 100 set avelage : 20.723962 ns |=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=| Substitution à long sample( 1 / 8 ) set times : 1000000 x 100 set avelage : 20.926685 ns |=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=| sample( 2 / 8 ) set times : 1000000 x 100 set avelage : 20.923104 ns |=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=| sample( 3 / 8 ) set times : 1000000 x 100 set avelage : 20.933459 ns |=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=| sample( 4 / 8 ) set times : 1000000 x 100 set avelage : 21.099284 ns |=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=| sample( 5 / 8 ) set times : 1000000 x 100 set avelage : 21.107446 ns |=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=| sample( 6 / 8 ) set times : 1000000 x 100 set avelage : 21.144695 ns |=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=| sample( 7 / 8 ) set times : 1000000 x 100 set avelage : 20.855954 ns |=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=| sample( 8 / 8 ) set times : 1000000 x 100 set avelage : 20.842132 ns |=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=| Substitution pour flotter sample( 1 / 10 ) set times : 1000000 x 100 set avelage : 20.799797 ns |=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=| sample( 2 / 10 ) set times : 1000000 x 100 set avelage : 20.841888 ns |=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=| sample( 3 / 10 ) set times : 1000000 x 100 set avelage : 21.097959 ns |=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=| sample( 4 / 10 ) set times : 1000000 x 100 set avelage : 20.814193 ns |=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=| sample( 5 / 10 ) set times : 1000000 x 100 set avelage : 20.959374 ns |=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=| sample( 6 / 10 ) set times : 1000000 x 100 set avelage : 20.883601 ns |=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=| sample( 7 / 10 ) set times : 1000000 x 100 set avelage : 20.948977 ns |=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=| sample( 8 / 10 ) set times : 1000000 x 100 set avelage : 20.824086 ns |=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=| sample( 9 / 10 ) set times : 1000000 x 100 set avelage : 20.750565 ns |=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=| sample( 10 / 10 ) set times : 1000000 x 100 set avelage : 20.721974 ns |=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=| Substitution pour doubler sample( 1 / 12 ) set times : 1000000 x 100 set avelage : 20.958085 ns |=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=| sample( 2 / 12 ) set times : 1000000 x 100 set avelage : 20.943837 ns |=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=| sample( 3 / 12 ) set times : 1000000 x 100 set avelage : 20.839026 ns |=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=| sample( 4 / 12 ) set times : 1000000 x 100 set avelage : 20.972230 ns |=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=| sample( 5 / 12 ) set times : 1000000 x 100 set avelage : 20.951048 ns |=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=| sample( 6 / 12 ) set times : 1000000 x 100 set avelage : 20.900803 ns |=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=| sample( 7 / 12 ) set times : 1000000 x 100 set avelage : 21.196955 ns |=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=| sample( 8 / 12 ) set times : 1000000 x 100 set avelage : 20.954024 ns |=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=| sample( 9 / 12 ) set times : 1000000 x 100 set avelage : 21.002265 ns |=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=| sample( 10 / 12 ) set times : 1000000 x 100 set avelage : 20.991709 ns |=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=| sample( 11 / 12 ) set times : 1000000 x 100 set avelage : 21.072246 ns |=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=| sample( 12 / 12 ) set times : 1000000 x 100 set avelage : 20.941363 ns |=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|


</div></details>

### environnement
Java : 1.8.0_31
OS : Windows 10 64bit
RAM : 32.0GB
CPU : Intel Core i7-4790K 4.00GHz


Recommended Posts

[Java] Comparaison de la vitesse de conversion de type
Conversion de type Java
[Java] Conversion de type de date
[Java] Conversion de type de liste / type de tableau
Java Primer Series (conversion de type)
[Java] Comparaison de vitesse de combinaison de chaînes
[Java] Comparaison correcte du type String
Conversion de type de données de date Java (date, calendrier, chaîne)
Concernant la comparaison d'équivalence de type de chaîne en Java
[Explication facile à comprendre! ] Conversion de type de type de référence en Java
[Java ~ A propos de la définition de variable et de la conversion de type ~] Note d'étude
[Java] Type d'énumération
Etude Java n ° 3 (conversion de type et exécution d'instruction)
Java double type
[Java] Comparaison de cartes
Comparaison du framework Java
[Connaissance de base de Java] À propos de la conversion de type
Conversion de type Java 8 LocalDateTime (String, java.util.Date)
[Java] Mécanisme de calcul, opérateurs et conversion de type
Conversion de type du type java Big Decimal au type String
[Introduction à Java] À propos de la conversion de type (distribution, promotion)
Conversion de type Java (chaîne, entier, date, calendrier, etc.)
Comparaison de la notation de la version Java
[Java] Comparaison des chaînes de caractères et && et ||
Conversion de type Uri → String, String → Uri
[Java, Kotlin] Variance de type
Champ de type de classe Java
Détermination de type en Java
Étudier Java # 1 (type typique)
[Développement] Comparaison du framework Java
Conversion Endian avec JAVA
[Java] Comparaison de la vitesse d'exécution de la jointure de chaîne (+ opérateur vs StringBuilder)
Comparaison de vitesse au moment de la génération au moment de la conversion de la date
Mémo d'apprentissage Java (type de données)
java ArrayList, Vector, comparaison LinkedList
Essayez le type fonctionnel en Java! ①
[Java Bronze] Mémo d'apprentissage (interface, méthode statique, conversion de type, etc.)
Etude de Java # 7 (Type de syntaxe de branche)
Comparaison Java à l'aide de la méthode compareTo ()
[Java] Type de données / produit matriciel (produit matriciel AOJ ⑧)
java (utilisez le type de classe pour le champ)
[Java] Conversion d'un tableau à une liste
Liste de conversion mutuelle de tableau / liste / flux Java
Conversion de liste Java8 avec Stream map
Comment utiliser le type enum Java
Comparaison entre Java et Swift (2) Type de base / Arithmétique / Syntaxe de contrôle / Définition de fonction
Revue Java ② (calcul, séquence d'échappement, règle d'évaluation, conversion de type, instruction d'exécution d'instruction)