Comment faire pour convertir un tableau d'octets en une chaîne hexadécimale en Java?

J'ai un tableau d'octets rempli avec les nombres hexadécimaux et de l'imprimer le plus simple est assez inutile, car il existe de nombreux éléments non imprimables. Ce dont j'ai besoin est l'exact hexadécimal sous la forme de: 3a5f771c

Pourquoi ne pas juste faire un essai d'abord nous montrer ce que vous avez. Vous n'avez rien à perdre et tout à gagner. Entier a une toHexString(...) méthode qui peut aider si c'est ce que vous cherchez. Aussi String.format(...) peut faire bien des astuces de mise en forme à l'aide de la %2x chaîne de code.
double possible de En Java, comment puis-je convertir un tableau d'octets en une chaîne de chiffres hexadécimaux, tout en gardant les zéros?
"Ce dont j'ai besoin est l'exact hexadécimal sous la forme de: 3a5f771c..." - vous avez demandé une forme exacte, mais vous n'avez pas de fournir un exemple précis. Va sur ce que vous avez fournis, convertir les quatre premiers octets d'une chaîne de caractères, puis concaténer les points de suspension à la chaîne.
Avec l'aide de flux en Java 8, il peut simplement être mis en œuvre comme: static String byteArrayToHex(byte[] a) { return IntStream.range(0, un.la longueur) .mapToObj(i -> String.format("%02x", a[i])) .réduire((acc, v) -> acc + "" + v) .get(); }

InformationsquelleAutor Andre | 2012-03-11

853

De la discussion ici, et surtout cette réponse, c'est la fonction que j'utilise actuellement:
```
private static final char[] HEX_ARRAY = "0123456789ABCDEF".toCharArray();
public static String bytesToHex(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] = HEX_ARRAY[v >>> 4];
        hexChars[j * 2 + 1] = HEX_ARRAY[v & 0x0F];
    }
    return new String(hexChars);
}
```
Mon petit repères (un million d'octets d'un millier de fois, 256 octets de 10 millions de fois) ont montré qu'il est beaucoup plus rapide que n'importe quel autre, environ la moitié du temps sur le long de tableaux. Par rapport à la réponse je l'ai pris de, le passage à la bit-à-bit de la fpo --- comme il est suggéré dans la discussion --- réduire d'environ 20% du temps pour les longs tableaux. (Edit: Quand je dis que c'est plus rapide que les autres solutions, je veux dire le code alternatif offert dans les discussions. La Performance est l'équivalent de Communes Codec, qui utilise le même code.)
- Je viens de trouver javax.xml.bind.DataTypeConverter, une partie de la distribution standard. Pourquoi ne pas venir quand vous Google ce genre de problème? Beaucoup d'outils utiles, y compris String printHexBinary(byte[]) et byte[] parseHexBinary(String). printHexBinary est, cependant, beaucoup (2x) plus lent que la fonction de cette réponse. (J'ai vérifié la source; il utilise un stringBuilder. parseHexBinary utilise un tableau.) Vraiment, si, pour la plupart des fins, elle est assez rapide et vous avez probablement déjà.
- +1 pour la réponse depuis Android n'a pas DataTypeConverter
- JDK 7 est maintenant open source. On doit soumettre un patch pour améliorer les performances de printHexBinary?
- pourriez-vous expliquer comment cela fonctionne. J'ai suivi pour la plupart, mais vraiment comme la compréhension de ce qui se passe lors de l'utilisation de code. Merci!
- Ce code est super rapide!! J'ai été en utilisant String.format("%0" + (bytes.length << 1) + "X", new BigInteger(1, bytes)); mais la performance était de la foutaise. C'est une bien meilleure solution.
- Comment à l'inverse c'est à dire étant Donné une Chaîne Hexadécimale obtenir byte[] à partir de la Chaîne ?
- Pour l'inverse, voir: stackoverflow.com/a/140861/1284661
- Cette réponse a de plus en plus vite bytes2hex stackoverflow.com/a/21429909/185565
- Hmm, comment êtes-vous benchmarking-il? Dans mes critères de référence de la vitesse de l'air exactement la même, ce qui est logique, car chacun a le même numéro d'index de tableau les recherches et le même nombre d'opérations. Quels sont les avantages que vous obtenez de la plus grande table?
- Super réponse! Une infime augmentation de la performance pourraient être obtenus par l'ajout d'une variable pour n * 2 à être utilisé dans le premier tableau de l'index, puis ++n dans le second accès.
- Cette solution est meilleure que DataTypeConverter solution, car il utilise des StringBuilder qui inturn utilise char[] et à se développer.Si nous connaissons la taille de l'avance je me sens char[] est une excellente option
- Est-ce code de travail pour les octets de la valeur? bcz j'obtiens une valeur qui est hors de portée pour octet, lors de l'octet de valeur est négative.
- javax.xml.bind.DataTypeConverter est retiré de Java 11.
- Pourquoi est - & 0xFF nécessaire dans cette ligne int v = bytes[j] & 0xFF;? Ai-je raté quelque chose ou est-ce inutile?
- Que Java a signé nombre de primitives, de sorte qu'un octet que vous imaginez que 0xFF sera considéré comme négatif. Un index de tableau est toujours de type int, et seulement à l'aide de la variable d'octet comme un indice de la position fera la même chose que la méthode n'est en l'affectant à des int v: Le négatif octet sera élargie - l'int sera plein de bits. Vous auriez pas demander l'index de tableau 15, mais quelque chose dans les millions.
- Parfois, vous avez besoin d'espaces, puis utilisez bytes.length * 3, hexChars[j * 3], hexChars[j * 3 + 1] et hexChars[j * 3 + 2] = 0x20
InformationsquelleAutor maybeWeCouldStealAVan
390

