Bitconverter pour Java

Suivant les conseils fournis dans la question https://stackoverflow.com/questions/1738244/what-is-the-java-equivalent-of-net-bitconverter j'ai commencé à réaliser mes propres bitconverter pour Java mais je ne suis pas d'obtenir des résultats équivalents.

Quelqu'un pourrait-il svp me guider sur ce que je fais mal?

public static byte[] GetBytes(Integer value) {
    ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
    DataOutputStream stream = new DataOutputStream(byteStream);
    try {
        stream.writeInt(value);
    } catch (IOException e) {
        return new byte[4];
    }
    return byteStream.toByteArray();
}

byte[] result = BitConverter.GetBytes(1234); //JAVA: [0, 0, 4, -46]
byte[] result = BitConverter.GetBytes(1234); //C#: [210, 4, 0, 0]

OriginalL'auteur Maxim Gershkovich | 2011-05-03

bytearray c#java primitive

8

Qui est juste endianness (-46 et 210 est à cause de Java est signé octets, mais c'est juste une INTERFACE chose). Soit de renverser le contenu du tableau, ou de l'utilisation des opérations de déplacement d'écrire int.

Remarque: le boutisme .NET émet dépend de la plate-forme. Je conseille CONNU BOUTISME dans les deux cas; la plupart du temps en utilisant des opérations de déplacement de deux. Ou peut-être une meilleure idée: il suffit d'utiliser un pré-arrangé, indépendant de la plateforme format de sérialisation (par exemple: protocole de tampons, qui a un bon soutien sur Java et en .NET/C#).

Par exemple; si j'écrivais un int value à un byte[] buffer (à partir de offset), je pourrais utiliser:
```
buffer[offset++] = (byte)value;
buffer[offset++] = (byte)(value>>8);
buffer[offset++] = (byte)(value>>16);
buffer[offset++] = (byte)(value>>24);
```
c'est garanti little-endian, et le même code devrait fonctionner sur n'importe quel cadre.

quelle est la valeur de décalage?
cependant, la mesure dans les données que vous avez lu jusqu'à présent

OriginalL'auteur Marc Gravell
4

Le C# BitConverter utilisera le boutisme de la sous-achitecture. Dans la plupart des environnements, il est little-endian (comme il est dans votre cas). Java est DataOutputStream cependant toujours écrire en big-endian ("les mobiles"). Vous aurez besoin de vérifier le boutisme de la machine et de l'écriture en conséquence si vous voulez faire correspondre le comportement.

Aussi, les octets en java sont signés de sorte que le résultat est juste une esthétique de la différence. La représentation binaire est le même si vous n'avez pas besoin de s'inquiéter à ce sujet.

Pour vérifier le stockage de votre machine, utilisez le java.nio.ByteOrder.nativeOrder() méthode. Ensuite, utilisez la java.nio.ByteBuffer au lieu où vous pouvez spécifier l'octet () et écrire les données.

Vous pouvez ensuite appliquer votre méthode comme ceci:
```
public static byte[] GetBytes(int value)
{
    ByteBuffer buffer = ByteBuffer.allocate(4).order(ByteOrder.nativeOrder());
    buffer.putInt(value);
    return buffer.array();
}
```
OriginalL'auteur Jeff Mercado

si tout besoin de corps..C# JAVA BitConverter.ToInt32

  public static int toInt32_2(byte[] bytes, int index)
        {
            int a = (int)((int)(0xff & bytes[index]) << 32 | (int)(0xff & bytes[index + 1]) << 40 | (int)(0xff & bytes[index + 2]) << 48 | (int)(0xff & bytes[index + 3]) << 56);
            //int a = (int)((int)(0xff & bytes[index]) << 56 | (int)(0xff & bytes[index + 1]) << 48 | (int)(0xff & bytes[index + 2]) << 40 | (int)(0xff & bytes[index + 3]) << 32);
            //Array.Resize;
            return a;
        }

Aussi Int16

    public static short toInt16(byte[] bytes, int index) //throws Exception
    {
        return (short)((bytes[index + 1] & 0xFF) | ((bytes[index] & 0xFF) << 0));
        //return (short)(
        //       (0xff & bytes[index]) << 8 |
        //               (0xff & bytes[index + 1]) << 0
        //);
    }

BitConverter.getBytes

public static byte[] GetBytesU16(long value)
{

    ByteBuffer buffer = ByteBuffer.allocate(8).order(ByteOrder.nativeOrder());
    buffer.putLong(value);
    return buffer.array();
}

OriginalL'auteur Jevgenij Kononov

Bâtiment sur Jeff de réponse, vous pouvez utiliser un seul ByteBuffer à convertir à la fois vers et à partir de int et byte[]. Voici le code vous pouvez vous déplacer dans une classe de convertir vers/à partir de Little Endian:

ByteBuffer _intShifter = ByteBuffer.allocate(Integer.SIZE / Byte.SIZE)
                                   .order(ByteOrder.LITTLE_ENDIAN);

public byte[] intToByte(int value) {
    _intShifter.clear();
    _intShifter.putInt(value);      
    return _intShifter.array();
}

public int byteToInt(byte[] data)
{
    _intShifter.clear();
    _intShifter.put(data, 0, Integer.SIZE / Byte.SIZE);
    _intShifter.flip();
    return _intShifter.getInt();
}

OriginalL'auteur Matt Klein

Vous devez vous connecter pour publier un commentaire.