byte[] bytes = {-1, 0, 1, 2, 3 };
    StringBuilder sb = new StringBuilder();
    for (byte b : bytes) {
        sb.append(String.format("%02X ", b));
    }
    System.out.println(sb.toString());
    // prints "FF 00 01 02 03 "

Voir aussi

• java.util.Formatter la syntaxe
  • %[flags][width]conversion
    • Drapeau '0' - Le résultat sera zéro-collier
    • Largeur 2
    • Conversion 'X' - Le résultat est formaté en entier hexadécimal, en majuscules

En regardant le texte de la question, il est également possible que ce soit ce qui est demandé:

    String[] arr = {"-1", "0", "10", "20" };
    for (int i = 0; i < arr.length; i++) {
        arr[i] = String.format("%02x", Byte.parseByte(arr[i]));
    }
    System.out.println(java.util.Arrays.toString(arr));
    // prints "[ff, 00, 0a, 14]"

Plusieurs réponses ici utilise Integer.toHexString(int); c'est faisable, mais avec quelques mises en garde. Puisque le paramètre est un int, une conversion primitive d'élargissement est effectuée en l'argument byte, ce qui implique une extension de signe.

    byte b = -1;
    System.out.println(Integer.toHexString(b));
    // prints "ffffffff"

Le byte 8 bits, qui est signé en Java, est étendu à un int 32 bits. Pour annuler efficacement cette extension de signe, on peut masquer le byte avec 0xFF.

    byte b = -1;
    System.out.println(Integer.toHexString(b & 0xFF));
    // prints "ff"

Un autre problème avec l'utilisation de toHexString est qu'il ne fonctionne pas avec des zéros:

    byte b = 10;
    System.out.println(Integer.toHexString(b & 0xFF));
    // prints "a"

Les deux facteurs combinés devraient faire la solution String.format plus préférable.

Références

• JLS 4.2.1 Types et valeurs intégrales
  • Pour byte, de -128 à 127, inclusive
• JLS 5.1.2 Élargissement de la conversion primitive

Je poste parce qu'aucune des réponses existantes n'explique pourquoi leurs approches fonctionnent, ce qui, je pense, est vraiment important pour ce problème. Dans certains cas, la solution proposée semble inutilement compliquée et subtile. Pour illustrer, je vais fournir une approche assez simple, mais je vais fournir un peu plus de détails pour aider à illustrer pourquoi cela fonctionne.

Tout d'abord, qu'essayons-nous de faire? Nous voulons convertir une valeur d'un octet (ou un tableau d'octets) à un chaîne qui représente une valeur hexadécimale en ASCII. La première étape consiste donc à savoir exactement ce qu'est un octet en Java:

Le type de données octet est un entier de complément de deux signé à 8 bits. Il a une valeur minimale de -128 et une valeur maximale de 127 (inclus). Le type de données byte peut être utile pour économiser de la mémoire dans de grands tableaux, où les économies de mémoire comptent réellement. Ils peuvent également être utilisés à la place de int où leurs limites aident à clarifier votre code; le fait qu'un la plage de variable est limitée peut servir de forme de documentation.

Qu'est-ce que cela signifie? Quelques choses: Tout d'abord et surtout, cela signifie que nous travaillons avec 8-bits. Ainsi, par exemple, nous pouvons écrire le nombre 2 comme 0000 0010. Cependant, comme c'est le complément de deux, nous écrivons un négatif 2 comme ceci: 1111 1110. Ce qui signifie également que la conversion en hexadécimal est très simple. Autrement dit, vous convertissez simplement chaque segment de 4 bits directement en hexadécimal. Notez que pour donner un sens à nombres négatifs dans ce schéma, vous devrez d'abord comprendre le complément de deux. Si vous ne comprenez pas déjà le complément de deux, vous pouvez lire une excellente explication, ici: http://www.cs.cornell.edu / ~tomf/notes/cps104/twoscomp.html

Conversion du Complément de Deux en Hexadécimal en général

Une fois qu'un nombre est dans le complément de deux, il est très simple de le convertir en hexadécimal. En général, la conversion de binaire en hexadécimal est très simple, et comme vous le verrez dans les deux exemples suivants, vous pouvez aller directement du complément de deux à hex.

