Opérations de déplacement de bits sur un tableau d'octets en Java

Je crois que vous pouvez le faire à l'aide de java.les mathématiques.BigInteger qui prend en charge se déplace sur arbitrairement grand nombre. Cela a l'avantage de la simplicité, mais l'inconvénient de ne pas rembourrage en original octets taille de la matrice, c'est à dire d'entrée pourrait être de 16 octets de sortie mais peut être seulement de 10 etc, demandant plus de logique.

BigInteger approche

byte [] array = new byte[]{0x7F,0x11,0x22,0x33,0x44,0x55,0x66,0x77};

//create from array
BigInteger bigInt = new BigInteger(array);

//shift
BigInteger shiftInt = bigInt.shiftRight(4);

//back to array
byte [] shifted = shiftInt.toByteArray();

//print it as hex
for (byte b : shifted) {
    System.out.print(String.format("%x", b));
}

Sortie

7f1122334455667   <== shifted 4 to the right. Looks OK

Long de manipulation

Je ne sais pas pourquoi vous voulez le faire comme rotateRight (), car cela rend la vie plus difficile, vous avez à vide à les bits qui apparaissent à gauche dans K1 etc. Vous seriez mieux avec l'aide de décalage de l'OMI, comme décrit ci-dessous. J'ai utilisé un décalage de 20 divisible par 4 donc plus facile de voir les amuse-gueules de se déplacer dans la sortie.

1) Utilisation ByteBuffer pour former deux longs à partir de 16 octets du tableau

byte[] array = { 0x00, 0x00, 0x11, 0x11, 0x22, 0x22, 0x33, 0x33, 0x44, 0x44, 0x55, 0x55, 0x66, 0x66, 0x77, 0x77 };
ByteBuffer buffer = ByteBuffer.wrap(array);
long k1 = buffer.getLong();
long k2 = buffer.getLong();

2) Maj chaque long de n bits vers la droite

int n = 20;

long k1Shift = k1 >> n;
long k2Shift = k2 >> n;

System.out.println(String.format("%016x => %016x", k1, k1Shift));
System.out.println(String.format("%016x => %016x", k2, k2Shift));

0000111122223333 => 0000000001111222
4444555566667777 => 0000044445555666

Déterminer les bits de k1 qui "s'est retrouvé au large de la pointe"

long k1CarryBits = (k1 << (64 - n));
System.out.println(String.format("%016x => %016x", k1, k1CarryBits));

0000111122223333 => 2333300000000000

Rejoindre le K1 transporter des bits sur K2 sur la droite

long k2WithCarray = k2Shift | k1CarryBits;
System.out.println(String.format("%016x => %016x", k2Shift, k2WithCarray));

0000044445555666 => 2333344445555666

Écrire les deux longs en arrière dans un ByteBuffer et de l'extrait de comme un tableau d'octets

buffer.position(0);
buffer.putLong(k1Shift);
buffer.putLong(k2WithCarray);
for (byte each : buffer.array()) {
    System.out.print(Long.toHexString(each));
}

000011112222333344445555666

OriginalL'auteur Adam

1. Manuellement en œuvre

Ici sont à gauche et à droite de décalage de la mise en œuvre sans l'aide de BigInteger (ie. sans la création d'une copie du tableau d'entrée) et avec unsigned décalage à droite (BigInteger prend uniquement en charge l'arithmétique des décalages de cours)

Décalage à gauche <<

/**
 * Light shift of whole byte array by shiftBitCount bits. 
 * This method will alter the input byte array.
 */
static byte[] shiftLeft(byte[] byteArray, int shiftBitCount) {
    final int shiftMod = shiftBitCount % 8;
    final byte carryMask = (byte) ((1 << shiftMod) - 1);
    final int offsetBytes = (shiftBitCount / 8);

    int sourceIndex;
    for (int i = 0; i < byteArray.length; i++) {
        sourceIndex = i + offsetBytes;
        if (sourceIndex >= byteArray.length) {
            byteArray[i] = 0;
        } else {
            byte src = byteArray[sourceIndex];
            byte dst = (byte) (src << shiftMod);
            if (sourceIndex + 1 < byteArray.length) {
                dst |= byteArray[sourceIndex + 1] >>> (8 - shiftMod) & carryMask;
            }
            byteArray[i] = dst;
        }
    }
    return byteArray;
}

Unsigned Décalage à Droite >>>

/**
 * Unsigned/logical right shift of whole byte array by shiftBitCount bits. 
 * This method will alter the input byte array.
 */
static byte[] shiftRight(byte[] byteArray, int shiftBitCount) {
    final int shiftMod = shiftBitCount % 8;
    final byte carryMask = (byte) (0xFF << (8 - shiftMod));
    final int offsetBytes = (shiftBitCount / 8);

    int sourceIndex;
    for (int i = byteArray.length - 1; i >= 0; i--) {
        sourceIndex = i - offsetBytes;
        if (sourceIndex < 0) {
            byteArray[i] = 0;
        } else {
            byte src = byteArray[sourceIndex];
            byte dst = (byte) ((0xff & src) >>> shiftMod);
            if (sourceIndex - 1 >= 0) {
                dst |= byteArray[sourceIndex - 1] << (8 - shiftMod) & carryMask;
            }
            byteArray[i] = dst;
        }
    }
    return byteArray;
}

Utilisés dans ce classe par cette Projet.

2. À L'Aide De BigInteger

Être conscient que BigInteger en interne convertit le tableau d'octets en un int tableau[] si cela peut ne pas être le plus optimisé solution:

Arithmétique Décalage à Gauche <<:

byte[] result = new BigInteger(byteArray).shiftLeft(3).toByteArray();

Arithmétique Décalage à Droite >>:

byte[] result = new BigInteger(byteArray).shiftRight(2).toByteArray();

3. Bibliothèque Externe

À l'aide de la Octets bibliothèque java*:

Ajouter à pom.xml:

<dependency>
    <groupId>at.favre.lib</groupId>
    <artifactId>bytes</artifactId>
    <version>{latest-version}</version>
</dependency>

Exemple de Code:

Bytes b = Bytes.wrap(someByteArray);
b.leftShift(3);
b.rightShift(3);
byte[] result = b.array();

_{*Avertissement: je suis le développeur.}

OriginalL'auteur patrickf