Einzelne Bits umwandeln und prüfen

[ocsme]

Guten Tag zusammen,

ich möchte ein Programm schreiben was ein int Wert in die Binärdarstellung umwandelt und dann z. B. das fünfte Bit invertiert und den modifizierten Wert wieder ausgibt.
Das ganze habe ich auch soweit hin bekommen doch ist es wirklich so umständlich oder gibt es dort wieder geeignete Methoden? Ich habe auch schon gegooglet und nicht wirklich viel gefunden. Es gibt einige Foren wo ähnliches gemacht wird die machen das mit den Operatoren ^ & | doch wie funktioniert das denn dann?
Und bei meinem Lösungsansatz mit String würde das nicht Funktionieren!

int a = 1000;
        String tmp=Integer.toBinaryString(a);
       
        //------------ falls String kleiner ist als 5 Stellen -->>>>>>>>
        for(int i=0;i<tmp.length()&&tmp.length()<5;i++)
            tmp="0"+tmp;
       
        char c=tmp.charAt(tmp.length()-5);
        if(c=='0')
            c='1';
        else c='0';
        char[] ch = tmp.toCharArray();
        for(int i=0;i<tmp.length();i++) {
            if(i==5)
                ch[i]=c;
            System.out.print(ch[i]);
        }

Wieso lässt sich das char[] auch nicht mit einer toString methode in ein String umwandeln die muss man selbst bauen Ich stehe heute irgendwie extrem neben mir denn ich hab schon so viel mit Strings und char[] s gemacht und jetzt klappt wieder nix

LG

 

[Robat]

Du kannst mit new String(char[]) einen neuen String aus einem char Array machen

Es ist auch nicht nötig die Zahl erst explizit in die binäre String Repräsentation umzuwandeln.
number = number ^ (1 << (k-1)) tuts auch wenn du das k-te Bit ( für k 1-basiert) in number toggeln willst

Edit: mit String Builder geht's theoretisch auch

StringBuilder builder = new StringBuilder(Integer.toBinaryString(a));
builder.setCharAt(builder.charAt(5) == '0' ? '1' : '0', 5);

Edit#2: Bitset kannst du dir auch mal anschauen

 

[ocsme]

Dank dir das mit dem new String(char[]) ist mir neu wieder was nettes gelernt Danke
Mit StringBuilder hatte ich es auch fast so hin bekommen Finde damit geht es viel Leichter als mit der unveränderlichen Klasse String

Doch was ich momentan noch nicht so ganz verstehe ist mal wieder das hier:

Es ist auch nicht nötig die Zahl erst explizit in die binäre String Repräsentation umzuwandeln.
number = number ^ (1 << (k-1)) tuts auch wenn du das k-te Bit ( für k 1-basiert) in number toggeln wills

Mal anschauen vielleicht komme ich noch dahinter

 

[Robat]

Schau einfach mal nach binären Operationen und lies dich ein. Gibt genug dazu

 

[ocsme]

Nochmals Danke werde ich tun
Es klappt zwar auch so doch das ist finde ich viel zu umständlich! Hier noch eine Methode wie man es ganz nett zu String umwandelt doch dann fehlt immer noch das Überprüfen der einzelnen Bits. Wenn ich dann sage ich hätte gerne das 2,4,6 bit Invertiert brauche ich ja wieder char[] muss durchlaufen etc. ....

public static string intToBinary(int n)
{
    string s = "";
    while (n > 0)
    {
        s =  ( (n % 2 ) == 0 ? "0" : "1") +s;
        n = n / 2;
    }
    return s;
}

 

[Xyz1]

Hier noch eine Methode wie man es ganz nett zu String umwandelt doch dann fehlt immer noch das Überprüfen der einzelnen Bits

Also das umwandeln sieht richtig aus, was meinst Du denn nochmal mit Überprüfen?

 

[ocsme]

horstiii2 ich wollte einen Integer Wert in Binär Umwandeln und dann verschiedene Bits wie z. B. das 2,3,5 Invertieren können. Dann wieder ein Integer Wert zurück geben
Das ganze habe ich jetzt über String "gelöst!". Doch es ist denke ich weder elegant noch sicherlich nicht sehr effizient deswegen muss ich mir die binären Operationen mal anschauen Das habe ich noch nicht so ganz verstanden!

LG

 

[Xyz1]

Ok lasse Dir Zeit alles zu verstehen. lg

 

[ocsme]