La Apache Commons Codec la bibliothèque dispose d'un Hex classe pour faire ce genre de travail.
```
import org.apache.commons.codec.binary.Hex;

String foo = "I am a string";
byte[] bytes = foo.getBytes();
System.out.println( Hex.encodeHexString( bytes ) );
```
- Mon downvote s'est produite il y a 4 mois donc je ne suis pas tout à fait certaine de ce que je pensais, mais j'étais probablement s'opposer à la taille de la bibliothèque. C'est une petite fonction dans le programme; il n'y a pas besoin d'ajouter une volumineuse bibliothèque pour le projet à réaliser.
- Je suis d'accord, donc au lieu de import org.apache.commons.codec.*; vous pourriez faire import org.apache.commons.codec.binary.Hex;
- Je suis en désaccord. La seule chose terrible, c'est que l'apache commons bibliothèques ne sont pas inclus par défaut avec le JRE et JDK. Il y a quelques bibliothèques qui sont très utiles, ils devraient vraiment être sur votre chemin de classe par défaut, et c'est l'un d'entre eux.
- Je recommande fortement cette réponse est échangé que la réponse sommet. Toujours voter pour utiliser un bien testé, performant, bibliothèque open source sur le code personnalisé qui permet de ne pas l'améliorer.
- Lors de l'utilisation de sbt ou maven, l'ajout d'un open-source de dépendance, comme c'est mort-facile.
- Aussi, commons-codec-1.9.jar 258 Kio, et je suppose que l'espace d'impact peut aller plus loin si vous allez utiliser Proguard ou quelque chose comme ça.
- De ne pas renouveler une vieille thread faussement, mais comme l'ajout de la documentation de référence pour l'avenir: même travail pour certains très grands et plus particulièrement des entreprises, la licence Apache a été jugé acceptable pour l'utilisation de nos produits. À mon humble avis, si vous ne pouvez pas tomber rapidement dans/gérer la 3e partie des dépendances de votre projet, pour des cas comme cela, alors vous n'avancent pas assez vite.
- +1 pour suggérant une étagère de la bibliothèque, pour ne point cette méthode retourne un char tableau[] plutôt qu'une chaîne, qui s'est déclenché-moi un peu. (et la méthode semble maintenant 'encodeHex" plutôt que de "encodeHexString' - pourrait être juste la version que j'utilise tout de même).
- Au moment où j'ai écrit qu'il y avait des méthodes pour encodeHex et encodeHexString, même si ce peut être différent maintenant.
- Ou dans le cas où vous utilisez BouncyCastle (org.bouncycastle:bcprov-jdk15on), vous pouvez utiliser cette classe : org.bouncycastle.util.encoders.Hex, avec cette méthode : String toHexString(byte[] data)
InformationsquelleAutor chooban
312

La méthode javax.xml.bind.DatatypeConverter.printHexBinary(), une partie de la Java Architecture for XML Binding (JAXB), était un moyen pratique pour convertir un byte[] chaîne hexadécimale. Le DatatypeConverter classe également inclus de nombreuses autres données utiles méthodes de manipulation.

Dans Java 8 et les versions antérieures, JAXB faisait partie de la Java standard de la bibliothèque. Il a été obsolète avec Java 9 et supprimé avec Java 11, dans le cadre d'un effort pour déplacer tous les Java EE des paquets dans leurs propres bibliothèques. C'est une longue histoire. Maintenant, javax.xml.bind n'existe pas, et si vous voulez utiliser JAXB, qui contient DatatypeConverter, vous aurez besoin pour installer le API JAXB et JAXB d'Exécution de Maven.

Exemple d'utilisation:
```
byte bytes[] = {(byte)0, (byte)0, (byte)134, (byte)0, (byte)61};
String hex = javax.xml.bind.DatatypeConverter.printHexBinary(bytes);
```
Permettra:
```
000086003D
```
Que cette réponse est la même que cette une.
- Une bonne solution, mais malheureusement pas celui qui est valide dans Android.
- peut-être que vous voulez lire code.google.com/p/dalvik/wiki/JavaxPackages. C'est un moyen d'obtenir javax classes dans Android. Mais si vous voulez les convertir en hexadécimal, il ne vaut pas la peine.
- Tout il y a des commentaires sur le rapport performances / la accepté de répondre. C'est évidemment beaucoup plus simple.
- Win7-iCore5-430M)-JDK1.7.0_11: 60 octets d'entrée, 100000 boucles -> accepté MaybeWeCouldStealAva réponse=90ms. DatatypeConverter.printHexBinary=190ms.
- En Plus d'un nouveau Higginse réponse=62ms. stackoverflow.com/a/21429909/185565
- DatatypeConverter n'est plus accessible dès le JDK 9
- Pourquoi avez-vous dit? Au moins dans les docs de l'API, il est toujours là: docs.oracle.com/javase/9/docs/api/javax/xml/bind/...
- Il est toujours là, mais ne faisant pas partie de l'environnement d'exécution par défaut (en raison de Java 9 modules).
- ne comptez pas sur javax.xml.lier, il compile bien, mais peut-être pas être trouvé lors de l'exécution. si vous le faites, être prêt à gérer java.lang.NoClassDefFoundError
InformationsquelleAutor PhoneixS
210

