Java di lavoro con punte

Question

Vorrei iniziare dicendo che non ho mai veramente lavorato con i bit prima nella programmazione. Ho un oggetto che può essere in 3 stati e voglio rappresentare questi stati utilizzando una matrice di 3 bit.
Ad esempio:
Ho una macchina da corsa e può andare avanti, a sinistra ea destra in una posizione ancora i bit sarebbe 000
Se la macchina era in movimento in avanti le punte sarebbero 010 se in avanti e di sinistra che sarebbe stato 110 ecc ...
Come faccio a impostare i bit e come potevo li ho letto di nuovo per ottenere i valori?

Answer 1

Se la dimensione e la velocità è importante, utilizzare i bit in un byte. (Leggi i link pubblicato un altra risposta, come ci sono complicazioni, non banali, quando si utilizza e colata tipi di dati firmati.)

Questa codifica per la velocità:. Basamento, a sinistra, left_forward, in avanti, right_forward, e proprio

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();
}

}

Output:

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

Si noti inoltre che sinistra e destra è escludono a vicenda, per cui il suo possibile creare un abbinamento. (7 = 111)

Se effettivamente ha fatto sì che una cosa può muovere solo sinistra, avanti o DESTRA, bandiere, allora non ti servono, solo enumerazioni.

Questo enum è possibile trasportare in solo due bit.

    enum Direction{
    NONE, FORWARD, RIGHT, LEFT;

}


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

Gli ultimi due bit enc risulteranno:

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

Answer 2

Io suggerirei di usare BitSet insieme di 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

Il minimo è necessario memorizzare questi tre bit è uno byte.

questo tutorial su operatori bit per bit per iniziare.

Modifica:. questa pagina su maschere di bit può anche essere molto utile

Answer 4

Si dice tre stati, ma hai effettivamente ottenuto sei: avanti, avanti-sinistra, avanti a destra, sinistra, destra, stand-still. A meno che la vostra auto da corsa non si muove lateralmente naturalmente, allora hai quattro.

Si dovrebbe utilizzare un enum per questo:

enum State { FORWARD, FORWARD_LEFT, FORWARD_RIGHT, STAND_STILL }

Da sinistra, a destra e in avanti si escludono a vicenda, non si tratta di una misura molto buona per un programma di po-giocherellare. Otterrete in tutti i tipi di problemi di coerenza.

Answer 5

In java.util v'è una classe chiamata BitSet che rende la manipolazione po 'molto semplice.

Nel tuo caso si potrebbe creare un BitSet di dimensione 3 e quindi utilizzare il get () e set () per impostare un controllo i bit.