Exemples

Exemple 1: Convertir 2 en hexadécimal.

1) Convertissez d'abord 2 en binaire dans le complément de deux:

2 (base 10) = 0000 0010 (base 2)

2) Maintenant convertir binaire en hexadécimal:

0000 = 0x0 in hex
0010 = 0x2 in hex

therefore 2 = 0000 0010 = 0x02. 

Exemple 2: Convertir -2 (en complément de deux) en hexadécimal.

1) Convertissez d'abord -2 en binaire dans le complément de deux:

-2 (base 10) = 0000 0010 (direct conversion to binary) 
               1111 1101 (invert bits)
               1111 1110 (add 1)
therefore: -2 = 1111 1110 (in two's complement)

2) Maintenant Convertir en Hex:

1111 = 0xF in hex
1110 = 0xE in hex

therefore: -2 = 1111 1110 = 0xFE.

Faire cela en Java

Maintenant que nous avons couvert le concept, vous constaterez que nous pouvons réaliser ce que nous voulons avec un simple masquage et décalage. La chose clé à comprendre est que l'octet que vous essayez de convertir est déjà dans le complément de deux. Vous ne faites pas cette conversion vous-même. Je pense que c'est un point de confusion majeur sur cette question. Prenons par exemple le tableau d'octets suivant:

byte[] bytes = new byte[]{-2,2};

Nous venons de les convertir manuellement en hex, ci-dessus, mais comment pouvons-nous le faire en Java? Voici comment:

Étape 1: Créez un StringBuffer pour contenir notre calcul.

StringBuffer buffer = new StringBuffer();

Étape 2: Isoler les bits d'ordre supérieur, les convertir en hexadécimal et les ajouter au tampon

Étant donné le nombre binaire 1111 1110, nous pouvons isoler les bits d'ordre supérieur en les décalant d'abord de 4, puis en mettant à zéro le reste du nombre. Logiquement c'est simple, cependant, les détails de l'implémentation en Java (et de nombreuses langues) introduisent une ride à cause de l'extension du signe. Essentiellement, lorsque vous décalez une valeur d'octet, Java convertit d'abord votre valeur en un entier, puis effectue une extension de signe. Donc, alors que vous vous attendez à ce que 1111 1110 > > 4 soit 0000 1111, en réalité, en Java, il est représenté comme le complément des deux 0xFFFFFFFF!

Revenons donc à notre exemple:

1111 1110 >> 4 (shift right 4) = 1111 1111 1111 1111 1111 1111 1111 1111 (32 bit sign-extended number in two's complement)

On peut alors isoler les bits avec un masque:

1111 1111 1111 1111 1111 1111 1111 1111 & 0xF = 0000 0000 0000 0000 0000 0000 0000 1111
therefore: 1111 = 0xF in hex. 

En Java, nous pouvons le faire tout en un tir:

Character.forDigit((bytes[0] >> 4) & 0xF, 16);

La fonction forDigit mappe simplement le nombre que vous lui transmettez sur l'ensemble des nombres hexadécimaux 0-F.

Étape 3: Ensuite, nous avons besoin d'isoler les bits d'ordre inférieur. Puisque les bits que nous voulons sont déjà dans la bonne position, nous pouvons simplement les masquer:

1111 1110 & 0xF = 0000 0000 0000 0000 0000 0000 0000 1110 (recall sign extension from before)
therefore: 1110 = 0xE in hex.  

Comme avant, en Java, nous pouvons le faire en un seul coup:

Character.forDigit((bytes[0] & 0xF), 16);

En mettant tout cela ensemble, nous pouvons le faire comme une boucle for et convertir l'ensemble du tableau:

for(int i=0; i < bytes.length; i++){
    buffer.append(Character.forDigit((bytes[i] >> 4) & 0xF, 16));
    buffer.append(Character.forDigit((bytes[i] & 0xF), 16));
}

Espérons-le cette explication rend les choses plus claires pour ceux d'entre vous qui se demandent exactement ce qui se passe dans les nombreux exemples que vous trouverez sur Internet. J'espère que je n'ai pas fait d'erreurs flagrantes, mais les suggestions et les corrections sont les bienvenues!

Lele plus rapide moyen que j'ai encore trouvé pour le faire est le suivant:

private static final String    HEXES    = "0123456789ABCDEF";

static String getHex(byte[] raw) {
    final StringBuilder hex = new StringBuilder(2 * raw.length);
    for (final byte b : raw) {
        hex.append(HEXES.charAt((b & 0xF0) >> 4)).append(HEXES.charAt((b & 0x0F)));
    }
    return hex.toString();
}

C'est ~ 50 fois plus rapide que String.format. si vous voulez le tester:

public class MyTest{
    private static final String    HEXES        = "0123456789ABCDEF";

    @Test
    public void test_get_hex() {
        byte[] raw = {
            (byte) 0xd0, (byte) 0x0b, (byte) 0x01, (byte) 0x2a, (byte) 0x63,
            (byte) 0x78, (byte) 0x01, (byte) 0x2e, (byte) 0xe3, (byte) 0x6c,
            (byte) 0xd2, (byte) 0xb0, (byte) 0x78, (byte) 0x51, (byte) 0x73,
            (byte) 0x34, (byte) 0xaf, (byte) 0xbb, (byte) 0xa0, (byte) 0x9f,
            (byte) 0xc3, (byte) 0xa9, (byte) 0x00, (byte) 0x1e, (byte) 0xd5,
            (byte) 0x4b, (byte) 0x89, (byte) 0xa3, (byte) 0x45, (byte) 0x35,
            (byte) 0xd6, (byte) 0x10,
        };

        int N = 77777;
        long t;

        {
            t = System.currentTimeMillis();
            for (int i = 0; i < N; i++) {
                final StringBuilder hex = new StringBuilder(2 * raw.length);
                for (final byte b : raw) {
                    hex.append(HEXES.charAt((b & 0xF0) >> 4)).append(HEXES.charAt((b & 0x0F)));
                }
                hex.toString();
            }
            System.out.println(System.currentTimeMillis() - t); // 50
        }

        {
            t = System.currentTimeMillis();
            for (int i = 0; i < N; i++) {
                StringBuilder hex = new StringBuilder(2 * raw.length);
                for (byte b : raw) {
                    hex.append(String.format("%02X", b));
                }
                hex.toString();
            }
            System.out.println(System.currentTimeMillis() - t); // 2535
        }

    }
}

Edit : Je viens de trouver quelque chose juste un peu plus rapide et qui tient sur une ligne mais qui n'est pas compatible avec JRE 9. Utiliser à vos risques et périls

import javax.xml.bind.DatatypeConverter;

DatatypeConverter.printHexBinary(raw);

Essayez de cette façon:

byte bv = 10;
String hexString = Integer.toHexString(bv);

Traitant du tableau (si je vous ai bien compris):

byte[] bytes = {9, 10, 11, 15, 16};
StringBuffer result = new StringBuffer();
for (byte b : bytes) {
    result.append(String.format("%02X ", b));
    result.append(" "); // delimiter
}
return result.toString();

Comme polygenelubricants mentionné, String.format() est la bonne réponse comparer à Integer.toHexString() (car il traite des nombres négatifs d'une bonne manière).

La meilleure solution est ce one-liner badass:

String hex=DatatypeConverter.printHexBinary(byte[] b);

Tel Que mentionné ici

, Si vous êtes heureux d'utiliser une bibliothèque externe, org.apache.commons.codec.binary.Hex class a encodeHex méthode qui prend un byte[] et retourne un char[]. Cette méthode est BEAUCOUP plus rapide que l'option format et encapsule les détails de la conversion. Est également livré avec une méthode decodeHex pour la conversion opposée.

Si vous voulez une représentation hexadécimale de largeur constante, c'est-à-dire 0A au lieu de A, afin que vous puissiez récupérer les octets sans ambiguïté, essayez format():

StringBuilder result = new StringBuilder();
for (byte bb : byteArray) {
    result.append(String.format("%02X", bb));
}
return result.toString();

C'est le code que j'ai trouvé pour exécuter le plus rapidement jusqu'à présent. Je l'ai exécuté sur des tableaux d'octets 109015 de longueur 32, en 23 ms. Je l'exécutais sur une machine virtuelle, donc il fonctionnera probablement plus vite sur du métal nu.

public static final char[] HEX_DIGITS =         {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};

public static char[] encodeHex( final byte[] data ){
    final int l = data.length;
    final char[] out = new char[l<<1];
    for( int i=0,j=0; i<l; i++ ){
        out[j++] = HEX_DIGITS[(0xF0 & data[i]) >>> 4];
        out[j++] = HEX_DIGITS[0x0F & data[i]];
    }
    return out;
}

Alors vous pouvez juste faire

String s = new String( encodeHex(myByteArray) );

BigInteger n = new BigInteger(byteArray);
String hexa = n.toString(16));

org.bouncycastle.util.encoders.Hex.toHexString(byteArray);

Ou

org.apache.commons.codec.binary.Hex.encodeHexString(byteArray);

D'autres ont couvert le cas général. Mais si vous avez un tableau d'octets d'une forme connue, par exemple une adresse MAC, vous pouvez alors:

byte[] mac = { (byte)0x00, (byte)0x00, (byte)0x00, (byte)0x00, (byte)0x00 };

String str = String.format("%02X:%02X:%02X:%02X:%02X:%02X",
                           mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]); 