Solution la plus simple, pas de libs externes, pas de chiffres constantes:
```
public static String byteArrayToHex(byte[] a) {
   StringBuilder sb = new StringBuilder(a.length * 2);
   for(byte b: a)
      sb.append(String.format("%02x", b));
   return sb.toString();
}
```
- C'est très lente, en moyenne 1000 fois plus lent (pour 162 octets de long) que l'une au dessus de réponse. Évitez d'utiliser de la Chaîne.Format si la performance est importante.
- Peut-être que lente. C'est bon pour des choses se produire occasionnellement, comme login ou similaire.
- Pas "peut-être lent, mais très très efficace. Si vous souhaitez utiliser lente code, à moins de les réutiliser (ne pas copier+coller) d'une bibliothèque existante qui a une suite de tests.
- Si c'est lent, et alors? Dans mon cas d'utilisation, c'est juste pour une instruction de débogage, donc merci pour ce fragment de code.
- La réutilisation d'une bibliothèque, en y incluant un extra de fichiers JAR de plusieurs dizaines de ko ne serait pas exactement être efficace si vous avez besoin de cette fonction (sur certaines plates-formes comme Android, le Pot est inclus dans la fin de l'application). Et parfois, plus court et plus clair code est mieux quand la performance n'est pas nécessaire.
- peut-être, mais dans ce cas, vous avez besoin de flux de soutien, pas un seul appel de fonction. c'est facile à comprendre et à mémoriser, et donc à maintenir.
InformationsquelleAutor Pointer Null
53

Une Goyave solution, par souci d'exhaustivité:
```
import com.google.common.io.BaseEncoding;
...
byte[] bytes = "Hello world".getBytes(StandardCharsets.UTF_8);
final String hex = BaseEncoding.base16().lowerCase().encode(bytes);
```
Maintenant hex est "48656c6c6f20776f726c64".
- Dans la Goyave vous pouvez également utiliser new HashCode(bytes).toString().
- Comme de Goyave 22.0 il est HashCode.fromBytes(checksum).toString()
InformationsquelleAutor Stephan202
40

Cette simple oneliner fonctionne pour moi

String result = new BigInteger(1, inputBytes).toString(16);

MODIFIER - grâce à cette volonté de supprimer les zéros, mais bon fonctionné pour mon cas d'utilisation. Merci @Voicu pour le pointant hors
- Ce oneliner gouttes de zéro octets.
- Et il va ajouter un zéro à 50% du temps.
InformationsquelleAutor everconfusedGuy
25

Utilisation DataTypeConverter classejavax.xml.bind.DataTypeConverter

