Comment puis-je convertir Long de byte[] et, de retour en java

Comment puis-je convertir une longue pour un byte[] et, de retour en Java?
Je suis en train de convertir une longue pour un byte[] de sorte que je vais être en mesure d'envoyer le byte[] sur une connexion tcp. De l'autre côté je veux prendre que byte[] et la convertir en un lit double.
Des conseils seraient appréciés.

Une autre alternative sera de Cartes.transformValues, un général de l'outillage pour la conversion des collections. docs.guava-libraries.googlecode.com/git-history/release/javadoc/...
Voir aussi stackoverflow.com/q/27559449/32453 si votre objectif est de convertir une longue dans le plus petit nombre de Base64 caractères.
Peut-être qu'il convient de souligner que la conversion pipeline 'de long -> byte[] -> double", pas "long -> byte[] -> long -> double".

InformationsquelleAutor Emre801 | 2010-12-19

189
```
public byte[] longToBytes(long x) {
    ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES);
    buffer.putLong(x);
    return buffer.array();
}

public long bytesToLong(byte[] bytes) {
    ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES);
    buffer.put(bytes);
    buffer.flip();//need flip 
    return buffer.getLong();
}
```
Ou enveloppé dans une classe pour éviter à plusieurs reprises la création d'ByteBuffers:
```
public class ByteUtils {
    private static ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES);    

    public static byte[] longToBytes(long x) {
        buffer.putLong(0, x);
        return buffer.array();
    }

    public static long bytesToLong(byte[] bytes) {
        buffer.put(bytes, 0, bytes.length);
        buffer.flip();//need flip 
        return buffer.getLong();
    }
}
```
Depuis c'est devenu tellement populaire, je veux juste mentionner que je pense que vous êtes mieux d'utiliser une bibliothèque comme la Goyave, dans la grande majorité des cas. Et si vous avez une étrange opposition à des bibliothèques, vous devriez probablement envisager cette réponse première pour java natif de solutions. Je pense que la principale chose que ma réponse a vraiment pour elle est que vous n'avez pas à vous soucier de la endian-ness de vous-même le système.
- +1 pour ByteBuffer
- Intelligente ... mais vous vous créez et jetez un temporaire ByteBuffer pour chaque conversion. Pas bon si vous envoyez plusieurs longs par message et/ou beaucoup de messages.
- J'étais juste assez pour montrer comment utiliser ByteBuffer, mais je suis allé de l'avant et a ajouté un exemple d'utilisation dans une classe utilitaire.
- L'utilité de la méthode n'est pas thread-safe, donc je ne suis pas sûr que c'est beaucoup mieux...
- Je pense que le bytesToLong() ici échouerait que la position après le mettre à la fin de la mémoire tampon, non pas le début. Je pense que vous seriez obtenir un type dépassement de tampon d'exception.
- pouvez-vous s'il vous plaît modifier votre réponse, cette réponse est fausse par Alex Miller, et à l'aide de votre méthode [static long bytesToLong(octets)] j'ai des problèmes.. Vous devriez avoir octets dans le bon endroit ou vous devez effacer la mémoire. J'ai été faire BufferOverflowException.
- Merci pour flip()
- Grande réponse. Il n'était pas immédiatement clair pour moi pourquoi vous avez besoin de "flip", mais je suis tombé sur cet article qui m'a beaucoup aidé! tutorials.jenkov.com/java-nio/buffers.html peut-être flip est un abus de langage?
- Avant Java 8, vous pouvez l'utiliser Longtemps.TAILLE/Octet.TAILLE au lieu de Long.OCTETS pour éviter un nombre magique.
- La réutilisation d'un bytebuffer est très problématique, et pas seulement pour les fils des raisons de sécurité, que d'autres ont commenté. Pas seulement un".clear()' être nécessaire entre les deux, mais ce n'est pas évident, c'est que l'appel .array() sur le ByteBuffer est de retour à la sauvegarde de tableau par rapport à une copie. Ainsi, si vous appelez à plusieurs reprises et de conserver les autres résultats, ils sont en fait tous le même tableau que, à plusieurs reprises, d'écraser les valeurs précédentes. Hadoop lien dans un commentaire ci-dessous est le plus performant et qui évite une quelconque de ces questions.
InformationsquelleAutor Brad Mace
72