Voici une fonction simple pour convertir l'octet en hexadécimal

   private static String convertToHex(byte[] data) {
    StringBuffer buf = new StringBuffer();
    for (int i = 0; i < data.length; i++) {
        int halfbyte = (data[i] >>> 4) & 0x0F;
        int two_halfs = 0;
        do {
            if ((0 <= halfbyte) && (halfbyte <= 9))
                buf.append((char) ('0' + halfbyte));
            else
                buf.append((char) ('a' + (halfbyte - 10)));
            halfbyte = data[i] & 0x0F;
        } while(two_halfs++ < 1);
    }
    return buf.toString();
}

Créer (et détruire) un tas d'instances String n'est pas un bon moyen si les performances sont un problème.

Veuillez ignorer ces arguments verbeux (en double) vérifiant les instructions (ifs). C'est à des fins (autres) éducatives.

Projet maven complet: http://jinahya.googlecode.com/svn/trunk/com.googlecode.jinahya/hex-codec/

Encodage...

/**
 * Encodes a single nibble.
 *
 * @param decoded the nibble to encode.
 *
 * @return the encoded half octet.
 */
protected static int encodeHalf(final int decoded) {

    switch (decoded) {
        case 0x00:
        case 0x01:
        case 0x02:
        case 0x03:
        case 0x04:
        case 0x05:
        case 0x06:
        case 0x07:
        case 0x08:
        case 0x09:
            return decoded + 0x30; // 0x30('0') - 0x39('9')
        case 0x0A:
        case 0x0B:
        case 0x0C:
        case 0x0D:
        case 0x0E:
        case 0x0F:
            return decoded + 0x57; // 0x41('a') - 0x46('f')
        default:
            throw new IllegalArgumentException("illegal half: " + decoded);
    }
}


/**
 * Encodes a single octet into two nibbles.
 *
 * @param decoded the octet to encode.
 * @param encoded the array to which each encoded nibbles are written.
 * @param offset the offset in the array.
 */
protected static void encodeSingle(final int decoded, final byte[] encoded,
                                   final int offset) {

    if (encoded == null) {
        throw new IllegalArgumentException("null encoded");
    }

    if (encoded.length < 2) {
        // not required
        throw new IllegalArgumentException(
            "encoded.length(" + encoded.length + ") < 2");
    }

    if (offset < 0) {
        throw new IllegalArgumentException("offset(" + offset + ") < 0");
    }

    if (offset >= encoded.length - 1) {
        throw new IllegalArgumentException(
            "offset(" + offset + ") >= encoded.length(" + encoded.length
            + ") - 1");
    }

    encoded[offset] = (byte) encodeHalf((decoded >> 4) & 0x0F);
    encoded[offset + 1] = (byte) encodeHalf(decoded & 0x0F);
}


/**
 * Decodes given sequence of octets into a sequence of nibbles.
 *
 * @param decoded the octets to encode
 *
 * @return the encoded nibbles.
 */