Guten Tag,
so ich habe es nun korrekt mit String gelöst:

    public static int getBinaryInverse(int a) {
        String tmp=Integer.toBinaryString(a);
        //wenn Zahl kleiner ist als 5 Stellen!
        for(int i=0;tmp.length()<5 && i<tmp.length();i++)
            tmp="0"+tmp;
        char c=tmp.charAt(tmp.length()-5);
        c=(c=='0')?'1':'0';
        char[] ch = tmp.toCharArray();
        for(int i=0;i<tmp.length();i++)
            if(i==tmp.length()-5)
                ch[i]=c;
        String erg=new String(ch);
        int ergebnis=Integer.parseInt(erg,2);
        return ergebnis;
    }

Desweiteren habe ich mir die Binär Operatoren angeschaut und hätte eine Idee wie man das lösen könnte mein Problem ist nur ich hab keine Ahnung wie ich erkennen kann ob das 5te Bit gesetzt ist?
Meine Idee wäre ich habe eine Int zahl = 32 Bit also Hexadezimal ja 8 Ziffern.
Man nimmt die Zahl und negiert diese dann hätten wir 8 inverse Ziffern.
Nun müsste man das 5 Bit erkennen das ist:
FFFFFFEF denke ich doch wie macht man dann sowas? Und vor allem wie Invertiert man dieses dann wieder.
Ich denke wenn man das richtig hin bekommt wäre das sicherlich nur ein 2Zeiler
Doch ich bekomme es nicht hin!
LG

 

[ocsme]

PS: Ich weis das man die letzten Zeilen in eine return machen kann

//        String erg=new String(ch);
//        int ergebnis=Integer.parseInt(erg,2);
        return Integer.parseInt(new String(ch),2);

Mir ging es nur um die Übersicht
LG

 

[Robat]

Nur damit ich dich richtig verstehe: Du willst von einer Zahl einfach nur das 5. Bit invertieren?

 

[Robat]

mein Problem ist nur ich hab keine Ahnung wie ich erkennen kann ob das 5te Bit gesetzt ist?

Das geht relativ einfach (bit ist 1-based)

public static boolean isNthBitSet(int number, int bit) {
    return ((number >> (bit-1)) & 1) == 1;
}

Erklärung am Beispiel 10 und zweitem Bit:
>> ist der Shift-Right Operator. Damit werden alle Bits um n Stellen nach rechts verschoben und links mit 0 aufgefüllt.
Die Bits von number werden also (bit-1) Stellen nach rechts geschoben - in dem Fall 2 - 1 = 1

number = 10 = 1010(bin)
number >> (2-1) --> 1010 >> 1  -> 0101

Nun steht unser gesuchtes Bit ganz rechts. Jetzt wollen wir herausfinden, ob es 1 oder 0 ist. Dazu kann man den & (AND) - Operator benutzen. Die Wertetabelle für den Operator sieht wie folgt aus:

0 & 0 = 0
1 & 0 = 0
0 & 1 = 0
1 & 1 = 1

Man sieht also, ein "verunden" mit 1 gibt nur 1 zurück, wenn das Bit gesetzt, also 1, ist.

number = 10 = 1010(bin)
number >> (2-1) --> 1010 >> 1  -> 0101

  0101
& 0001
-------
  0001

Am Ende prüfen wir, ob das Ergebnis 1 ist. Falls ja, wissen wir, dass das Bit gesetzt ist.

 

[ocsme]

Das habe ich verstanden
Es gibt in Java keine Möglichkeit ein einzelnes Bit direkt zu manipulieren oder? Denn jetzt wissen wir das dieses Bit gesetzt ist sehr schön
Nachdem wir geprüft haben das dieses Bit gesetzt ist möchte ich es jetzt manipulieren wenn es gesetzt ist Invertiere es
Muss ich das ganze Teil wieder in ein String umwandeln? *hoffentlich nicht!*
Denn ich muss ja irgendwie an diese Stelle vorrücken das bedeutet etwas verschieben wenn ich es raus schiebe ist es verloren oder kann ich es in eine neue Variable schieben das wäre ja echt witzig und ab den stellen die man ändern möchte kommen die änderungen die dann weiter in die neue Variable geschoben werden

LG

 

[ocsme]

Nur damit ich dich richtig verstehe: Du willst von einer Zahl einfach nur das 5. Bit invertieren?

Nicht nur das Bit invertieren sondern die Zahl (Integer) wieder komplett zurück geben "geht so was überhaupt?!"

 

[Robat]