Vous pouvez utiliser le Octet méthodes de conversion de Google Goyave.

Exemple:
```
byte[] bytes = Longs.toByteArray(12345L);
```
InformationsquelleAutor Sonson123
69

J'ai testé la ByteBuffer méthode contre plaine des opérations bit à bit, mais la seconde est beaucoup plus rapide.
```
public static byte[] longToBytes(long l) {
    byte[] result = new byte[8];
    for (int i = 7; i >= 0; i--) {
        result[i] = (byte)(l & 0xFF);
        l >>= 8;
    }
    return result;
}

public static long bytesToLong(byte[] b) {
    long result = 0;
    for (int i = 0; i < 8; i++) {
        result <<= 8;
        result |= (b[i] & 0xFF);
    }
    return result;
}
```
- Nombre magique 8 devrait être défini comme Long.SIZE / Byte.SIZE dans la gamme de taille et de Byte.SIZE en quart de travail.
- D'accord. J'ai décidé de le laisser dehors de cet exemple. Dans Java 8 vous pouvez utiliser Longtemps.OCTETS au lieu de Long.TAILLE / Octet.TAILLE
- Au lieu de résultat |= (b[i] & 0xFF); On peut simplement utiliser result |= b[i]; comme et avec 0xFF pour un peu, ne pas modifier quoi que ce soit.
- Le bit à bit et a de l'importance parce que quand vous faites juste result |= b[i] la valeur de l'octet va d'abord être converti à long terme qui ne l'extension du signe. Un octet dont la valeur -128 (hex 0x80) va se transformer en un long avec la valeur -128 (hex 0xFFFF FFFF FFFF FF80). Tout d'abord, après la conversion sont les valeurs ou:ed ensemble. L'aide au niveau du bit et protège contre ce en convertissant d'abord l'octet de type int et le découpage de l'extension du signe: (byte)0x80 & 0xFF ==> (int)0xFFFF FF80 & 0xFF ==> (int) 0x80. Pourquoi octets sont signés en java, c'est un peu un mystère pour moi, mais je suppose que c'est pour s'adapter à d'autres types.
- J'ai essayé cas -128 avec |= b[i] et avec |= (b[i] & 0xFF) et les résultats sont les mêmes !!
- Le problème est que l'octet sera promu avant le décalage est appliqué, ce qui provoque des problèmes étranges avec le bit de signe. Par conséquent, nous avons d'abord et (&) avec 0xFF pour obtenir la valeur correcte de changement.
- J'essaie de convertir ces données (data = new byte[]{(byte) 0xDB, (byte) 0xA7, 0x53, (byte) 0xF8, (byte) 0xA8, 0x0C, 0x66, 0x8}; ) à la longue, mais qu'elle renvoie la valeur false -2619032330856274424, la valeur attendue est 989231983928329832
- La représentation hexadécimale de 989231983928329832 est 0DBA753F8A80C668. Le 0 probablement tombé de provoquer l'erreur de conversion.
- J'ai un fichier avec le contenu 11776135168. J'ai lu le contenu d'un fichier à l'aide de Fichier.readAllBytes(chemin) et ensuite essayé de convertir les octets en valeur longue. Je m'attendais à 11776135168 lui-même comme le résultat final, mais 3544675091989214005. Quel est le problème? Ci-dessous l'extrait de code: byte[] fileContent = Files.readAllBytes(path); long result = 0; for (int i = 0; i < Long.BYTES; i++) { result <<= Byte.SIZE; result |= (fileContent[i] & 0xFF); } System.out.println("The result: " + result);
InformationsquelleAutor Wytze
15

Pourquoi avez-vous besoin byte[]? pourquoi ne pas l'écrire sur le socket?