String hexString = DatatypeConverter.printHexBinary(bytes[] raw);
- Classe supprimée en Java 11. Voir: JEP 320: Supprimer la Java EE et CORBA Modules
InformationsquelleAutor Coral
17

J'ai trouvé trois façons différentes ici:
http://www.rgagnon.com/javadetails/java-0596.html

Le plus élégant, comme il le note également, je pense, est celui-ci:
```
static final String HEXES = "0123456789ABCDEF";
public static String getHex( byte [] raw ) {
    if ( raw == null ) {
        return null;
    }
    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();
}
```
- D'autres méthodes ont été en cours d'exécution sur mon 64 octets par échantillon de 5ms, celui-ci fonctionne en 0ms. Probablement le meilleur de l'absence de toute les autres fonctions de Chaîne de format.
- if (raw == null) return null n'est pas échouer rapidement. Pourquoi voudriez-vous jamais utiliser un null clé?
- Je suppose que c'est une habitude à l'entrée de valider. Dans ce cas, nous prévenir toute référence Nulle exception, et laisse à l'appelant pour gérer les données de mauvaise qualité.
InformationsquelleAutor Michael Bisbjerg
17

Je voudrais utiliser quelque chose comme ceci pour une durée déterminée, comme les hachages:
```
md5sum = String.format("%032x", new BigInteger(1, md.digest()));
```
- Merci, c'est tellement savoureux et appropriée.
InformationsquelleAutor Usagi Miyamoto

Au petit coût de stockage de la table de recherche de cette mise en œuvre est simple et très rapide.

 private static final char[] BYTE2HEX=(
    "000102030405060708090A0B0C0D0E0F"+
    "101112131415161718191A1B1C1D1E1F"+
    "202122232425262728292A2B2C2D2E2F"+
    "303132333435363738393A3B3C3D3E3F"+
    "404142434445464748494A4B4C4D4E4F"+
    "505152535455565758595A5B5C5D5E5F"+
    "606162636465666768696A6B6C6D6E6F"+
    "707172737475767778797A7B7C7D7E7F"+
    "808182838485868788898A8B8C8D8E8F"+
    "909192939495969798999A9B9C9D9E9F"+
    "A0A1A2A3A4A5A6A7A8A9AAABACADAEAF"+
    "B0B1B2B3B4B5B6B7B8B9BABBBCBDBEBF"+
    "C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF"+
    "D0D1D2D3D4D5D6D7D8D9DADBDCDDDEDF"+
    "E0E1E2E3E4E5E6E7E8E9EAEBECEDEEEF"+
    "F0F1F2F3F4F5F6F7F8F9FAFBFCFDFEFF").toCharArray();
   ; 

  public static String getHexString(byte[] bytes) {
    final int len=bytes.length;
    final char[] chars=new char[len<<1];
    int hexIndex;
    int idx=0;
    int ofs=0;
    while (ofs<len) {
      hexIndex=(bytes[ofs++] & 0xFF)<<1;
      chars[idx++]=BYTE2HEX[hexIndex++];
      chars[idx++]=BYTE2HEX[hexIndex];
    }
    return new String(chars);
  }

Pourquoi ne pas initialiser le BYTE2HEX tableau avec une simple for cycle?
Si, c'est possible avec un static final (aka constante) champ?
Il peut être affecté dans un static { } bloc.
car son plus rapide de coder en dur une table de recherche que pour le générer. Ici, la mémoire de la complexité est négocié avec le temps, la complexité, c'est à dire. besoin de plus de mémoire, mais plus rapide (tous les légèrement sur les deux extrémités)

InformationsquelleAutor higginse

12

