Java de Trabajo con los bits

Question

Déjame empezar diciendo que en realidad nunca he trabajado con los bits antes de la programación. Tengo un objeto que puede estar en 3 estados y quiero representar esos estados utilizando una matriz de 3 bits.
Por ejemplo:
Tengo un coche de carreras y que puedo seguir adelante, izquierda y derecha en una posición todavía los bits sería 000 Euros | Si el coche se movía hacia adelante los bits serían 010 si hacia adelante y hacia la izquierda sería 110, etc ...
¿Cómo iba a establecer los bits y cómo podría volver a leer para obtener los valores?

Answer 1

Si el tamaño y la velocidad es importante, utilizar bits en un byte. (Leer los enlaces publicados en la otra respuesta, ya que hay complicaciones no evidentes cuando se utilizan los tipos de datos y que emitan firmados.)

Este codifica para las velocidades:. Soporte, izquierda, left_forward, hacia adelante, right_forward, ya la derecha

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

}

Salida:

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

Tenga en cuenta también que la izquierda y la derecha es mutuamente excluyentes, por lo que su posible crear una combinación ilegal. (7 = 111)

Si en realidad quería decir que una cosa sólo puede mover hacia la izquierda, derecha, FORWARD o banderas, entonces no es necesario, sólo enumeraciones.

Esta enumeración es posible el transporte en sólo dos bits.

    enum Direction{
    NONE, FORWARD, RIGHT, LEFT;

}


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

Los dos últimos bits en enc se convertirán en:

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

Answer 2

Se recomienda usar BitSet junto con la enumeración

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

Lo menos que necesita para almacenar estos tres bits es uno byte.

este tutorial a los operadores bit a bit para empezar.

Editar:. esta página de máscaras de bits también puede ser muy útil

Answer 4

decir tres estados, pero en realidad tengo seis: adelante, adelante, izquierda, adelante derecha, izquierda, derecha, de pie inmóvil. A menos que su coche de carreras no se mueve de lado por supuesto, entonces usted tiene cuatro.

Se debe utilizar realmente una enumeración para esto:

enum State { FORWARD, FORWARD_LEFT, FORWARD_RIGHT, STAND_STILL }

Desde la izquierda, derecha y hacia adelante son mutuamente excluyentes, esto no es una muy buena opción para un programa de bits tocar el violín. Usted obtendrá en todo tipo de problemas de coherencia.

Answer 5

En java.util hay una clase llamada BitSet que hace que la manipulación de bits muy simple.

En el caso de que podría crear un BitSet de tamaño 3 y luego usar el get () y set () para establecer un control de los bits.