Code Java pour convertir byte en hexadécimal
j'ai un tableau d'octets. Je veux que chaque chaîne de bytes de ce tableau soit convertie en ses valeurs hexadécimales correspondantes.
Est-il une fonction en Java pour convertir un tableau d'octets en Hexadécimal ?
17 réponses
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.Formattersyntaxe-
%[flags][width]conversion- drapeau
'0'- le résultat sera zéro-rembourré - Largeur
2 - Conversion
'X'- le résultat est formaté comme un entier hexadécimal, majuscule
- drapeau
-
en regardant le texte de la question, il est aussi 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 à l'argument byte , qui implique l'extension du signe.
byte b = -1;
System.out.println(Integer.toHexString(b));
// prints "ffffffff"
8 bits byte , qui est signé en Java, est signe étendu à 32 bits int . Pour annuler efficacement cette extension de signal, 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 rembourre pas avec des zéros:
byte b = 10;
System.out.println(Integer.toHexString(b & 0xFF));
// prints "a"
ces deux facteurs combinés devraient rendre 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, inclusivement
- pour
- JLS 5.1.2 l'Élargissement des Primitives de Conversion
je poste parce qu'aucune des réponses existantes n'explique pourquoi leurs approches fonctionnent, qui je pense est vraiment important pour ce problème. Dans certains cas, la solution proposée semble inutilement compliqué et subtil. Pour illustrer mon propos, je vais vous présenter une approche assez simple, mais je vais vous donner un peu plus de détails pour vous aider à illustrer pourquoi ça marche.
tout d'abord, qu'essayons-nous de faire? Nous voulons convertir un valeur de byte (ou un tableau d'octets) à une chaîne de caractères qui représente une valeur hexadécimale en ASCII. La première étape consiste donc à découvrir exactement ce qu'est un byte en Java:
le type de données byte est un . Il a une valeur minimale de -128 et une valeur maximale de 127 (inclus). Le type de données byte peut être utile pour sauver la mémoire dans les grands tableaux, où les économies de mémoire importe réellement. Ils peuvent également être utilisés dans lieu d'int où leurs limites aident à clarifier votre code; le fait que la portée d'une 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 numéro 2 0000 0010. Cependant, puisqu'il s'agit du complément de two, nous écrivons un 2 négatif comme ceci: 1111 1110. Ce qui signifie aussi que la conversion en hex est très simple. Autrement dit, vous convertissez simplement chaque segment de 4 bits directement en hex. Notez que pour donner un sens aux nombres négatifs dans ce schéma, vous devrez d'abord comprendre le complément de two. Si vous ne comprenez pas déjà le complément de two, vous pouvez lire une excellente explication, ici: http://www.cs.cornell.edu/~tomf/notes/cps104/twoscomp.html
conversion du complément de Two en Hex 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 hex. En général, passer du binaire à l'hexadécimal est très simple, et comme vous le verrez dans les deux exemples suivants, vous pouvez passer directement du complément de two à l'hexadécimal.
exemples
exemple 1: convertir 2 en Hex.
1) convertissez D'abord 2 en binaire dans le complément de two:
2 (base 10) = 0000 0010 (base 2)
2) Maintenant convertir binaire en hex:
0000 = 0x0 in hex
0010 = 0x2 in hex
therefore 2 = 0000 0010 = 0x02.
exemple 2: convertir -2 (en complément de two) en Hex.
1) convertir d'abord -2 en binaire dans le complément de two:
-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 hexadécimal:
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 trouverez, nous pouvons réaliser ce que nous voulons avec un simple masquage et de déplacement. L'essentiel à comprendre est que l'octet que vous tentez de convertir est déjà en complément à deux. Vous ne faites pas cette conversion vous-même. Je pense qu'il s'agit là d'un point majeur de confusion sur cette question. Prenez par exemple le tableau d'octets suivant:
byte[] bytes = new byte[]{-2,2};
Nous juste manuellement converti en hexadécimal, ci-dessus, mais comment pouvons-nous le faire en Java? Voici comment:
Étape 1: créez un curseur à cordes pour maintenir notre calcul.
StringBuffer buffer = new StringBuffer();
Étape 2: isoler les bits d'ordre supérieur, les convertir en hex, et les ajouter au tampon
étant donné le nombre binaire 1111 1110, nous pouvons isoler les bits d'ordre supérieur en les déplaçant d'abord de 4, puis en ramenant à zéro le reste du nombre. Logiquement c'est simple, cependant, la mise en œuvre les détails en Java (et dans de nombreuses langues) introduisent une ride à cause de l'extension du signe. Essentiellement, lorsque vous déplacez une valeur byte, Java convertit d'abord votre valeur en un entier, puis exécute l'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 0xffff!
pour reprendre 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)
nous pouvons 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 faire tout cela d'un seul coup:
Character.forDigit((bytes[0] >> 4) & 0xF, 16);
la fonction forDigit ne fait que cartographier le nombre que vous lui passez sur l'ensemble des nombres hexadécimaux 0-F.
Étape 3: ensuite, nous devons isoler les bits d'ordre inférieur. Puisque les bits que nous voulons sont déjà dans la bonne position, nous pouvons juste 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 faire tout cela en un seul prise de vue:
Character.forDigit((bytes[0] & 0xF), 16);
en mettant tout cela ensemble, nous pouvons le faire comme une boucle pour et convertir le tableau entier:
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 que cette explication clarifie les choses 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 ne pas avoir commis d'erreurs flagrantes, mais les suggestions et les corrections sont les bienvenues!
Le le plus rapide façon je n'ai pas encore trouvé pour ce faire est la suivante:
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 ~ 50x plus rapide que String.format . si vous voulez 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
}
}
}
Modifier : Viens de trouver quelque chose de juste un ptit plus rapide et qui tient sur une ligne, mais est pas compatible avec le JRE 9. utiliser à vos risques et périls 151970920"
import javax.xml.bind.DatatypeConverter;
DatatypeConverter.printHexBinary(raw);
Essayer de cette façon:
byte bv = 10;
String hexString = Integer.toHexString(bv);
traitant du tableau (si je vous ai compris correctement):
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 manière juste).
si vous êtes heureux d'utiliser une bibliothèque externe, la classe org.apache.commons.codec.binary.Hex a une méthode encodeHex 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. Vient aussi avec une méthode decodeHex pour la conversion opposée.
si vous voulez une représentation hexadécimale à largeur constante, i.e. 0A au lieu de A , pour 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é le plus rapide jusqu'à présent. Je l'ai lancé sur des réseaux de 109015 octets de longueur 32, en 23ms. Je l'ai lancé sur une VM donc il va probablement courir 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 simplement 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 byte 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 paquet d'instances String n'est pas une bonne façon si la performance est un problème.
s'il vous Plaît ignorer ceux détaillé (en double) arguments de la vérification des déclarations ( if s). C'est pour (un autre) but éducatif.
Plein de projet maven: 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 n'ai pas pu comprendre ce que vous vouliez dire exactement par Byte String, mais voici quelques conversions de byte en String et vice versa, bien sûr il y en a beaucoup plus sur les documentations officielles
Integer intValue = 149;
la valeur de byte 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érer la valeur entière d'une variable Byte:
Integer anInt = byteValue.intValue(); // This will convert the byteValue variable to a signed Integer
de Byte et entier à chaîne hexadécimale:
C'est comme ça que 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
conversion d'un tableau d'octets en chaîne hexadécimale:
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 quelques Object en éléments d'un autre Object , donc vous devez le faire vous-même. Vous pouvez utiliser les fonctions suivantes:
de byte [] à String:
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 hex string à byte[]:
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 certains autres ;)
C'est un moyen très rapide. Pas besoin de libaires 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);
}
Voici 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];
}