Comment puis-je inverser des bits d'un octet non signé en Java?

Je suis en train d'écrire un décodeur pour un type très simple de chiffrement. Les nombres de 0 à 255 sont entrés via un Scanner, les bits sont inversés, et puis converti en caractère et de l'imprimé.

Par exemple, le nombre de 178 devraient se convertir à la lettre "M".

178 est 10110010.

En inversant tous les bits devrait donner 01001101, qui est de 77 ou "M" comme un caractère.

Le principal problème que j'ai c'est que, aussi loin que je peux dire, Java ne supporte pas d'octets non signés. J'ai pu lire des valeurs comme un int ou un court, mais alors les valeurs doivent être hors tension lors de la conversion en raison de l'extra. Idéalement, je pouvais au niveau du bit opérateur de complément, mais je pense que je vais finir par avoir des valeurs négatives si je fais cela avec des nombres signés. Des idées sur comment je dois aborder cette?

source d'informationauteur DavidKelly999

  1. 13

    Je voudrais simplement utiliser ceux de compléter et de se débarrasser des autres bits en utilisant le binaire et le.

    public class Conv {
    public static void main(String[] args) {
        int val = 178;
        val = ~val & 0xff;
        System.out.println((char) val);
    }
}
  2. 10
    ~n & 0xff

    ~ ne le complément et les convertit implicitement à un nombre entier comme tous les numériques les opérations faites, alors & 0xff masque tout, sauf la partie inférieure 8 bits pour obtenir la valeur non signée, de nouveau comme un entier.

    J'ai lu votre question différemment, d'inverser l'ordre à la place des valeurs des bits, et ce fut la réponse.

    Vous pouvez utiliser Integer.reverse() (non testé):

    Integer.reverse(n << 24) & 0xff
  3. 4

    Des opérations bit à bit en Java sont définis pour int il est donc logique de travailler avec int plutôt que byte. Vous pouvez utiliser Scanner.nextIntplutôt que de Scanner.nextByte. Vous devez valider la saisie de l'utilisateur de s'assurer que tous les entiers sont entrés dans la plage de 0 à 255 et afficher un message d'erreur approprié si un numéro est rencontré.

    Une fois que vous avez le numéro stocké dans un entier puis de retourner le moins significatif de 8 bits, vous pouvez XOR avec 0xff. Cela devrait fonctionner comme prévu pour toutes les entrées entre 0 et 255:

    x ^= 0xff;

    Exemple:

    String input = "178 0 255";
Scanner s = new Scanner(input);
while (s.hasNextInt()) {
    int x = s.nextInt();
    if (x < 0 || x > 255) {
        System.err.println("Not in range 0-255: " + x);
    } else {
        x ^= 0xff;
        System.out.println(x);
    }
}

    Résultat:

    77
255
0
  4. 1

    Si Java prend en charge ce, vous avez pu lire dans un plus grand type, au niveau du bit-compliment, puis masque de bits les indésirables bits.

    int x = [your byte];
x = ~x & 0xFF;
  5. 0

    La façon la plus simple pour ce faire est de trois étapes:

    1. Lire la valeur d'un int (32 bits de java). Il peut se lire comme négatif, mais nous ne se soucient que du bas de 8 bits, de toute façon. int i = scanner.nextByte();
    2. Ne l'inversion comme un int en utilisant les opérateurs sur les bits (comme vous le dites vous donnera 1s comme ordre élevé de bits: i = ~i;
    3. Perdre les ordre élevé de bits avec un ET logique: i = i & 0xFF;

    Puis il suffit d'utiliser le résultat comme un personnage (qui est en fait 16 bits de java, mais nous les utiliserons seulement 8 d'entre eux): 

    char c=(char)a;
System.out.println(c);

    Tous ensemble:

    int i = scanner.nextByte(); //change this to nextInt() depending on file format
i = ~i;
i = i & 0xFF;
char c=(char)a;
System.out.println(c);
  6. 0
    private byte reverseBitsByte(byte x)
{
    int intSize = 8;

    byte y = 0;
    for (int position = intSize - 1; position >= 0; position--)
    {
        y += ((x & 1) << position);
        x >>= 1;
    }
    return y;
}
  7. -1

    Voici Java octets, triés par représentation binaire (à partir de 00000000 à 11111111):

    0, 1, 2, .., 126, 127, -128, -127, .., -2, -1

    00000000 est 0, 11111111 est -1

    Inversé 0 -1, inversé 1 est de -2, ..., inversé -128 à 127.
    Donc si vous voulez inverser les bits de Java, vous devriez obtenir votre octet de signe opposé et soustraire un:

    byte myByte = 123;
byte myInvertedByte = -myByte-1;