Come inizializzare un array di byte in Java?

Question

Devo memorizzare alcuni valori costanti (UUID) in forma di array di byte in java e mi chiedo quale sarebbe il modo migliore per inizializzare tali array statici. Questo è come lo sto facendo attualmente, ma sento che ci deve essere un modo migliore.

private static final byte[] CDRIVES = new byte[] { (byte)0xe0, 0x4f, (byte)0xd0, 
    0x20, (byte)0xea, 0x3a, 0x69, 0x10, (byte)0xa2, (byte)0xd8, 0x08, 0x00, 0x2b, 
    0x30, 0x30, (byte)0x9d }; 
private static final byte[] CMYDOCS = new byte[] { (byte)0xba, (byte)0x8a, 0x0d, 
    0x45, 0x25, (byte)0xad, (byte)0xd0, 0x11, (byte)0x98, (byte)0xa8, 0x08, 0x00, 
    0x36, 0x1b, 0x11, 0x03 }; 
private static final byte[] IEFRAME = new byte[] { (byte)0x80, 0x53, 0x1c, 
    (byte)0x87, (byte)0xa0, 0x42, 0x69, 0x10, (byte)0xa2, (byte)0xea, 0x08, 
    0x00, 0x2b, 0x30, 0x30, (byte)0x9d }; 
... 
and so on 

C'è qualcosa che potrei usare che potrebbe essere meno efficiente, ma sembrerebbe più pulito? per esempio:

private static final byte[] CDRIVES = 
    new byte[] { "0xe04fd020ea3a6910a2d808002b30309d" }; 

Answer 1

Utilizzo di una funzione di conversione di una stringa hexa a byte[], si potrebbe fare

byte[] CDRIVES = hexStringToByteArray("e04fd020ea3a6910a2d808002b30309d"); 

Io suggerirei di usare la funzione definita da Dave L in Convert a string representation of a hex dump to a byte array using Java?

inserisco qui per la massima leggibilità:

public static byte[] hexStringToByteArray(String s) { 
    int len = s.length(); 
    byte[] data = new byte[len/2]; 
    for (int i = 0; i < len; i += 2) { 
     data[i/2] = (byte) ((Character.digit(s.charAt(i), 16) << 4) 
          + Character.digit(s.charAt(i+1), 16)); 
    } 
    return data; 
} 

Se si lascia che CDRIVES static e final, il calo di prestazioni è Irrel Evant.

Answer 2

È possibile utilizzare la classe UUID Java per memorizzare questi valori, invece di array di byte:

UUID 

public UUID(long mostSigBits, 
      long leastSigBits) 

Costruisce un nuovo UUID utilizzando i dati specificati. mostSigBits viene utilizzato per i 64 bit più significativi dell'UUID e leastSigBits diventa il meno significativo 64 bit dell'UUID.

Answer 3

Per quanto riguarda un processo pulito è interessato è possibile utilizzare ByteArrayOutputStream oggetto ...

ByteArrayOutputStream bObj = new ByteArrayOutputStream(); 
bObj.reset(); 

// scrivere tutti i valori a BOBJ uno ad uno utilizzando

bObj.write(byte value) 

// quando hai finito puoi ottenere il byte [] usando

CDRIVES = bObj.toByteArray(); 

// di quanto sia possibile ripetere il processo simile anche per CMYDOCS e IEFRAME,

NOTA Questa soluzione non è efficiente se si dispone di un piccolo array.

Answer 4

In Java 6, v'è un metodo di fare esattamente quello che vuoi:

private static final byte[] CDRIVES = javax.xml.bind.DatatypeConverter.parseHexBinary("e04fd020ea3a6910a2d808002b30309d") 

In alternativa è possibile utilizzare Google Guava:

import com.google.common.io.BaseEncoding; 
private static final byte[] CDRIVES = BaseEncoding.base16().lowerCase().decode("E04FD020ea3a6910a2d808002b30309d".toLowerCase()); 

Il metodo Guava è eccessivo, quando si utilizza piccoli array . Ma Guava ha anche versioni in grado di analizzare flussi di input. Questa è una bella caratteristica quando si tratta di grandi ingressi esadecimali.

Answer 5

byte[] myvar = "Any String you want".getBytes(); 

Answer 6

byte[] responseBody = "Invalid Domain Alias".getBytes(); 

Answer 7

mia opzione preferita in questa circostanza è quello di utilizzare org.apache.commons.codec.binary.Hex che ha API utili per la conversione tra String y esadecimale e binario. Ad esempio:

1. Hex.decodeHex(char[] data) che genera un DecoderException se ci sono caratteri non esadecimali nell'array, o se vi sono un numero dispari di caratteri.

2. Hex.encodeHex(byte[] data) è la controparte del metodo di decodifica di cui sopra, e sputa lo char[].

3. Hex.encodeHexString(byte[] data) che converte da un array byte a String.

Usage: Hex.decodeHex("dd645a2564cbe648c8336d2be5eafaa6".toCharArray())

Answer 8

private static final int[] CDRIVES = new int[] {0xe0, 0xf4, ...}; 

e dopo l'accesso convertito al byte.

Answer 9

Una soluzione senza le biblioteche, la lunghezza dinamica restituito, interpretazione intero senza segno (non complemento a due)

public static byte[] numToBytes(int num){ 
    if(num == 0){ 
     return new byte[]{}; 
    }else if(num < 256){ 
     return new byte[]{ (byte)(num) }; 
    }else if(num < 65536){ 
     return new byte[]{ (byte)(num >>> 8),(byte)num }; 
    }else if(num < 16777216){ 
     return new byte[]{ (byte)(num >>> 16),(byte)(num >>> 8),(byte)num }; 
    }else{ // up to 2,147,483,647 
     return new byte[]{ (byte)(num >>> 24),(byte)(num >>> 16),(byte)(num >>> 8),(byte)num }; 
    } 
}