Convertir entier dans le tableau d'octets (Java)

ce qui est un moyen rapide de convertir un Integer dans un Byte Array?

par exemple 0xAABBCCDD => {AA, BB, CC, DD}

Il n'importe quel format l'résultant tableau d'octets est? Qu'allez-vous faire avec ça?

InformationsquelleAutor Buttercup | 2009-12-20

218

Ont un look à la ByteBuffer classe.
```
ByteBuffer b = ByteBuffer.allocate(4);
//b.order(ByteOrder.BIG_ENDIAN); //optional, the initial order of a byte buffer is always BIG_ENDIAN.
b.putInt(0xAABBCCDD);

byte[] result = b.array();
```
Réglage de l'octet d'ordre s'assure que result[0] == 0xAA, result[1] == 0xBB, result[2] == 0xCC et result[3] == 0xDD.

Ou sinon, vous pouvez le faire manuellement:
```
byte[] toBytes(int i)
{
  byte[] result = new byte[4];

  result[0] = (byte) (i >> 24);
  result[1] = (byte) (i >> 16);
  result[2] = (byte) (i >> 8);
  result[3] = (byte) (i /*>> 0*/);

  return result;
}
```
La ByteBuffer classe a été conçu pour de telles mains sales tâches. En fait, le privé java.nio.Bits définit ces méthodes d'assistance, qui sont utilisés par ByteBuffer.putInt():
```
private static byte int3(int x) { return (byte)(x >> 24); }
private static byte int2(int x) { return (byte)(x >> 16); }
private static byte int1(int x) { return (byte)(x >>  8); }
private static byte int0(int x) { return (byte)(x >>  0); }
```
- ce serait bien travailler si le bytebuffer est déjà là... sinon, il semble que ce serait prendre plus de temps pour faire la répartition, que d'allouer un tableau d'octets de longueur 4 et de faire le déplacement à la main... mais on parle probablement de petites différences.
- obtenir la droite d'abord, puis de profil, puis de les optimiser 😉
- Le ByteBuffer instance peut être mise en cache; et, en interne, c'est sûrement mis en œuvre avec le décalage et le masquage de toute façon.
- C'est une parfaitement bien de répondre. Notez que big-endian est spécifié par défaut, et les méthodes sont "chaînage", et la position argument est facultatif, donc tout se réduit à: byte[] résultat = ByteBuffer.allouer(4).putInt(0xAABBCCDD).array(); bien sûr, si vous êtes en train de faire cela à plusieurs reprises et la concaténation de tous les résultats de l'ensemble (ce qui est fréquent lorsque vous êtes en train de faire ce genre de chose), d'allouer un tampon unique et à plusieurs reprises putFoo() toutes les choses qui vous avez besoin, il va garder la trace de l'offset comme vous allez. C'est vraiment un outil très utile en classe.
- que faut-il apporter sur les types signés?
- Si vous prévoyez sur l'utilisation que ByteBuffer dans la suite NIO de l'écriture des opérations, vous aurez besoin de rewind il. Sinon, vous ne pas écrire n'importe quoi! (Été là, fait cela!)
- Pour qui ne le sait pas. Le putInt toujours écrire 4 octets, quelle que soit la taille de l'entrée de type entier est. Si vous voulez seulement 2 octets, utilisez putShort, etc ...
- pourquoi serait-il question? Selon stackoverflow.com/a/2458526/5276890 un tel casting serait le premier de 8 bits et ignorer tous les autres. Donc, tous les autres bits ajoutés par >> ou >>> n'aurait pas d'importance.
- Vous êtes correct.
InformationsquelleAutor Gregory Pakosz
33

À l'aide de BigInteger:
```
private byte[] bigIntToByteArray( final int i ) {
    BigInteger bigInt = BigInteger.valueOf(i);      
    return bigInt.toByteArray();
}
```
À l'aide de DataOutputStream:
```
private byte[] intToByteArray ( final int i ) throws IOException {      
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    DataOutputStream dos = new DataOutputStream(bos);
    dos.writeInt(i);
    dos.flush();
    return bos.toByteArray();
}
```
À l'aide de ByteBuffer:
```
public byte[] intToBytes( final int i ) {
    ByteBuffer bb = ByteBuffer.allocate(4); 
    bb.putInt(i); 
    return bb.array();
}
```
- attention à l'ordre des octets si
- Ne ByteBuffer donne un unsigned int?
- À l'aide de ByteBuffer j'ai essayé avec ByteBuffer bb = ByteBuffer.allouer(3); c'est en java.nio.BufferOverflowException, je ne reçois pas pourquoi il ne fonctionne pas de valeur pour les moins de 4? Pouvez-vous expliquer?
- Vous obtenez un dépassement de la mémoire tampon exception, car les entiers en Java 32 bits ou 4 octets la taille, et donc exiger de vous que vous allouer au moins 4 octets de mémoire dans votre ByteBuffer.
- est juste à propos de l'ordre des octets. Sa réponse à l'aide de ByteBuffer est plus intuitif si vous faites affaire avec un entier supérieur à 2^31 - 1.
InformationsquelleAutor Pascal Thivent
27