Voici quelques options commandées à partir de la simple (one-liner) aux plus complexes (l'immense bibliothèque). Si vous êtes intéressé par les performances, voir la micro-benchmarks ci-dessous.

Option 1: extrait de Code - Simple

Une solution très simple est d'utiliser le BigInteger's représentation hexadécimale:
```
new BigInteger(1, someByteArray).toString(16)
```
Noter que depuis cette poignées numéros de pas arbitraire octet-chaînes il va ignorer les zéros en tête - cela peut ou peut ne pas être ce que vous voulez (par exemple 000AE3 vs 0AE3 pour un 3 octet d'entrée). C'est aussi très lent, sur 100x plus lent par rapport à l'option suivante.

Option 2: extrait de Code Avancé

Ici est un complet, copie & pasteable extrait du code de l'appui majuscules/minuscules et stockage. Il est optimisé pour minimiser la mémoire de la complexité et de maximiser la performance et devrait être compatible avec tous les versions de Java (5+).
```
private static final char[] LOOKUP_TABLE_LOWER = new char[]{0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66};
private static final char[] LOOKUP_TABLE_UPPER = new char[]{0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46};
public static String encode(byte[] byteArray, boolean upperCase, ByteOrder byteOrder) {
//our output size will be exactly 2x byte-array length
final char[] buffer = new char[byteArray.length * 2];
//choose lower or uppercase lookup table
final char[] lookup = upperCase ? LOOKUP_TABLE_UPPER : LOOKUP_TABLE_LOWER;
int index;
for (int i = 0; i < byteArray.length; i++) {
//for little endian we count from last to first
index = (byteOrder == ByteOrder.BIG_ENDIAN) ? i : byteArray.length - i - 1;
//extract the upper 4 bit and look up char (0-A)
buffer[i << 1] = lookup[(byteArray[index] >> 4) & 0xF];
//extract the lower 4 bit and look up char (0-A)
buffer[(i << 1) + 1] = lookup[(byteArray[index] & 0xF)];
}
return new String(buffer);
}
public static String encode(byte[] byteArray) {
return encode(byteArray, false, ByteOrder.BIG_ENDIAN);
}
```
Le code source complet avec Apache v2 licence et le décodeur peut être trouvé ici.

Option 3: à l'Aide d'une petite bibliothèque optimisée: octets-java

Tout en travaillant sur mon projet précédent, j'ai créé cette petite trousse d'outils pour travailler avec des octets en Java. Il n'a pas de dépendances externes et est compatible avec Java 7+. Il comprend, entre autres, un très rapide et bien testé HEX fr/décodeur:
```
import at.favre.lib.bytes.Bytes;
...
Bytes.wrap(someByteArray).encodeHex()
```
Vous pouvez le vérifier sur Github: octets-java.

Option 4: Apache Commons Codec

Bien sûr il y a le bon vieux communes codecs. (d'alerte de l'opinion à l'avance) Tout en travaillant sur le projet décrit ci-dessus j'ai analysé le code et a été très déçu; beaucoup de double non-syndiqués code, obsolète et exotiques codecs probablement utile uniquement pour de très rares et tout à fait sur d'ingénierie et de ralentir les implémentations de populaires codecs (plus précisément en Base64). Par conséquent, je voudrais prendre une décision éclairée si vous voulez les utiliser, ou d'un autre. De toute façon, si vous voulez continuer à l'utiliser, voici un extrait de code:
```
import org.apache.commons.codec.binary.Hex;
...
Hex.encodeHexString(someByteArray));
```
Option 5: Google Goyave

Plus souvent que vous ne possédez pas déjà Goyave comme une dépendance. Si juste utiliser:
```
import com.google.common.io.BaseEncoding;
...
BaseEncoding.base16().lowerCase().encode(someByteArray);
```
Option 6: Le Printemps De Sécurité

Si vous utilisez le Spring framework avec Printemps De Sécurité vous pouvez utiliser les éléments suivants:
```
import org.springframework.security.crypto.codec.Hex
...
new String(Hex.encode(someByteArray));
```
Option 7: Château Gonflable

Si vous utilisez déjà le cadre de la sécurité Château Gonflable vous pouvez utiliser ses Hex util:
```
import org.bouncycastle.util.encoders.Hex;
...
Hex.toHexString(someByteArray);
```
Pas Vraiment l'Option 8: Java 9+ Compatibilité ou "Ne Pas Utiliser JAXBs javax/xml/bind/DatatypeConverter'

Précédentes de Java (8 et ci-dessous) versions du code Java pour JAXB a été inclus à titre d'exécution de la dépendance. Depuis Java 9 et Jigsaw modularisation votre code ne peut pas accéder à un autre code à l'extérieur du module sans déclaration explicite. Donc, être conscient que si vous obtenez une exception comme:
```
java.lang.NoClassDefFoundError: javax/xml/bind/JAXBException
```
lors de l'exécution sur une machine virtuelle java avec Java 9+. Si oui, alors l'interrupteur implémentations à l'une des alternatives ci-dessus. Voir aussi ce question.

Micro Repères

Voici les résultats à partir d'un simple JMH micro de référence de l'encodage tableaux d'octets de différentes tailles. Les valeurs sont des opérations par seconde, de sorte plus c'est mieux.
Notez que les micro-benchmarks, très souvent, ne représentent pas le monde réel comportement, afin de prendre ces résultats avec un grain de sel.
```
| Name (ops/s)         |    16 byte |    32 byte |  128 byte | 0.95 MB |
|---------------------- | -----------:|-----------:|----------:|--------:|
| Opt1: BigInteger     |  2,088,514 |  1,008,357 |   133,665 |       4 |
| Opt2/3: Bytes Lib    | 20,423,170 | 16,049,841 | 6,685,522 |     825 |
| Opt4: Apache Commons | 17,503,857 | 12,382,018 | 4,319,898 |     529 |
| Opt5: Guava          | 10,177,925 |  6,937,833 | 2,094,658 |     257 |
| Opt6: Spring         | 18,704,986 | 13,643,374 | 4,904,805 |     601 |
| Opt7: BC             |  7,5016,66 |  3,674,422 | 1,077,236 |     152 |
| Opt8: JAX-B          | 13,497,736 |  8,312,834 | 2,590,940 |     346 |
```
Spécifications: JDK 8u202, i7-7700K, Win10, 24GO de Ram. Voir l'intégralité de l'indice de référence ici.

InformationsquelleAutor patrickf

Comment à ce sujet?

    String byteToHex(final byte[] hash)
{
Formatter formatter = new Formatter();
for (byte b : hash)
{
formatter.format("%02x", b);
}
String result = formatter.toString();
formatter.close();
return result;
}

InformationsquelleAutor Manan Bakshi

Je préfère utiliser ce:

final protected static char[] hexArray = "0123456789ABCDEF".toCharArray();
public static String bytesToHex(byte[] bytes, int offset, int count) {
char[] hexChars = new char[count * 2];
for ( int j = 0; j < count; j++ ) {
int v = bytes[j+offset] & 0xFF;
hexChars[j * 2] = hexArray[v >>> 4];
hexChars[j * 2 + 1] = hexArray[v & 0x0F];
}
return new String(hexChars);
}

Il est légèrement plus grande souplesse d'adaptation de la accepté de répondre.
Personnellement, je garde les deux accepté de répondre et cette surcharge avec elle, utilisable dans d'autres contextes.

La question initiale était de type byte[] à la Chaîne. Regarder hex d'octets[] ou de poser une autre question, @Inexistant.

InformationsquelleAutor Bamaco

2

J'ai l'habitude d'utiliser la méthode suivante pour debuf déclaration, mais je ne sais pas si c'est la meilleure façon de faire ou de ne pas
```
private static String digits = "0123456789abcdef";
public static String toHex(byte[] data){
StringBuffer buf = new StringBuffer();
for (int i = 0; i != data.length; i++)
{
int v = data[i] & 0xff;
buf.append(digits.charAt(v >> 4));
buf.append(digits.charAt(v & 0xf));
}
return buf.toString();
}
```
- Si votre debuffer a une mauvaise journée, essayez cluing dans StringBuilder instanciation avec un nombre de caractères à prendre en charge: StringBuilder buf = new StringBuilder(data.length * 2);.
InformationsquelleAutor Snox
2

Ok, donc il y a des tas de façons de le faire, mais si vous décidez d'utiliser une bibliothèque je suggère de fouiller dans votre projet pour voir si quelque chose a été mis en place dans une bibliothèque qui fait déjà partie de votre projet avant d'ajouter une nouvelle bibliothèque juste pour ce faire. Par exemple, si vous ne l'avez pas déjà

org.apache.commons.codec.binaires.Hex

peut-être que vous avez...

org.apache.xerces.impl.dv.util.HexBin

InformationsquelleAutor Aaron Cooley

Si vous utilisez le Printemps du cadre de la Sécurité, vous pouvez utiliser:

import org.springframework.security.crypto.codec.Hex
final String testString = "Test String";
final byte[] byteArray = testString.getBytes();
System.out.println(Hex.encode(byteArray));

InformationsquelleAutor java-addict301

L'ajout d'un utilitaire jar pour simple fonction n'est pas une bonne option. Au lieu d'assembler des classes utilitaires. la suite est possible, la mise en œuvre rapide.

public class ByteHex {
public static int hexToByte(char ch) {
if ('0' <= ch && ch <= '9') return ch - '0';
if ('A' <= ch && ch <= 'F') return ch - 'A' + 10;
if ('a' <= ch && ch <= 'f') return ch - 'a' + 10;
return -1;
}
private static final String[] byteToHexTable = 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"
};
private static final String[] byteToHexTableLowerCase = 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 byteToHexTable[b & 0xFF];
}
public static String byteToHex(byte[] bytes){
if(bytes == null) return null;
StringBuilder sb = new StringBuilder(bytes.length*2);
for(byte b : bytes) sb.append(byteToHexTable[b & 0xFF]);
return sb.toString();
}
public static String byteToHex(short[] bytes){
StringBuilder sb = new StringBuilder(bytes.length*2);
for(short b : bytes) sb.append(byteToHexTable[((byte)b) & 0xFF]);
return sb.toString();
}
public static String byteToHexLowerCase(byte[] bytes){
StringBuilder sb = new StringBuilder(bytes.length*2);
for(byte b : bytes) sb.append(byteToHexTableLowerCase[b & 0xFF]);
return sb.toString();
}
public static byte[] hexToByte(String hexString) {
if(hexString == null) return null;
byte[] byteArray = new byte[hexString.length() / 2];
for (int i = 0; i < hexString.length(); i += 2) {
byteArray[i / 2] = (byte) (hexToByte(hexString.charAt(i)) * 16 + hexToByte(hexString.charAt(i+1)));
}
return byteArray;
}
public static byte hexPairToByte(char ch1, char ch2) {
return (byte) (hexToByte(ch1) * 16 + hexToByte(ch2));
}
}

InformationsquelleAutor krishna Telgave

Une petite variante de la solution proposée par @maybewecouldstealavan, qui vous permet de visuellement faisceau de N octets ensemble en sortie de chaîne hexadécimale:

 final static char[] HEX_ARRAY = "0123456789ABCDEF".toCharArray();
final static char BUNDLE_SEP = ' ';
public static String bytesToHexString(byte[] bytes, int bundleSize /*[bytes]*/]) {
char[] hexChars = new char[(bytes.length * 2) + (bytes.length / bundleSize)];
for (int j = 0, k = 1; j < bytes.length; j++, k++) {
int v = bytes[j] & 0xFF;
int start = (j * 2) + j/bundleSize;
hexChars[start] = HEX_ARRAY[v >>> 4];
hexChars[start + 1] = HEX_ARRAY[v & 0x0F];
if ((k % bundleSize) == 0) {
hexChars[start + 2] = BUNDLE_SEP;
}   
}   
return new String(hexChars).trim();    
}

