[Java] Vergleich der Geschwindigkeit der Typkonvertierung

Jeder sah auch den Code `double hoge = 1;` und sagte: "Ist es in Ordnung, wenn ich nicht" double hoge = 1.0d; ``? "" Wird die Ausführungsgeschwindigkeit nicht verlangsamt? " Ich glaube, Sie haben sich vielleicht Sorgen gemacht. Also habe ich es tatsächlich gemessen.

Ergebnis

Die Einheit ist Nanosekunden, aber die Geschwindigkeit variiert je nach Umgebung, sodass sie nur eine Richtlinie ist. Betrachten Sie es als ** relativ ** schneller **, da die Anzahl ** kleiner ist. Fett ist die Konvertierung in den gleichen Typ.

wird bearbeitet\Ergebnis(dst)Art int long float double
dst =Variable vom Typ int; 19.42 20.93 20.80 20.95
dst =lange Typvariable; 20.92 20.84 20.94
dst =Variable vom Typ float; 21.10 20.84
dst =doppelte Typvariable; 20.97
dst = (Besetzung)Variable vom Typ int; 19.95 20.93 20.81 20.95
dst = (Besetzung)lange Typvariable; 20.69 21.10 20.96 20.90
dst = (Besetzung)Variable vom Typ float; 21.19 21.11 20.88 21.20
dst = (Besetzung)doppelte Typvariable; 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

Impressionen

Immerhin scheint es grundsätzlich schneller zu sein, die Formen auszurichten. Es gibt jedoch einige Kombinationen, bei denen die Typkonvertierung schneller ist, sodass sie als Fehlerkategorie betrachtet werden kann.

double hoge = 1;Und doppelte Hoge= 1.0d;Ich habe festgestellt, dass sich nicht viel geändert hat, sodass ich endlich mit dem Kissen von heute schlafen kann.



### Hinweis
 Basierend auf diesem Ergebnis ** Bitte versuchen Sie nicht, das Programm unachtsam zu beschleunigen **.
 Lesbarkeit und Beschleunigung des Algorithmus sind wichtiger, als das Programm zwangsweise zu ändern und eine leichte Beschleunigung wie Fehler vorzunehmen.

