Variablen im Java-Code selber "ausrechnen"

[BlueMoon92]

Hallo,
ich habe im Oktober angefangen Informatik zu studieren und war schon seit langer Zeit auf der suche nach einem guten und aktiven Java Forum. Jetzt bin ich seit gestern hier gelandet und eig. ganz zufrieden.

Ich habe eine Aufgabe bekommen und komme leider nicht mehr weiter. Ich könnte es jetzt in einem Compiler laufen lassen, aber ich will lieber selber auf die Ergebnisse kommen. Könnte mir bitte jemand erklären, wie ich auf die Lösungen von a, b, c, d und e komme? Bei b bin ich mir relativ sicher, dass dort 0x1234AFFE als Ergebnis angezeigt wird, da es im durchlauf nicht verändert wird. Bei c ist es so, dass 1 draufaddiert wird, so erhält man 0x00000000. Aber bei den anderen komme ich leider nicht mehr weiter. Es wäre nett, wenn ich nicht direkt die Ergebnisse gesagt bekomme.

public class BitArithmetics {
public static String HexOut(int i) {
String s = Integer.toHexString(i);
while (s.length() < 8) s = "0" + s;
s = "0x" + s;
return s;
}
public static void main(String[] args) {
System.out.println("Programm gestartet.");
int a = -1;
int b = 0x1234AFFE;
int c = 0xFFFFFFFF; c++;
int d = (b << 16) ^ (b >> 16);
int e = b / 16;
System.out.println("a = " + HexOut(a));
System.out.println("b = " + HexOut(b));
System.out.println("c = " + HexOut(c));
System.out.println("d = " + HexOut(d));
System.out.println("e = " + HexOut(e));
System.out.println("Programm beendet.");
}
}

 

[Gucky]

<< und >> sind Bitoperatoren. Sie bedeuten, dass das Bitmuster der betreffenden Variable (oder Konstante) verschoben wird.

Bei a sehe ich keine Veränderung.

b/16 ist einfach ausrechnen und die Nachkommastellen abschneiden. Nicht runden.

Für den String einfach die Schleife langlaufen.

 

[kaoZ]

Dazu musst du , insofern du die Ergebnisse selbst errechnen willst , dich mit den Bit Operatoren auseinander setzen

<<

sowie

>>

shiften die stellen um die jeweilige zahl, in deinem Fall

16

stellen nach rechts , bzw.links

in Binärer Schreibweise wäre das z.B

00001010 << 2 // Dezimal 10 im Binärsystem 2 stellen nach links shiften

Ausgabe :

00101000 // // Dezimal 40 wäre das geshiftete Ergebnis

das gleiche kannst du nun bei Hexadezimalen Zahlen machen

0x0A << 2 // Hexadezimal 10 2 stellen nach links shiften 

Ausgabe :

0x28 // Hexadezimal 40 wäre das geshiftete Ergebnis

Ich persönlich finde es wesentlich einfacher, sowas zu errechnen wenn ich die Hexadezimalzahl vorher ins Binärsystem umrechne

 

[kaoZ]

Nur nochmal ein kleines Beispiel:

Hex zu binär:

0x45 

//aufteilen in nibbles ( jede zahl steht für 4 Bit = 1 nibble )

4 = 0100

5 = 0101

01000101 = 1 Byte = 8 Bit

Ergibt im Dezimalsystem ( anhand der Wertigkeit ) :

64 + 4 + 1 = 69

 

[BlueMoon92]

Hallo,

vielen Dank für eure Antworten. Also ich habe mal versucht die Variablen selber auszurechnen...

a) 0x ....
Wie wird es bei der a gerechnet? Mit -1 kann ich nicht wirklich etwas anfangen..
b) 0x0x1234AFFE
c) 0x00000000
d) 0x ....

So, ich habe es jetzt genau wie in deinem Beispiel in binär umgerechnet. Aber bei mir kommt jetzt 0 als Ergebnis raus... Aber leider ist mein Ergebnis falsch. Was habe ich hier falsch gemacht?

(hex) A F F E 0 0 0 0
(bin) 1010 1111 1111 1110 0000 0000 0000 0000
(hex) 0 0 0 0 1 2 3 4
^ (bin) 0000 0000 0000 0000 0001 0010 0011 0100
--------------------------------------------------------------------
(hex) 0 0 0 0 0 0 0 0
(bin) 0000 0000 0000 0000 0000 0000 0000 0000

e) 0x ....
Wie muss ich bei dieser Aufgabe rechnen? Und dieses / ist dann wohl der div-Operator, wenn ich die Nachkommastellen nicht beachten muss.

 

[Gucky]

(dez)-1=(hex)-1

e) Ganz normal ausrechnen mit Nachkommastellen und diese abschneiden. Nicht runden.

 

[kaoZ]

Bsp:

0x45 -1

ist equivalent zu 69 - 1

Aufgabe e ist :

0x1234AFFE / 16

also 

12  34  AF  FE

00010010001101001100111111111110

305442814

305442814 / 16

Ergebnis

19090175

//Überprüfen kannst du dies leicht mit 

System.out.println(Integer.toHexString(305442814));

Dies ergibt :

0x1234AFFE

 

[Sen-Mithrarin]