Qui est:

bytesToHexString("..DOOM..".toCharArray().getBytes(), 2);
2E2E 444F 4F4D 2E2E
bytesToHexString("..DOOM..".toCharArray().getBytes(), 4);
2E2E444F 4F4D2E2E

InformationsquelleAutor Campa

Ne trouve pas de solution sur cette page qui n'a pas

Utiliser une boucle
Utilisation javax.xml.bind.DatatypeConverter qui compile bien, mais souvent throws java.lang.NoClassDefFoundError au moment de l'exécution.

Voici une solution qui n'a pas les défauts ci-dessus(pas de promesses, mine de ne pas avoir d'autres défauts tout de même)

import java.math.BigInteger;
import static java.lang.System.out;
public final class App2 {
//| proposed solution.
public static String encode(byte[] bytes) {          
final int length = bytes.length;
//| BigInteger constructor throws if it is given an empty array.
if (length == 0) {
return "00";
}
final int evenLength = (int)(2 * Math.ceil(length / 2.0));
final String format = "%0" + evenLength + "x";         
final String result = String.format (format, new BigInteger(bytes));
return result;
}
public static void main(String[] args) throws Exception {
//00
out.println(encode(new byte[] {})); 
//01
out.println(encode(new byte[] {1})); 
//203040
out.println(encode(new byte[] {0x20, 0x30, 0x40})); 
//416c6c20796f75722062617365206172652062656c6f6e6720746f2075732e
out.println(encode("All your base are belong to us.".getBytes()));
}
}