Je suppose que vous voulez dire long plutôt que Long, celle-ci doit autoriser les valeurs null.
```
DataOutputStream dos = new DataOutputStream(
     new BufferedOutputStream(socket.getOutputStream()));
dos.writeLong(longValue);

DataInputStream dis = new DataInputStream(
     new BufferedInputStream(socket.getInputStream()));
long longValue = dis.readLong();
```
- Il demande comment convertir byte[] et à l'arrière. Bonne réponse, mais n'a pas répondu à la question. Vous vous demandez pourquoi, parce que vous supposez que c'est inutile mais c'est une hypothèse erronée. Si il est en train de faire de la croix-de la langue ou de la croix-plate-forme? DataOutputStream ne sera pas vous aider là-bas.
- Si il fait de la langue ou de la croix-plate-forme, puis à envoyer les octets dans un ordre connu est important. Cette méthode n'est que (il écrit "octet de poids fort en premier") selon les docs. L'on a accepté la réponse n'a pas (il écrit dans "commande en cours", selon les docs). La question déclare qu'il veut les envoyer sur une connexion TCP. Le byte[] est seulement un moyen à cette fin.
- La accepté de répondre à n'utiliser un ordre connu. Il crée un nouveau ByteBuffer qui, selon les docs "La première commande d'un octet de mémoire tampon est toujours BIG_ENDIAN.
InformationsquelleAutor Peter Lawrey

Si vous êtes à la recherche d'un rapide déroulé, cette version devrait faire l'affaire, en supposant un tableau d'octets appelé "b" avec une longueur de 8:

byte[] -> long

long l = ((long) b[7] << 56)
       | ((long) b[6] & 0xff) << 48
       | ((long) b[5] & 0xff) << 40
       | ((long) b[4] & 0xff) << 32
       | ((long) b[3] & 0xff) << 24
       | ((long) b[2] & 0xff) << 16
       | ((long) b[1] & 0xff) << 8
       | ((long) b[0] & 0xff);

long -> byte[] comme un équivalent exact de la ci-dessus

byte[] b = new byte[] {
       (byte) lng,
       (byte) (lng >> 8),
       (byte) (lng >> 16),
       (byte) (lng >> 24),
       (byte) (lng >> 32),
       (byte) (lng >> 40),
       (byte) (lng >> 48),
       (byte) (lng >> 56)};

InformationsquelleAutor Michael Böckling

Il suffit d'écrire le long d'un DataOutputStream avec un sous-jacent ByteArrayOutputStream. À partir de la ByteArrayOutputStream vous pouvez obtenir le tableau d'octets via toByteArray():

class Main
{

        public static byte[] long2byte(long l) throws IOException
        {
        ByteArrayOutputStream baos=new ByteArrayOutputStream(Long.SIZE/8);
        DataOutputStream dos=new DataOutputStream(baos);
        dos.writeLong(l);
        byte[] result=baos.toByteArray();
        dos.close();    
        return result;
        }


        public static long byte2long(byte[] b) throws IOException
        {
        ByteArrayInputStream baos=new ByteArrayInputStream(b);
        DataInputStream dos=new DataInputStream(baos);
        long result=dos.readLong();
        dos.close();
        return result;
        }


        public static void main (String[] args) throws java.lang.Exception
        {

         long l=123456L;
         byte[] b=long2byte(l);
         System.out.println(l+": "+byte2long(b));       
        }
}

Fonctionne pour d'autres primitives en conséquence.

Conseil: Pour TCP vous n'avez pas besoin de le byte[] manuellement. Vous allez utiliser un Socket socket et de ses flux de

OutputStream os=socket.getOutputStream(); 
DataOutputStream dos=new DataOutputStream(os);
dos.writeLong(l);
//etc ..

à la place.

InformationsquelleAutor Michael Konietzka

4

Vous pouvez utiliser la mise en œuvre dans org.apache.hadoop.hbase.util.Octets http://hbase.apache.org/apidocs/org/apache/hadoop/hbase/util/Bytes.html

Le code source est ici:

http://grepcode.com/file/repository.cloudera.com/content/repositories/releases/com.cloudera.hbase/hbase/0.89.20100924-28/org/apache/hadoop/hbase/util/Bytes.java#Bytes.toBytes%28long%29

Recherchez le toLong et toBytes méthodes.

