comment convertir byte[] pour Byte[], et dans l'autre sens?

Comment convertir byte[] pour Byte[], et aussi Byte[] pour byte[], dans le cas de ne pas utiliser du tout de la 3e partie de la bibliothèque? Est-il un moyen de le faire rapidement et simplement en utilisant la bibliothèque standard?

  • 10 questions, il est accepté? Pas bon
  • Pourquoi avez-vous besoin/ont un Byte[]? Ne semble pas être une bonne idée... soit utiliser byte[] ou List<Byte>.
  • Peut être utile si les valeurs peuvent être nulles, mais probablement pas très efficace (c'est à dire. les déchets de l'espace; avantage de stocker des octets, parce que de toutes les références d'objet)?
  • Mais vous ne pouvez pas convertir un Byte[] à un byte[] si vous avez des références nulles...
  • ok, 1 de 7. N'ont pas beaucoup amélioré!
  • L'une des raisons d'avoir Byte [], c'est qu'il devient une forme intermédiaire d'essayer d'appeler toArray sur une Liste<Byte>. Dans ce cas, la rédaction de votre propre boucle semble être le moyen le plus facile.

InformationsquelleAutor user926958 | 2012-10-17
  1. 43

    Byte classe est un wrapper de la primitive byte. Cela devrait faire le travail:

    byte[] bytes = new byte[10];
Byte[] byteObjects = new Byte[bytes.length];

int i=0;    
//Associating Byte array values with bytes. (byte[] to Byte[])
for(byte b: bytes)
   byteObjects[i++] = b;  //Autoboxing.

....

int j=0;
//Unboxing Byte values. (Byte[] to byte[])
for(Byte b: byteObjects)
    bytes[j++] = b.byteValue();
    • Recommanderais certainement Byte.valueOf(b) sur new Byte(b). Je serais surpris si l'Octet de classe n'a pas de cache à chaque valeur unique pour un octet.
    • Je crois qu'il serait préférable d'utiliser Byte.valueOf(byte). La documentation javadoc dire que cette méthode doit généralement être utilisés de préférence pour le constructeur Byte(byte), que cette méthode est susceptible d'avoir nettement mieux l'espace et le temps de la performance car toutes les valeurs d'octets sont mis en cache.
    • Avec l'autoboxing, vous pouvez simplement faire byteObjects[i++] = b;
    • Je voudrais utiliser new Byte[bytes.length]; au lieu de new Byte[10]; garder raisonnable.
    • Cette réponse n'est pas correcte. Le i++, j++ dans la boucle for-each ne pas faire quelque chose d'utile. Vous devez utiliser la base pour la boucle: for (int i=0; i<octets.longueur;i++) { byteObjects[i] = b[i]; }. En va de même pour l'unboxing.
    • avez-vous déjà réglé mon code? avec mon code, je l'ai et j en va de 0 à 10, et les poignées de l'emploi.
    • ah, je vois que vous utilisez deux "guichets" dans la boucle for: l'un pour itérer sur les primitives tableau d'octets et/ou d'Octets de l'objet de tableau, et un autre pour l'incrémentation de l'index de la primitive tableau d'octets et/ou d'Octets de l'objet array. Pour moi, c'est une mauvaise pratique. Si ce code est maintenu par d'autres, et que quelqu'un serait de modifier le compteur "je" de 0 à une autre valeur, ou serait de changer le i++ ++dans i, les indices ne correspondent plus. Je ne suis pas plaider n'importe qui devrait modifier le code dans la première place, mais c'est un piège classique pour les débutants. Ma suggestion garde les index des deux tableaux dans la synchronisation.

    InformationsquelleAutor Juvanis
  2. 48

    byte[] pour Byte[] :

    byte[] bytes = ...;
Byte[] byteObject = ArrayUtils.toObject(bytes);

    Byte[] pour byte[] :

    Byte[] byteObject = new Byte[0];
byte[] bytes = ArrayUtils.toPrimitive(byteObject);
    • Pourquoi ce n'est pas la meilleure réponse? Tout performace raison ou simplement répondu à plus tard?
    • Parce que le ArrayUtils ne sont pas une partie de Java, mais Apache lib.
    InformationsquelleAutor LaCrampe
  3. 14

    Vous pouvez utiliser le toPrimitive à la méthode d'Apache Commons lang bibliothèque ArrayUtils classe,
    Comme suggéré ici - Java Byte[] pour byte[]

    • C'est en fait la meilleure réponse, au moins pour ceux qui pensent que l'ajout d'une dépendance à commons-lang n'est pas un problème.
    InformationsquelleAutor Giannis
  4. 14

    Java 8 solution:

    Byte[] toObjects(byte[] bytesPrim) {
    Byte[] bytes = new Byte[bytesPrim.length];
    Arrays.setAll(bytes, n -> bytesPrim[n]);
    return bytes;
}

    Malheureusement, vous ne pouvez pas le faire pour convertir Byte[] à byte[]. Arrays a setAll pour double[], int[], et long[], mais pas pour d'autres types de primitives.

    InformationsquelleAutor ajb
  5. 5

    De byte[] pour Byte[]:

        byte[] b = new byte[]{1,2};
    Byte[] B = new Byte[b.length];
    for (int i = 0; i < b.length; i++)
    {
        B[i] = Byte.valueOf(b[i]);
    }

    De Byte[] pour byte[] (à l'aide de nos précédemment définis,B): 

        byte[] b2 = new byte[B.length];
    for (int i = 0; i < B.length; i++)
    {
        b2[i] = B[i];
    }
    InformationsquelleAutor DNA
  6. 4
    byte[] toPrimitives(Byte[] oBytes)
{

    byte[] bytes = new byte[oBytes.length];
    for(int i = 0; i < oBytes.length; i++){
        bytes[i] = oBytes[i];
    }
    return bytes;

}

    Inverse:

    //byte[] to Byte[]
Byte[] toObjects(byte[] bytesPrim) {

    Byte[] bytes = new Byte[bytesPrim.length];
    int i = 0;
    for (byte b : bytesPrim) bytes[i++] = b; //Autoboxing
    return bytes;

}
    InformationsquelleAutor jacktrades