Je ne pouvais pas obtenir ce en vertu de 62 opcodes, mais si vous pouvez vivre sans le 0 de rembourrage dans le cas où le premier octet est inférieur à 0x10, alors la solution suivante utilise seulement 23 opcodes. Vraiment montre comment "facile à mettre en œuvre vous-même des solutions comme "pad avec un zéro si la longueur de la chaîne est impair" peut être assez cher si un natif de la mise en œuvre n'est pas déjà disponible(ou dans ce cas, si BigInteger avait l'option de préfixe avec des zéros dans les toString).

public static String encode(byte[] bytes) {          
final int length = bytes.length;
//| BigInteger constructor throws if it is given an empty array.
if (length == 0) {
return "00";
}
return new BigInteger(bytes).toString(16);
}

InformationsquelleAutor Dmitry

1

Ma solution est basée sur maybeWeCouldStealAVan de la solution, mais ne repose pas sur les plus affectés tables de recherche. Il n'utilise aucun "int-à-char" jette hacks (en fait, Character.forDigit() t-il, de l'exécution de certains de comparaison pour vérifier ce que le chiffre est vraiment) et donc peut-être un peu plus lent. N'hésitez pas à utiliser où vous le souhaitez. Des acclamations.
```
public static String bytesToHex(final byte[] bytes)
{
final int numBytes = bytes.length;
final char[] container = new char[numBytes * 2];
for (int i = 0; i < numBytes; i++)
{
final int b = bytes[i] & 0xFF;
container[i * 2] = Character.forDigit(b >>> 4, 0x10);
container[i * 2 + 1] = Character.forDigit(b & 0xF, 0x10);
}
return new String(container);
}
```
InformationsquelleAutor Netherwire