# Ausführungsinhalt
 Der tatsächlich eingegebene Verarbeitungsinhalt ist wie folgt.

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[] = {
        //Ersatz wie es ist
        ()->{ dstI = srcI; }

// , ()->{ dstI = srcL; } //Unmöglich // , ()->{ dstI = srcF; } //Unmöglich // , ()->{ dstI = srcD; } //Unmöglich //Cast und zuweisen , ()->{ dstI = (int)srcI; } , ()->{ dstI = (int)srcL; } , ()->{ dstI = (int)srcF; } , ()->{ dstI = (int)srcD; } //Ersetzen Sie eine Nummer , ()->{ dstI = 1 ; } // , ()->{ dstI = 1l ; } //Unmöglich // , ()->{ dstI = 1.0f; } //Unmöglich // , ()->{ dstI = 1.0d; } //Unmöglich };

    TimeMeasure.Sample sampleL[] = {
        //Ersatz wie es ist
        ()->{ dstL = srcI; }
    ,   ()->{ dstL = srcL; }

// , ()->{ dstL = srcF; } //Unmöglich // , ()->{ dstL = srcD; } //Unmöglich //Cast und zuweisen , ()->{ dstL = (long)srcI; } , ()->{ dstL = (long)srcL; } , ()->{ dstL = (long)srcF; } , ()->{ dstL = (long)srcD; } //Ersetzen Sie eine Nummer , ()->{ dstL = 1 ; } , ()->{ dstL = 1l ; } // , ()->{ dstL = 1.0f; } //Unmöglich // , ()->{ dstL = 1.0d; } //Unmöglich };

    TimeMeasure.Sample sampleF[] = {
        //Ersatz wie es ist
        ()->{ dstF = srcI; }
    ,   ()->{ dstF = srcL; }
    ,   ()->{ dstF = srcF; }

// , ()->{ dstF = srcD; } //Unmöglich //Cast und zuweisen , ()->{ dstF = (float)srcI; } , ()->{ dstF = (float)srcL; } , ()->{ dstF = (float)srcF; } , ()->{ dstF = (float)srcD; } //Ersetzen Sie eine Nummer , ()->{ dstF = 1 ; } , ()->{ dstF = 1l ; } , ()->{ dstF = 1.0f; } // , ()->{ dstF = 1.0d; } //Unmöglich };

    TimeMeasure.Sample sampleD[] = {
        //Ersatz wie es ist
        ()->{ dstD = srcI; }
    ,   ()->{ dstD = srcL; }
    ,   ()->{ dstD = srcF; }
    ,   ()->{ dstD = srcD; }
        //Cast und zuweisen
    ,   ()->{ dstD = (double)srcI; }
    ,   ()->{ dstD = (double)srcL; }
    ,   ()->{ dstD = (double)srcF; }
    ,   ()->{ dstD = (double)srcD; }
        //Ersetzen Sie eine Nummer
    ,   ()->{ dstD = 1   ; }
    ,   ()->{ dstD = 1l  ; }
    ,   ()->{ dstD = 1.0f; }
    ,   ()->{ dstD = 1.0d; }
    };

### Rechenmethode
 1. Führen Sie den zu messenden Prozess 1 Million Mal aus und berechnen Sie die durchschnittliche Ausführungszeit für jedes Mal.
 2. Führen Sie 1 100 Mal aus und berechnen Sie den Durchschnittswert der Ergebnisse.

 * Das Programm für den Berechnungsteil ist in die hausgemachte Bibliothek integriert, daher ist es unentschlossen. Wenn Sie dem Ergebnis misstrauen, versuchen Sie, es selbst zu messen.

<details>
 <summary> Rohes Ausführungsergebnis </ summary>
<div>

Substitution zu 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 zu lang 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 |=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=| Zuordnung zum Schweben 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 |=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=| Auswechslung zu verdoppeln 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>

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


Recommended Posts

[Java] Vergleich der Geschwindigkeit der Typkonvertierung
Java-Typkonvertierung
[Java] Konvertierung des Datumstyps
[Java] Konvertierung von Listentyp / Array-Typ
Java Primer Series (Typkonvertierung)
[Java] Geschwindigkeitsvergleich der Zeichenfolgenkombination
[Java] Korrekter Vergleich des String-Typs
Konvertierung des Java-Datumsdatentyps (Datum, Kalender, Zeichenfolge)
In Bezug auf den Vergleich der Zeichenfolgentypäquivalenz in Java
[Leicht verständliche Erklärung! ] Konvertierung des Referenztyptyps in Java
[Java ~ Informationen zur Variablendefinition und Typkonvertierung ~] Studiennotiz
[Java] Aufzählungstyp
Java-Studie Nr. 3 (Typkonvertierung und Befehlsausführung)
Java-Doppeltyp
[Java] Kartenvergleich
Java Framework Vergleich
[Grundkenntnisse in Java] Informationen zur Typkonvertierung
Java 8 LocalDateTime-Typkonvertierung (String, java.util.Date)
[Java] Berechnungsmechanismus, Operatoren und Typkonvertierung
Typkonvertierung vom Java Big Decimal-Typ zum String-Typ
[Einführung in Java] Informationen zur Typkonvertierung (Besetzung, Promotion)
Java-Typkonvertierung (String, int, Datum, Kalender usw.)
Vergleich der Java-Versionsnotation
[Java] Vergleich von Zeichenketten und && und ||
Uri → String, String → Uri-Typkonvertierung
[Java, Kotlin] Typabweichung
Feld für den Java-Klassentyp
Typbestimmung in Java
Java # 1 studieren (typischer Typ)
[Entwicklung] Java Framework Vergleich
Endian-Konvertierung mit JAVA
[Java] Vergleich der Ausführungsgeschwindigkeit des String-Joins (+ Operator vs StringBuilder)
Geschwindigkeitsvergleich zum Zeitpunkt der Generierung zum Zeitpunkt der Datumskonvertierung
Java-Lernnotiz (Datentyp)
Java ArrayList, Vector, LinkedList Vergleich
Probieren Sie den Funktionstyp in Java aus! ①
[Java Bronze] Lernnotiz (Schnittstelle, statische Methode, Typkonvertierung usw.)
Studieren Sie Java # 7 (Art der Verzweigungssyntax)
Java-Vergleich mit der compareTo () -Methode
[Java] Datentyp / Matrixprodukt (AOJ ⑧ Matrixprodukt)
Java (Klassentyp für Feld verwenden)
[Java] Konvertierung von Array zu Liste
Java-Array / Liste / Stream gegenseitige Konvertierungsliste
Java8-Listenkonvertierung mit Stream Map
Verwendung des Java-Aufzählungstyps
Vergleich zwischen Java und Swift (2) Grundtyp / Arithmetik / Steuerungssyntax / Funktionsdefinition
Java-Überprüfung ② (Berechnung, Escape-Sequenz, Bewertungsregel, Typkonvertierung, Anweisungsausführungsanweisung)