Es gibt in Java keine Möglichkeit ein einzelnes Bit direkt zu manipulieren oder?

Doch. Um das ganze abzukürzen hier gleich mal eine Hand von gängigen Operationen

public static int clearNthBit(int number, int bit) {
    return (number & ~(1 << (bit-1)));
}

public static int setNthBit(int number, int bit) {
    return (number | (1 << (bit-1)));
}

public static int toggleNthBit(int number, int bit) {
    return (number ^ (1 << (bit - 1)));
}

public static boolean isNthBitSet(int number, int bit) {
    return ((number >> (bit-1)) & 1) == 1;
}

 

[ocsme]

wie kann ich dir den nur dafür DANKEN
das ist ja der Wahnsinn
so klappt das ganze wie ich es mir vorstelle

    int number = 16;
        int bit = 5;      
        if(isNthBitSet(number,bit))
            System.out.println(toggleNthBit(number,bit));

Das ist ja super Lieb
Danke

PS: die Methoden zu verstehen ist nicht das Problem darauf zu kommen ist die Hürde! Da muss ich mich mehr mit auseinander Setzen, die Sache ist nur das ich auch so schon genug zu tun habe da kommt man nicht hinterher soviel zu Lernen !!

 

[Robat]

Mir würde es schon reichen, wenn du mir versprichst, dass du dir den Code anschaust und versuchst ihn zu verstehen, anstatt ihn nur zu kopieren

 

[ocsme]

Ich schaue mir die Methoden gerade an!
Was ich nicht so ganz verstehe ist: Wenn ich eine Zahl habe sagen wir mal BinärDarstellung: 10101 wenn ich nun toggle also von links n bits (n=5) einschiebe also n-1 = 4
Dann würde doch dort stehen 10101 ^ 01111 oder etwa nicht? Doch dann würde was sehr komisches raus kommen 11010.

 

[Robat]

Nicht ganz. Schauen wir uns die Zeile mal Stück für Stück an.
bit - 1 = 4 ... das hattest du bereits richtig erkannt.
<< ist der Left-Shift Operator ... die Bits werden also alle um n Stellen nach links geschoben und es wird von rechts mit Nullen aufgefüllt.

1 << 4 = 1000

^ ist der XOR-Operator .. die Wertetabelle für diesen Operator ist wie folgt

0 ^ 0  = 0
1 ^ 0 = 1
0 ^ 1 = 1
1 ^ 1 = 0

Es kommt also immer nur 1 heraus, wenn genau einer der beiden Eingaben 1 ist.

number ^ (1 << 4)
number ^ 10000

number = 10101
  10101
^ 10000
--------
  00101

 

[ocsme]

Wieso steht jetzt oben 10000 also die 1 an der 5ten Stelle wenn ich doch nur um 4 Stellen schiebe?

1 << 4 = 1000

number ^ (1 << 4)
number ^ 1000

 

[Robat]

Also 1 << 4 sagt ja verschiebe die Bits von 1 um 4 Stellen. 1 Binär dargestellt ist 1. Man könnte auch sagen: Füge auf der rechten Seite 4 Nullen an.

1. Verschiebung: 10
2. Verschiebung: 100
3. Verschiebung: 1000
4. Verschiebung: 10000

 

[ocsme]

Ja ist mir gerade auch aufgefallen ich hatte es mir so veranschaulicht!

        System.out.println(Integer.toBinaryString((1<<0)));
        System.out.println(Integer.toBinaryString((1<<1)));
        System.out.println(Integer.toBinaryString((1<<2)));
        System.out.println(Integer.toBinaryString((1<<3)));
        System.out.println(Integer.toBinaryString((1<<4)));
        System.out.println(Integer.toBinaryString((1<<5)));

Ausgabe:

1
10
100
1000
10000
100000

Schiebe an Position 5 (zähle wie bei Array(wie der Informatiker) ab 0 beginnent!) und füge von rechts kommend nullen ein

 

[mihe7]

>> ist der Shift-Right Operator. Damit werden alle Bits um n Stellen nach rechts verschoben und links mit 0 aufgefüllt.

Nö. Das macht der >>> Operator

 

[Xyz1]

zähle wie bei Array(wie der Informatiker) ab 0 beginnent

Oh das ist Definitionssache, aber zumeist starten Indizes mit 0 ja. Also sind 0 beginnend.
Dadurch kann der < Operator eingesetzt werden - und wohl theoretisch die Anzahl der Maschinenzyklen verringert werden.