Je crois que la licence du logiciel vous permet de prendre des parties du code et de l'utiliser mais s'il vous plaît vérifier que.
- C'est la bonne et la plus performante de réponse.
- Pourquoi est-ce que la mise en œuvre utilisation XOR (^=) au lieu de OU? github.com/apache/hbase/blob/master/hbase-common/src/main/java/...
InformationsquelleAutor Marquez

 public static long bytesToLong(byte[] bytes) {
        if (bytes.length > 8) {
            throw new IllegalMethodParameterException("byte should not be more than 8 bytes");

        }
        long r = 0;
        for (int i = 0; i < bytes.length; i++) {
            r = r << 8;
            r += bytes[i];
        }

        return r;
    }



public static byte[] longToBytes(long l) {
        ArrayList<Byte> bytes = new ArrayList<Byte>();
        while (l != 0) {
            bytes.add((byte) (l % (0xff + 1)));
            l = l >> 8;
        }
        byte[] bytesp = new byte[bytes.size()];
        for (int i = bytes.size() - 1, j = 0; i >= 0; i--, j++) {
            bytesp[j] = bytes.get(i);
        }
        return bytesp;
    }

vous pouvez ignorer la liste de tableaux: public static byte[] longToBytes(long l) { long num = l; byte[] bytes = new byte[8]; for (int i = octets.longueur - 1, i >= 0; i--) { octets[i] = (byte)(num & 0xff); num >>= 8; } return bytesp; }
La première méthode ne fonctionne pas avec les nombres négatifs comme il entre dans une boucle infinie while (l != 0), @eckes méthode ne fonctionne pas avec les numéros de plus de 127 parce qu'il ne tient pas compte d'octets négatives sur 127 cause qu'ils sont signés.

InformationsquelleAutor maziar

1

Si vous utilisez déjà un OutputStream à écrire pour le socket, puis DataOutputStream pourrait être un bon ajustement. Voici un exemple:
```
//Assumes you are currently working with a SocketOutputStream.

SocketOutputStream outputStream = ...
long longValue = ...

DataOutputStream dataOutputStream = new DataOutputStream(outputStream);

dataOutputStream.writeLong(longValue);
dataOutputStream.flush();
```
Il y a des méthodes similaires pour short, int, float, etc. Vous pouvez ensuite utiliser DataInputStream sur le côté de réception.

InformationsquelleAutor Matt Solnit
1

Je vais ajouter une autre réponse qui est la plus rapide possible ׂ(oui, même plus que l'on a accepté la réponse), MAIS il ne fonctionne pas pour tous les cas. TOUTEFOIS, il ne fonctionne pour tous les scénarios envisageables:

Vous pouvez simplement utiliser la Chaîne comme intermédiaire. Remarque, cela vous donnera le résultat correct même s'il semble que l'aide de la Chaîne pourrait donner des résultats erronés aussi LONGTEMPS QUE vous SAVEZ que VOUS travaillez À la "NORMALE" des CHAÎNES. C'est une méthode pour augmenter l'efficacité et de rendre le code plus simple qui, en retour, doit utiliser certaines hypothèses sur les chaînes de données, il fonctionne sur.

Con de l'utilisation de cette méthode: Si vous travaillez avec certains caractères ASCII comme ces symboles dans le début de la table ASCII, les lignes suivantes peuvent échouer, mais avouons - le, vous n'aurez probablement jamais utiliser de toute façon.

Pro de l'utilisation de cette méthode: Rappelez-vous que la plupart des gens travaillent habituellement avec une certaine normale des cordes, sans caractères inhabituels et ensuite, la méthode est la plus simple et la plus rapide façon d'aller.

de Long à byte[]:
```
byte[] arr = String.valueOf(longVar).getBytes();
```
de byte[] pour Longtemps:
```
long longVar = Long.valueOf(new String(byteArr)).longValue();
```
- Désolé pour necroposting, mais c'est tout simplement faux. E. g. Chaîne de caractères.valueOf(0).getBytes()[0] == 0x30. Surprise! String#getBytes sera de retour ASCII codé chiffres, des symboles, des chiffres: '0' != 0, mais '0' == 0x30
- Eh bien peut-être si vous aviez lu la totalité de ma réponse, puis vous avais vu, j'ai averti à ce sujet dans la réponse elle-même..
- Ah, j'ai raté le point intermédiaire byte[] de données est traité comme (presque) opaque. Votre truc va faire pour ce scénario.
InformationsquelleAutor Yonatan Nir

Vous devez vous connecter pour publier un commentaire.