protected static byte[] encodeMultiple(final byte[] decoded) {

    if (decoded == null) {
        throw new IllegalArgumentException("null decoded");
    }

    final byte[] encoded = new byte[decoded.length << 1];

    int offset = 0;
    for (int i = 0; i < decoded.length; i++) {
        encodeSingle(decoded[i], encoded, offset);
        offset += 2;
    }

    return encoded;
}


/**
 * Encodes given sequence of octets into a sequence of nibbles.
 *
 * @param decoded the octets to encode.
 *
 * @return the encoded nibbles.
 */
public byte[] encode(final byte[] decoded) {

    return encodeMultiple(decoded);
}

Décodage...

/**
 * Decodes a single nibble.
 *
 * @param encoded the nibble to decode.
 *
 * @return the decoded half octet.
 */
protected static int decodeHalf(final int encoded) {

    switch (encoded) {
        case 0x30: // '0'
        case 0x31: // '1'
        case 0x32: // '2'
        case 0x33: // '3'
        case 0x34: // '4'
        case 0x35: // '5'
        case 0x36: // '6'
        case 0x37: // '7'
        case 0x38: // '8'
        case 0x39: // '9'
            return encoded - 0x30;
        case 0x41: // 'A'
        case 0x42: // 'B'
        case 0x43: // 'C'
        case 0x44: // 'D'
        case 0x45: // 'E'
        case 0x46: // 'F'
            return encoded - 0x37;
        case 0x61: // 'a'
        case 0x62: // 'b'
        case 0x63: // 'c'
        case 0x64: // 'd'
        case 0x65: // 'e'
        case 0x66: // 'f'
            return encoded - 0x57;
        default:
            throw new IllegalArgumentException("illegal half: " + encoded);
    }
}


/**
 * Decodes two nibbles into a single octet.
 *
 * @param encoded the nibble array.
 * @param offset the offset in the array.
 *
 * @return decoded octet.
 */
protected static int decodeSingle(final byte[] encoded, final int offset) {

    if (encoded == null) {
        throw new IllegalArgumentException("null encoded");
    }

    if (encoded.length < 2) {
        // not required
        throw new IllegalArgumentException(
            "encoded.length(" + encoded.length + ") < 2");
    }

    if (offset < 0) {
        throw new IllegalArgumentException("offset(" + offset + ") < 0");
    }

    if (offset >= encoded.length - 1) {
        throw new IllegalArgumentException(
            "offset(" + offset + ") >= encoded.length(" + encoded.length
            + ") - 1");
    }

    return (decodeHalf(encoded[offset]) << 4)
           | decodeHalf(encoded[offset + 1]);
}


/**
 * Encodes given sequence of nibbles into a sequence of octets.
 *
 * @param encoded the nibbles to decode.
 *
 * @return the encoded octets.
 */
protected static byte[] decodeMultiple(final byte[] encoded) {

    if (encoded == null) {
        throw new IllegalArgumentException("null encoded");
    }

    if ((encoded.length & 0x01) == 0x01) {
        throw new IllegalArgumentException(
            "encoded.length(" + encoded.length + ") is not even");
    }

    final byte[] decoded = new byte[encoded.length >> 1];

    int offset = 0;
    for (int i = 0; i < decoded.length; i++) {
        decoded[i] = (byte) decodeSingle(encoded, offset);
        offset += 2;
    }

    return decoded;
}


/**
 * Decodes given sequence of nibbles into a sequence of octets.
 *
 * @param encoded the nibbles to decode.
 *
 * @return the decoded octets.
 */
public byte[] decode(final byte[] encoded) {

    return decodeMultiple(encoded);
}

Je ne pouvais pas comprendre ce que vous vouliez dire exactement par chaîne d'octets, mais voici quelques conversions d'octet en chaîne et vice versa, bien sûr, il y a beaucoup plus sur les documentations officielles

Integer intValue = 149;

La valeur d'octet correspondante est:

Byte byteValue = intValue.byteValue(); // this will convert the rightmost byte of the intValue to byte, because Byte is an 8 bit object and Integer is at least 16 bit, and it will give you a signed number in this case -107

Récupère la valeur entière à partir d'une variable Octet:

Integer anInt = byteValue.intValue(); // This will convert the byteValue variable to a signed Integer

De l'octet et de l'entier à la chaîne hexadécimale:
C'est la façon dont je le fais:

Integer anInt = 149
Byte aByte = anInt.byteValue();

String hexFromInt = "".format("0x%x", anInt); // This will output 0x95
String hexFromByte = "".format("0x%x", aByte); // This will output 0x95

La Conversion d'un tableau d'octets en une chaîne hexadécimale:
Comme pour autant que je sache, il n'y a pas de fonction simple pour convertir tous les éléments à l'intérieur d'un tableau de certains Object en éléments d'un autre Object, vous devez donc le faire vous-même. Vous pouvez utiliser les fonctions suivantes:

De l'octet [] à la chaîne:

    public static String byteArrayToHexString(byte[] byteArray){
        String hexString = "";

        for(int i = 0; i < byteArray.length; i++){
            String thisByte = "".format("%x", byteArray[i]);
            hexString += thisByte;
        }

        return hexString;
    }

Et de la chaîne hexadécimale à l'octet[]:

public static byte[] hexStringToByteArray(String hexString){
    byte[] bytes = new byte[hexString.length() / 2];

    for(int i = 0; i < hexString.length(); i += 2){
        String sub = hexString.substring(i, i + 2);
        Integer intVal = Integer.parseInt(sub, 16);
        bytes[i / 2] = intVal.byteValue();
        String hex = "".format("0x%x", bytes[i / 2]);
    }

    return bytes;
}  

Il est trop tard mais j'espère que cela pourrait aider d'autres ;)

C'est un moyen très rapide. Pas besoin de bibliothèques externes.

final protected static char[] HEXARRAY = "0123456789abcdef".toCharArray();

    public static String encodeHexString( byte[] bytes ) {

        char[] hexChars = new char[bytes.length * 2];
        for (int j = 0; j < bytes.length; j++) {
            int v = bytes[j] & 0xFF;
            hexChars[j * 2] = HEXARRAY[v >>> 4];
            hexChars[j * 2 + 1] = HEXARRAY[v & 0x0F];
        }
        return new String(hexChars);
    }

Il y a votre méthode rapide:

    private static final String[] hexes = new String[]{
        "00","01","02","03","04","05","06","07","08","09","0A","0B","0C","0D","0E","0F",
        "10","11","12","13","14","15","16","17","18","19","1A","1B","1C","1D","1E","1F",
        "20","21","22","23","24","25","26","27","28","29","2A","2B","2C","2D","2E","2F",
        "30","31","32","33","34","35","36","37","38","39","3A","3B","3C","3D","3E","3F",
        "40","41","42","43","44","45","46","47","48","49","4A","4B","4C","4D","4E","4F",
        "50","51","52","53","54","55","56","57","58","59","5A","5B","5C","5D","5E","5F",
        "60","61","62","63","64","65","66","67","68","69","6A","6B","6C","6D","6E","6F",
        "70","71","72","73","74","75","76","77","78","79","7A","7B","7C","7D","7E","7F",
        "80","81","82","83","84","85","86","87","88","89","8A","8B","8C","8D","8E","8F",
        "90","91","92","93","94","95","96","97","98","99","9A","9B","9C","9D","9E","9F",
        "A0","A1","A2","A3","A4","A5","A6","A7","A8","A9","AA","AB","AC","AD","AE","AF",
        "B0","B1","B2","B3","B4","B5","B6","B7","B8","B9","BA","BB","BC","BD","BE","BF",
        "C0","C1","C2","C3","C4","C5","C6","C7","C8","C9","CA","CB","CC","CD","CE","CF",
        "D0","D1","D2","D3","D4","D5","D6","D7","D8","D9","DA","DB","DC","DD","DE","DF",
        "E0","E1","E2","E3","E4","E5","E6","E7","E8","E9","EA","EB","EC","ED","EE","EF",
        "F0","F1","F2","F3","F4","F5","F6","F7","F8","F9","FA","FB","FC","FD","FE","FF"
    };

    public static String byteToHex(byte b) {
        return hexes[b&0xFF];
    }

Utiliser

Integer.toHexString((int)b);