utiliser cette fonction, il fonctionne pour moi
```
public byte[] toByteArray(int value) {
    return new byte[] {
            (byte)(value >> 24),
            (byte)(value >> 16),
            (byte)(value >> 8),
            (byte)value};
}
```
il traduit l'int en une valeur d'un octet
- Il est également intéressant de noter que cela fonctionne quel que soit le bit le plus significatif et le plus efficace par rapport à d'autres réponses. Pourrait aussi utiliser " >>".
- Une solution directe, comme c'est certainement plus rapide que l'appel à la méthode de bibliothèque. Parfois vous avez juste à jouer avec les bits directement avec quelques lignes de code, plutôt que de supporter tous les frais généraux supplémentaires de la bibliothèque des appels de méthode.
InformationsquelleAutor daz

Si vous aimez Goyave, vous pouvez utiliser ses Ints classe:

Pour int → byte[], utilisez toByteArray():

byte[] byteArray = Ints.toByteArray(0xAABBCCDD);

Résultat est {0xAA, 0xBB, 0xCC, 0xDD}.

Son inverse est fromByteArray() ou fromBytes():

int intValue = Ints.fromByteArray(new byte[]{(byte) 0xAA, (byte) 0xBB, (byte) 0xCC, (byte) 0xDD});
int intValue = Ints.fromBytes((byte) 0xAA, (byte) 0xBB, (byte) 0xCC, (byte) 0xDD);

Résultat est 0xAABBCCDD.

InformationsquelleAutor Pang

8

Vous pouvez utiliser BigInteger:

À Partir De Nombres Entiers:
```
byte[] array = BigInteger.valueOf(0xAABBCCDD).toByteArray();
System.out.println(Arrays.toString(array))
//--> { -86, -69, -52, -35 }
```
Le tableau retourné est de la taille de ce qui est nécessaire pour représenter le nombre, de sorte qu'il pourrait être de taille 1, pour représenter 1 par exemple. Cependant, la taille ne peut pas être plus de quatre octets si un int est passé.

De Cordes:
```
BigInteger v = new BigInteger("AABBCCDD", 16);
byte[] array = v.toByteArray();
```
Toutefois, vous aurez besoin de regarder, si le premier octet est plus élevé 0x7F (comme dans ce cas), où BigInteger insérez un 0x00 octet pour le début du tableau. C'est nécessaire de faire la distinction entre valeurs positives et négatives.
- merci! Mais puisque c'est BigInteger, sera ints enrouler autour de correctement? C'est des entiers qui sont à l'extérieur Entier.MAX_VALUE, mais peut toujours être représenté avec seulement 4 octets?
- Ce n'est certainement pas rapide à exécuter. 😉
- Ce n'est pas une bonne option. Non seulement il peut ajouter 0x00 octet, il peut également supprimer les zéros non significatifs.
InformationsquelleAutor notnoop

Cela vous aide à

importer java.nio.ByteBuffer;
importer java.util.Des tableaux;

public class MyClass 
{
    public static void main(String args[]) {
       byte [] hbhbytes = ByteBuffer.allocate(4).putInt(16666666).array();

  System.out.println(Arrays.toString(hbhbytes));
    }
}

InformationsquelleAutor wai

Pouvez également maj -

byte[] ba = new byte[4];
int val = Integer.MAX_VALUE;

for(byte i=0;i<4;i++)
    ba[i] = (byte)(val >> i*8);
    //ba[3-i] = (byte)(val >> i*8); //Big-endian

InformationsquelleAutor Matt

Voici une méthode qui devrait faire le travail juste à droite.

public byte[] toByteArray(int value)
{
    final byte[] destination = new byte[Integer.BYTES];
    for(int index = Integer.BYTES - 1; index >= 0; index--)
    {
        destination[i] = (byte) value;
        value = value >> 8;
    };
    return destination;
};

InformationsquelleAutor user3424779

C'est ma solution:

public void getBytes(int val) {
    byte[] bytes = new byte[Integer.BYTES];
    for (int i = 0;i < bytes.length; i ++) {
        int j = val % Byte.MAX_VALUE;
        bytes[i] = (j == 0 ? Byte.MAX_VALUE : j);
    }
}

Aussi Stringy méthode:

public void getBytes(int val) {
    String hex = Integer.toHexString(val);
    byte[] val = new byte[hex.length()/2]; //because byte is 2 hex chars
    for (int i = 0; i < hex.length(); i+=2)
        val[i] = Byte.parseByte("0x" + hex.substring(i, i+2), 16);
    return val;
}

InformationsquelleAutor Muskovets

Vous devez vous connecter pour publier un commentaire.