wow ... wieder mal absolute begeisterung ...
von ausgehend die zahl soll das geburtsjahr symbolisieren versteh ich die fragen eigentlich nicht

WENN man sich schon selbst ausdenkt : hey ich will info studieren ... dann sollte man zumindest in der schule in diesem kurs recht gut gewesen sein
und sich auch selbst mal ein bisschen damit aus ein ander zu setzen


alleine schon der punkt : "-1 ... was ist das ?" zeigt schon das dir ganz einfach extremste elementarste grundlagen der digitalen datenverarbeitung fehlen ...
das hat NICHTS mit java zu tun ... oder gar mit programmieren ... sondern einfach damit wie so eine kiste die sich "PC" nennt im inneren funktioniert ...

und ohne dieses basis-wissen willst du info studieren ? viel spaß
deine erfolgs-chancen rechne ich mir bei diesem aktuellen wissesnstand und dieser aktuellen einstellung sich nicht mal 2 minuten zeit zu nehmen und google und wikipedia zu fragen und lieber gleich erstmal im nächst schlechten forum noch n thread zu nem thema auf zu reißen was jedes jahr unzählige immer wieder tun nicht wirklich groß aus

glaub mir, man sieht es hier und auch überall auf der welt immer wieder das genau solche leute die sich selbst viel zu sehr überschätzen und sich selbst ziele setzen von denen selbst außenstehende vorher wissen das diese SO nie erreicht werden können einfach extrem, und entschuldige bitte den ausdruck, aber es dient der bildlichen veranschaulichung, auf die große klappe fallen die sie in diese situation gebracht hat



um jetzt aber mal wieder zum thema zu kommen

es gibt gewisse datentypen, diese sind heutzutage normalerweise die ganzzahltypen Byte, Short, Char, Int und Long sowie die beiden fließkommazahltypen Float und Double

diese sog. Primitiven Datentypen haben gewisse Wertebereiche, die angeben was die bit-kombinationen letztendlich bedeuten

bei java ist es so das es grundsätzlich nur sog. vorzeichenbehaftete datentypen gibt, die also immer N-Bit -1 zum darstellen des wertes haben und 1 Bit um anzuzeigen ob die zahl positiv oder negativ ist


dein datentyp ist INT
INT hat in java den wertebereich von (-(2^31)) bis ((2^31)-1)
also von -2147483648 bis +2147483647

und nun beginnen wir mal zu zählen

00000000 00000000 00000000 00000000 = 0
00000000 00000000 00000000 00000001 = 1
00000000 00000000 00000000 00000010 = 2
...
01111111 11111111 11111111 11111110 = 2147483646
01111111 11111111 11111111 11111111 = 2147483647
10000000 00000000 00000000 00000000 = -2147483648
10000000 00000000 00000000 00000001 = -2147483647
...
11111111 11111111 11111111 11111110 = -2
11111111 11111111 11111111 11111111 = -1


und ... AHH ... was erkennen wir : -1 ist es also wenn alle bits bei einem vorzeichenbehafteten (signed) datentyp 1 sind
und was wissen wir aus der umrechnung BIN -> HEX ? richtig ! das wenn 4 Bits in folge 1 sind ein F kommt

also ergibt

-1 = 11111111 11111111 11111111 11111111 = 0x FF FF FF FF




so ... und den rest machst du jetzt bitte mit hilfe von google und wikipedia alleine

 

[DrZoidberg]

Integer Variablen werden im Zweierkomplement gespeichert
Zweierkomplement ? Wikipedia
Das heisst also -1 ist gleich 0xFFFFFFFF
Der Windows Taschenrechner hat übrigens auch einen "Programmierer - Modus", der da ganz nützlich sein kann.
Es ist für solche Aufgaben sehr hilfreich, wenn man weiss, wie man zwischen Binär und Hexadezimal sehr schnell umrechen kann. Und zwar entsprechen jeweils 4 bit einer Hex Ziffer.
Also z.B. 1010 = A, 1011 = B, 1100 = C, 1101 = D

Hast du jetzt die Zahl 0xABCD, dann wandelst du die einfach Ziffer für Ziffer um.
Also 0xABCD = 1010 1011 1100 1101

Du musst bei dieser Aufgabe im Grunde gar nichts rechen.
z.B. (b << 16) ^ (b >> 16)
Da 16 bit gleich 4 Hex Ziffern entsprechen, musst du die Hex Darstellung der Zahl einfach nur um 4 Ziffern verschieben.
Also 0xAFFE0000 ^ 0x00001234 = 0xAFFE1234
Dabei ist noch zu beachten, dass beim rechts-schieben von negativen Zahlen die linken bits mit 1 aufgefüllt werden, um das Vorzeichen nicht zu verändern, was hier aber nicht zum Tragen kommt, da 0x1234AFFE positiv ist.
Mit einer negativen Zahl könnte das z.B. so aussehen
0xAFFE1234 >> 16 = 0xFFFFAFFE

^ steht für XOR, 1 ^ 1 = 0, 0 ^ 0 = 0, 1 ^ 0 = 1, 0 ^ 1 = 1
D.h. Wenn beide bits gleich sind, kommt 0 raus, wenn sie verschieden sind, kommt 1 raus.