zweierKompliment erzeugen

[Gast]

Hi,

ich habe eine hex-zahl (wird mit der Zeile Number zahl = Integer.valueOf(sbValue.toString(), 16); erzeugt, sbValue ist ein StringBuffer),

nun möchte ich das Zweierkomplement von zahl erzeugen, ist das irgendwie einfach in Java möglich oder muss ich mir da selber was zusammenbauen?

schönen Tag noch,

 

[Der Müde Joe]

Do it yourself.

(also wüsste da grad nix)

 

[Wildcard]

Was soll das heißen, das Zweierkomplement erzeugen?
Zahlen in Java werden (natürlich) als Zweierkomplement behandelt, aber für die Zahl selbst spielt das keine Rolle.
Was willst du also 'erzeugen'?

 

[Guest]

die einzelnen Bits von "zahl" konvertieren und 1 dazuzählen

 

[musiKk]

Ein Bit invertieren kannst du mit xor 1 (der Operator dafuer ist ^). Eins addieren ist dann trivial.

 

[SlaterB]

xor -1, oder?

public class Test
{

    public static void main(String[] args)
        throws Exception
    {

        int k = 4454;
        int kk = k ^ -1;

        p(-1);
        p(k);
        p(kk);
    }

    static void p(int x)
    {
        String st = Integer.toBinaryString(x);
        while (st.length() < 32)
        {
            st = "0" + st;
        }
        System.out.println(st);
    }
}

 

[musiKk]

Bei der -1 sind alle Bits gesetzt, das stimmt schon, aber man muss ja nicht alles vorkauen.

 

[Wildcard]

Du willst also das Zweierkomplement eines Zweierkomplements erzeugen?

 

[Guest]

habs schon, danke danke,
ich hab wie oben schon gepostet ^ 0xFF und dann +1 dazugezählt,

ich lese nämlich zahlen aus einem externen File und daher ist es notwendig 2 mal das Zweierkomplement zu machen,

schönen Feierabend noch,

 

[SlaterB]

int kk = ~k;
gibts auch noch

 

[Guest]

ihr seit ja alle embedded spezialisten, so wies aussieht.

 

[Guest]

wenn ich 0xFFFD invertiere, dann wird aus

1111 1111 1111 1101 <=> 0xFFFD 
1111 1111 1111 1111 0000 0000 0000 0010 <=> -65534

ich möchte aber nur 0000 0000 0000 0010 haben bzw. nur so viele Stellen, wie meine Hex- Zahl hat (also bei 0xFFFD -> 16 invertierte Stellen, bei 0xFEEE BCEF -> 32 invertierte Stellen)

ist da einfach zu realisieren?

 

[SlaterB]

> also bei 0xFFFD -> 16 invertierte Stellen, bei 0xFEEE BCEF -> 32 invertierte Stellen

entweder gibst du jetzt für jede der 2^32 Zeichen an wieviele Stellen es sind,
oder du erklärst die Regel, gehts z.B. nach der Position der ersten 1?

sowas kannst du ja rausfinden entweder durch String-Methoden (charAt, indexOf) oder durch Mathematik, denke an die die Vielfachen von 2: 2^0 = 1, 2^5 = 32 usw.

dann nimmst du dir eine passende Bitmaske und nullst die Stellen, die du auf 0 haben willst,
z.B.

public class Test
{

    public static void main(String[] args)
        throws Exception
    {

        int k = -65534;
        int kk = k & 0xFF;

        p(-1);
        p(k);
        p(kk);
    }

    static void p(int x)
    {
        String st = Integer.toBinaryString(x);
        while (st.length() < 32)
        {
            st = "0" + st;
        }
        System.out.println(st);
    }

}

& ist ein bitweises &, was das genau macht und wie die Bitmaske aussieht kannst du ja erstmal selber überlegen