//Décalage d'octets est plus efficace
//Vous pouvez l'utiliser trop

public static String getHexString (String s) 
{
byte[] buf = s.getBytes();
StringBuffer sb = new StringBuffer();
for (byte b:buf)
{
sb.append(String.format("%x", b));
}
return sb.toString();
}

InformationsquelleAutor BluePurse

Si vous êtes à la recherche d'un tableau d'octets exactement comme cela pour python, j'ai converti cette implémentation Java en python.

class ByteArray:
@classmethod
def char(cls, args=[]):
cls.hexArray = "0123456789ABCDEF".encode('utf-16')
j = 0
length = (cls.hexArray)
if j < length:
v = j & 0xFF
hexChars = [None, None]
hexChars[j * 2] = str( cls.hexArray) + str(v)
hexChars[j * 2 + 1] = str(cls.hexArray) + str(v) + str(0x0F)
# Use if you want...
#hexChars.pop()
return str(hexChars)
array = ByteArray()
print array.char(args=[])

InformationsquelleAutor SkippsDev

  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;
}

InformationsquelleAutor 田咖啡

Ici est un java.util.Base64-comme la mise en œuvre(partielle), n'est-il pas assez?

public class Base16/*a.k.a. Hex*/ {
public static class Encoder{
private static char[] toLowerHex={'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
private static char[] toUpperHex={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
private boolean upper;
public Encoder(boolean upper) {
this.upper=upper;
}
public String encode(byte[] data){
char[] value=new char[data.length*2];
char[] toHex=upper?toUpperHex:toLowerHex;
for(int i=0,j=0;i<data.length;i++){
int octet=data[i]&0xFF;
value[j++]=toHex[octet>>4];
value[j++]=toHex[octet&0xF];
}
return new String(value);
}
static final Encoder LOWER=new Encoder(false);
static final Encoder UPPER=new Encoder(true);
}
public static Encoder getEncoder(){
return Encoder.LOWER;
}
public static Encoder getUpperEncoder(){
return Encoder.UPPER;
}
//...
}

InformationsquelleAutor fuweichin

private static String bytesToHexString(byte[] bytes, int length) {
if (bytes == null || length == 0) return null;
StringBuilder ret = new StringBuilder(2*length);
for (int i = 0 ; i < length ; i++) {
int b;
b = 0x0f & (bytes[i] >> 4);
ret.append("0123456789abcdef".charAt(b));
b = 0x0f & bytes[i];
ret.append("0123456789abcdef".charAt(b));
}
return ret.toString();
}

InformationsquelleAutor kakopappa

          Converts bytes data to hex characters
@param bytes byte array to be converted to hex string
@return byte String in hex format
private static String bytesToHex(byte[] bytes) {
char[] hexChars = new char[bytes.length * 2];
int v;
for (int j = 0; j < bytes.length; j++) {
v = bytes[j] & 0xFF;
hexChars[j * 2] = HEX_ARRAY[v >>> 4];
hexChars[j * 2 + 1] = HEX_ARRAY[v & 0x0F];
}
return new String(hexChars);
}

InformationsquelleAutor Rajneesh Shukla

Vous devez vous connecter pour publier un commentaire.

Option 1: extrait de Code - Simple

Option 2: extrait de Code Avancé

Option 3: à l'Aide d'une petite bibliothèque optimisée: octets-java

Option 4: Apache Commons Codec

Option 5: Google Goyave

Option 6: Le Printemps De Sécurité

Option 7: Château Gonflable

Pas Vraiment l'Option 8: Java 9+ Compatibilité ou "Ne Pas Utiliser JAXBs javax/xml/bind/DatatypeConverter'

Micro Repères