Java trabalhando com bits

Question

Deixe -me começar dizendo que nunca trabalhei com bits antes na programação. Eu tenho um objeto que pode estar em 3 estados e quero representar esses estados usando uma matriz de 3 bits.
Por exemplo:

Eu tenho um carro de corrida e ele pode seguir em frente, à esquerda e à direita em um suporte parado, os bits seriam 000
Se o carro estivesse avançando, os bits seriam 010 se a frente e esquerda fosse 110 etc ...

Como eu definiria os bits e como eu poderia lê -los de volta para obter os valores?

Answer 1

Se o tamanho e a velocidade forem importantes, use bits em um byte. (Leia os links postados na outra resposta, pois há complicações não óbvias ao usar e fundir tipo de dados assinados.)

Isso codifica as velocidades: Stand, esquerda, esquerda_forward, para frente, direita_forward e direita.

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

}

Resultado:

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

Observe também que a esquerda e a direita é mutuamente exclusiva; portanto, é possível criar uma combinação ilegal. (7 = 111)

Se você realmente quis dizer que uma coisa só pode se mover para a esquerda, para a frente ou para a direita, não precisa de sinalizadores, apenas enumes.

Esta enumeração é possível transportar em apenas dois bits.

    enum Direction{
    NONE, FORWARD, RIGHT, LEFT;

}


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

Os dois últimos bits em enc se tornará:

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

Answer 2

Eu sugeriria usar o bitset junto com o 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

O mínimo que você precisará para armazenar esses três bits é um byte.

Ler este tutorial em operadores bitwee para começar.

Editar: esta página Em máscaras de bits também podem ser muito úteis.

Answer 4

Você diz três estados, mas na verdade você tem seis: para a frente, para a frente, para a frente, à esquerda, à direita, ficam sentados. A menos que seu carro de corrida não se mova de lado, é claro, você tem quatro.

Você realmente deveria usar um enum por esta:

enum State { FORWARD, FORWARD_LEFT, FORWARD_RIGHT, STAND_STILL }

Desde que a esquerda, a direita e a frente são mutuamente exclusivas, isso não é muito bom para um programa de acertação de bits. Você entrará em todos os tipos de problemas de consistência.

Answer 5

Em java.util, há uma aula chamada Bitset Isso torna muito simples a manipulação.

No seu caso, você pode criar um bitset do tamanho 3 e, em seguida, usar os métodos get () e set () para definir uma verificação dos bits.