Java de travail avec les bits

Question

Permettez-moi de commencer par dire que je ne l'ai jamais vraiment travaillé avec des morceaux avant dans la programmation. J'ai un objet qui peut être dans 3 états et je veux représenter ces états en utilisant un réseau de 3 bits.
Par exemple:
J'ai une voiture de course et il peut aller de l'avant, à gauche, et à droite sur un stand encore les bits serait
000 Si la voiture se déplaçait en avant les bits seraient 010 si l'avant et à gauche ce serait 110 etc ...
Comment puis-je régler les bits et comment pourrais-je les relire pour obtenir les valeurs?

Answer 1

Si la taille et la vitesse est importante, utilisez bits dans un octet. (Lire les liens affichés dans l'autre réponse car il y a des complications non évidentes lors de l'utilisation et de coulée signé types de données.)

Ce code pour les vitesses:. Pied gauche, left_forward, avant, right_forward, et à droite

public class Moo {

final static byte FORWARD = 0x1; // 00000001
final static byte LEFT     =0x2; // 00000010
final static byte RIGHT    =0x4; // 00000100

/**
 * @param args
 */
public static void main(String[] args) {

    byte direction1 = FORWARD|LEFT;  // 00000011
    byte direction2 = FORWARD|RIGHT; // 00000101
    byte direction3 = FORWARD|RIGHT|LEFT; // 00000111

    byte direction4 = 0;

    // someting happens:
    direction4 |= FORWARD;
    // someting happens again.
    direction4 |= LEFT;

    System.out.printf("%x: %s\n", direction1, dirString(direction1));
    System.out.printf("%x: %s\n", direction2, dirString(direction2));
    System.out.printf("%x: %s\n", direction3, dirString(direction3));
    System.out.printf("%x: %s\n", direction4, dirString(direction4));


}

public static String dirString( byte direction) {
    StringBuilder b = new StringBuilder("Going ");

    if( (direction & FORWARD) > 0){
        b.append("forward ");
    }

    if( (direction & RIGHT) > 0){
        b.append("turning right ");
    }
    if( (direction & LEFT) > 0){
        b.append("turning left ");
    }
    if( (direction &( LEFT|RIGHT)) == (LEFT|RIGHT)){
        b.append(" (conflicting)");
    }

    return b.toString();
}

}

Sortie:

3: Going forward turning left 
5: Going forward turning right 
7: Going forward turning right turning left  (conflicting)
3: Going forward turning left 

Notez également que gauche et droite est mutuellement exclusive, donc il est possible de créer une combinaison illégale. (7 = 111)

Si vous avez réellement voulu dire qu'une chose ne peut se déplacer à gauche, AVANT ou à droite, alors vous ne avez pas besoin, drapeaux seulement énumérations.

Cette énumération est possible de transporter en seulement deux bits.

    enum Direction{
    NONE, FORWARD, RIGHT, LEFT;

}


Direction dir = Direction.FORWARD;
byte enc = (byte) dir.ordinal();

Les deux derniers bits enc deviendront:

00 : none  
01 : forward;
10 : right
11 : left

Answer 2

Je suggère d'utiliser BitSet ainsi que de ENUM

enum State { LEFT, RIGHT, FORWARD,STAND_STILL}

BitSet stat=new BitSet(4);

void setLeft() // and so on for each state
{
 stat.set(State.LEFT);
}
boolean isLeft()
{
 stat.get(State.LEFT);
}
void reset() //reset function to reset the state
{
  stat.clear();
}

Answer 3

Le moins vous aurez besoin de stocker ces trois bits est l'un byte.

Lire ce tutoriel sur les opérateurs binaires pour commencer.

Edit:. cette page sur les masques de bits peut également être très utile

Answer 4

Vous dites que trois états, mais vous avez bien six: avant, en avant-gauche, en avant-droite, à gauche, à droite, stand-encore. À moins que votre voiture de course ne se déplace pas sur le côté ofcourse, vous avez quatre.

Vous devriez vraiment utiliser un ENUM pour cela:

enum State { FORWARD, FORWARD_LEFT, FORWARD_RIGHT, STAND_STILL }

Depuis la gauche, à droite et à terme sont mutuellement exclusifs, ce n'est pas un très bon moyen pour un programme tripoter peu. Vous aurez dans toutes sortes de problèmes de cohérence.

Answer 5

Dans java.util il y a une classe appelée BitSet qui rend la manipulation de bits très simple.

Dans votre cas, vous pouvez créer un BitSet de taille 3, puis utiliser les méthodes get () et set () pour définir un contrôle des bits.