auto. Typenkonvertierung

[usrr]

Hallo,

wird z.B. "floatvar / 10" automatisch vom Compiler in "floatvar / 10f" konvertiert, oder hat man einen damit während der Laufzeit immer einen kleinen Geschwindigkeitsverlust?

 

[faetzminator]

public class Test {
    public static void main(String[] args) {
         float f1 = 1.4f;
         System.out.println(f1 / 10);
         float f2 = 1.4f;
         System.out.println(f2 / 10f);
    }
}

->

[faetzminator@fkaros ~]$ javac -version
javac 1.6.0_26
[faetzminator@fkaros ~]$ javap -c Test
Compiled from "Test.java"
public class Test extends java.lang.Object{
public Test();
  Code:
   0:	aload_0
   1:	invokespecial	#1; //Method java/lang/Object."<init>":()V
   4:	return

public static void main(java.lang.String[]);
  Code:
   0:	ldc	#2; //float 1.4f
   2:	fstore_1
   3:	getstatic	#3; //Field java/lang/System.out:Ljava/io/PrintStream;
   6:	fload_1
   7:	ldc	#4; //float 10.0f
   9:	fdiv
   10:	invokevirtual	#5; //Method java/io/PrintStream.println:(F)V
   13:	ldc	#2; //float 1.4f
   15:	fstore_2
   16:	getstatic	#3; //Field java/lang/System.out:Ljava/io/PrintStream;
   19:	fload_2
   20:	ldc	#4; //float 10.0f
   22:	fdiv
   23:	invokevirtual	#5; //Method java/io/PrintStream.println:(F)V
   26:	return

}

 

[usrr]

thx

 

[jamesv]

Hallo,
kann mir jemand von euch erklären, was das ist, der Beitrag von faetzminator?

Code:
[faetzminator@fkaros ~]$ javac -version
javac 1.6.0_26
[faetzminator@fkaros ~]$ javap -c Test
Compiled from "Test.java"
public class Test extends java.lang.Object{
public Test();
Code:
0: aload_0
1: invokespecial #1; //Method java/lang/Object."<init>"🙁)V
4: return

public static void main(java.lang.String[]);
Code:
0: ldc #2; //float 1.4f
2: fstore_1
3: getstatic #3; //Field java/lang/System.out:Ljava/io/PrintStream;
6: fload_1
7: ldc #4; //float 10.0f
9: fdiv
10: invokevirtual #5; //Method java/io/PrintStream.println🙁F)V
13: ldc #2; //float 1.4f
15: fstore_2
16: getstatic #3; //Field java/lang/System.out:Ljava/io/PrintStream;
19: fload_2
20: ldc #4; //float 10.0f
22: fdiv
23: invokevirtual #5; //Method java/io/PrintStream.println🙁F)V
26: return

}

Dankeschön.

 

[Gast2]

javap ist nen disassembler für class Dateien. Du kannst da ziemlich genau sehen was der Compiler aus deinem Quellcode gemacht hat.

javap - The Java Class File Disassembler

 

[jamesv]

Woran erkennt man aber daran einen Performance-Unterschied?

Vielen Dank für den Linkv und die Antwort.

 

[faetzminator]

Man sieht die exakten Befehle, welche auf der JVM aufgerufen werden. Erkennst du den Unterschied zwischen den beiden Zweizeilern?

 

[jamesv]

Die einzigen Unterschiede, die ich sehe sind:

anstatt
fstore_1

gibt es

fstore_2


Dies halt auch für fload.

sollte ich andere Unterschiede erkennen?

 

[faetzminator]

Nein, aber dein Hirn für eine Minute enschalten 😉 Was sagt dir das?

 

[jamesv]

Wenn das der exakte Befehlssatz ist, dann müsste es einen Unterschied geben zwischen float/int und float/float. Habe ich mein Hirn richtig eingeschaltet? Sorry, aber ich mache sowas zum ersten Mal habt ihr eventuell noch ein paar erklärende Links dazu die ich mir unbedingt anschauen sollte?

Vielen Dank 🙂

 

[Ogofo]

Die Ursprüngliche Frage war ja ob aus einr "floatvar / 10" vom compiler eine "floatvar / 10f" gemacht wird. Sprich ob die Ganzzahl 10 von Compiler automatisch in eine Fließkommazahl umgewandelt wird (typecasting).

In dem Java Quelltext sieht man nun eine Division mit einer Ganzzahl 10 und eine mit einer Fließkommazahl 10f. Wenn man sich nun anschaut was der Compiler daraus macht sieht man das er bei beiden Divisionen eine Fließkommazahl verwendet, also automatisch die Ganzzahl umgewandelt hat.

Der Rest des Codes dort oben sind die Befehle die die JVM aufruft. Die könnte man nun nachschlagen (sind aber recht selbsterklärend ^^)

 

[hüteüberhüte]

Mich würde das auch mal interessieren, ob die Typkonvertierung zur Übersetzungszeit oder zur Laufzeit geschieht. Ein einfaches Ja bzw. Nein würde reichen

 

[schalentier]

Ja






:-D

Sorry, konnt ich mir nicht verkneifen 😛

 

[Gast2]

Ja, definitiv :reflect:

 

[hüteüberhüte]

Ok 😀

Das bedeutet auch mehr Freiheit für den Programmierer, Blödsinn zu schreiben, ohne dass das Programm langsamer ist, weil der Compiler vorher alles "wegoptimiert"... :bahnhof:

 

[AquaBall]

Man könnte auch sagen:
Ja bzw. Nein!

 

[Noctarius]

Also viele Dinge (z.B. diese Typenkonvertierung) aber auch Autoboxing und Unboxing (primitive -> wrapper, wrapper -> primitive) macht der Compiler (bei letzteren beiden werden z.B. Methodenaufrufe zu Integer.valueOf(...) und Integer.intValue() im Bytecode hinterlegt) gemacht. Andere Dinge macht erst die JVM.

Der Compiler kann relativ viel schon zur Compile-Time auflösen, der wichtige Vorteil bei statisch typisierten Sprachen. Hier sind fast alle Informationen die benötigt werden schon im Sourcecode vorhanden.

 

[hüteüberhüte]

Also viele Dinge (z.B. diese Typenkonvertierung) aber auch Autoboxing und Unboxing (primitive -> wrapper, wrapper -> primitive) macht der Compiler (bei letzteren beiden werden z.B. Methodenaufrufe zu Integer.valueOf(...) und Integer.intValue() im Bytecode hinterlegt) gemacht. Andere Dinge macht erst die JVM.

Aber Moment, ein Cast kann doch erst zur Laufzeit ausgeführt werden, oder etwa nicht?

 

[Noctarius]

Nein, ein Cast ist ein Opcode op_cast für Klassen und bei Zahlenwerten wird oft mit Tricks gearbeitet. Z.B. kannst du aus einem Integer einen float machen Integer.floatValue() usw. Aber richtig, viele Casts werden auch erst zur Laufzeit ausgeführt (Autoboxing aber gerade nicht, das gibt es nämlich eigentlich nicht und ist nur Compiler-Magic 😉).

 

[faetzminator]

Mich würde das auch mal interessieren, ob die Typkonvertierung zur Übersetzungszeit oder zur Laufzeit geschieht. Ein einfaches Ja bzw. Nein würde reichen

Falls du auf meine Antwort ansprichst: kann auch nichts dafür, musste es selbst ausprobieren 😉 Und dann sind die Resultate sinnvoller, als wenn ich irgendwelchen Text verfasst hätte...