Was ist der beste Weg, Java-Codierung für diese Art von Byte-Level-Operationen zu tun?

Question

Ich lese über einige Probleme, die über Optimierungsansätze sind.
In dem Problem, wie Sie Zahlen in einem bestimmten Bereich sortieren, besteht die Lösung darin, eine Bitmap zu verwenden. Und wenn eine Nummer z.B. Verwenden Sie bis zu 10 Mal halbe Bytes zum Abbilden der Zahlen und als Zähler die Anzahl der Vorkommen.
Das Konzept verstehe ich gut. Mein Problem ist es, dies in Java auf einfache Weise zu implementieren.

Ich bin auf Bit-Operationen fest.
Zum Beispiel für den ersten Teil von 1 die Zähler zu erhöhen, was könnte ich darüber nachdenken, war:

Suchen Sie die Byte
Z.B. bitValue[i]
Dann tun byte tmp = bitValue[i] & 0x0F, um die unteren Bits zu erhalten (wenn der Zähler der niedrige Zähler ist).
Dann tmp = tmp + 1 um 1 inkrementieren.
Dann tun bitValue[i] >> 2, um Low-End-Bits zu löschen und dann bitValue[i] <<2 wiederherzustellen. Jetzt haben wir die gleichen hohen Bits wie die ursprünglichen und die niedrigen Bits.
Dann bitValue[i] |= tmp setzen, um niedrige Bits zu setzen.
Jetzt bitValue hat der Low-Bit-Zähler um 1 inkrementiert. Richtig?

Für das obere Bit wäre es der gleiche Prozess, aber für die oberen Bits.

Dann wenn ich überprüfen muss, wie ist die Nummer des Zählers.

Ich dachte Bitmasken verwenden:
0x00x10x2 etc und verwenden OR zu überprüfen, was der aktuelle Zählernummer ist.

All diese scheinen zu kompliziert zu sein. Bin ich auf dem richtigen Weg? Wie werden diese Operationen am besten in der Java-Codierung angesprochen?

Jede Eingabe, Anleitung dazu ist sehr willkommen.

Answer 1

Sie sind definitiv auf dem richtigen Weg. Hier ist ein ausgefüllter Code, der die ersten vier Bits oder die zweiten vier Bits eines int um einen bestimmten Betrag erhöht.

Beachten Sie, dass ich hier int statt byte verwenden. Selbst wenn Ihre Daten eine byte sind, ist es normalerweise viel einfacher, damit als int zu arbeiten. Dies liegt daran, java bitwise operators wie | und & und << zurück int. Es ist also am einfachsten, mit deinen Daten als int zu arbeiten und dann zurückzuschlagen, sobald du all dein Bit Twiddling gemacht hast.

Wenn Sie einen großen Datenblock (möglicherweise mehr als nur die beiden genannten Leistungsindikatoren) auf einer Bit-Ebene behandeln möchten, sollten Sie sich einen Blick auf BitSet werfen.

public class Test { 
    public static void main(String[] args) 
    { 
     int counter = 0; 

     // increment the low bits by 3 and high bits by 2 
     counter = addLowBits(counter, 3); 
     counter = addHighBits(counter, 2); 

     // print the hex string to verify 
     System.out.println(Integer.toHexString(counter)); 
     System.out.println("Low Counter: " + (counter & 0x0F)); 
     System.out.println("High Counter: " + ((counter & 0xF0) >> 4)); 
    } 

    public static int addLowBits(int counter, int increment) 
    { 
     // get the low bits 
     int low = counter & 0x0F; 

     // increment by 1 
     low = low + increment; 

     // mask the high bits and insert new low bits 
     counter = (counter & 0xF0) | low; 

     return counter; 
    } 

    public static int addHighBits(int counter, int increment) 
    { 
     // now get high bits 
     int high = (counter & 0xF0) >> 4; 

     // increment by 1 
     high = high + increment; 

     // mask the low bits and insert new high bits 
     counter = (counter & 0x0F) | (high << 4); 

     return counter; 
    } 
}