Conversion d'une chaîne en hexadécimal en Java
J'essaie de convertir une chaîne telle que "testing123" en format hexadécimal en Java. J'utilise actuellement BlueJ.
Et pour le reconvertir, est-ce la même chose sauf en arrière?
Voici un moyen rapide de le convertir en hex:
public String toHex(String arg) {
return String.format("%040x", new BigInteger(1, arg.getBytes(/*YOUR_CHARSET?*/)));
}
Pour que l'hexagone contienne toujours 40 caractères, le BigInteger doit être positif:
public String toHex(String arg) {
return String.format("%x", new BigInteger(1, arg.getBytes(/*YOUR_CHARSET?*/)));
}
import org.Apache.commons.codec.binary.Hex;
...
String hexString = Hex.encodeHexString(myString.getBytes(/* charset */));
http://commons.Apache.org/codec/apidocs/org/Apache/commons/codec/binary/Hex.html
Les chiffres encodés en hexadécimal doivent représenter un encodage des caractères, tel que UTF-8. Commencez donc par convertir la chaîne en un octet [] représentant la chaîne dans cet encodage, puis convertissez chaque octet en hexadécimal.
public static String hexadecimal(String input, String charsetName) throws UnsupportedEncodingException {
if (input == null) throw new NullPointerException();
return asHex(input.getBytes(charsetName));
}
private static final char[] HEX_CHARS = "0123456789abcdef".toCharArray();
public static String asHex(byte[] buf)
{
char[] chars = new char[2 * buf.length];
for (int i = 0; i < buf.length; ++i)
{
chars[2 * i] = HEX_CHARS[(buf[i] & 0xF0) >>> 4];
chars[2 * i + 1] = HEX_CHARS[buf[i] & 0x0F];
}
return new String(chars);
}
Utilisez DatatypeConverter.printHexBinary() :
public static String toHexadecimal(String text) throws UnsupportedEncodingException
{
byte[] myBytes = text.getBytes("UTF-8");
return DatatypeConverter.printHexBinary(myBytes);
}
Exemple d'utilisation:
System.out.println(toHexadecimal("Hello StackOverflow"));
Impressions:
48656C6C6F20537461636B4F766572666C6F77
Toutes les réponses basées sur String.getBytes () impliquent encoding votre chaîne selon un jeu de caractères. Vous n'obtenez pas nécessairement la valeur hexadécimale des 2 octets caractères qui composent votre chaîne. Si ce que vous voulez réellement est l'équivalent d'un visualiseur hexadécimal, vous devez accéder directement aux caractères. Voici la fonction que j'utilise dans mon code pour déboguer les problèmes Unicode:
static String stringToHex(String string) {
StringBuilder buf = new StringBuilder(200);
for (char ch: string.toCharArray()) {
if (buf.length() > 0)
buf.append(' ');
buf.append(String.format("%04x", (int) ch));
}
return buf.toString();
}
Ensuite, stringToHex ("testing123") vous donnera:
0074 0065 0073 0074 0069 006e 0067 0031 0032 0033
Voici une autre solution
public static String toHexString(byte[] ba) {
StringBuilder str = new StringBuilder();
for(int i = 0; i < ba.length; i++)
str.append(String.format("%x", ba[i]));
return str.toString();
}
public static String fromHexString(String hex) {
StringBuilder str = new StringBuilder();
for (int i = 0; i < hex.length(); i+=2) {
str.append((char) Integer.parseInt(hex.substring(i, i + 2), 16));
}
return str.toString();
}
Je suggérerais quelque chose comme ceci, où str est votre chaîne d'entrée:
StringBuffer hex = new StringBuffer();
char[] raw = tokens[0].toCharArray();
for (int i=0;i<raw.length;i++) {
if (raw[i]<=0x000F) { hex.append("000"); }
else if(raw[i]<=0x00FF) { hex.append("00" ); }
else if(raw[i]<=0x0FFF) { hex.append("0" ); }
hex.append(Integer.toHexString(raw[i]).toUpperCase());
}
byte[] bytes = string.getBytes(CHARSET); // you didn't say what charset you wanted
BigInteger bigInt = new BigInteger(bytes);
String hexString = bigInt.toString(16); // 16 is the radix
Vous pouvez renvoyer hexString à ce stade, en précisant que les caractères NULL seront supprimés et que le résultat aura une longueur impaire si le premier octet est inférieur à 16. code pour pad avec 0s:
StringBuilder sb = new StringBuilder();
while ((sb.length() + hexString.length()) < (2 * bytes.length)) {
sb.append("0");
}
sb.append(hexString);
return sb.toString();
Pour obtenir la valeur entière d'hex
//hex like: 0xfff7931e to int
int hexInt = Long.decode(hexString).intValue();
Convertir une lettre en code hexadécimal et code hexadécimal en lettre.
String letter = "a";
String code;
int decimal;
code = Integer.toHexString(letter.charAt(0));
decimal = Integer.parseInt(code, 16);
System.out.println("Hex code to " + letter + " = " + code);
System.out.println("Char to " + code + " = " + (char) decimal);
Convertissez-le d'abord en octets à l'aide de la fonction getBytes (), puis convertissez-le en hexa en utilisant ceci:
private static String hex(byte[] bytes) {
StringBuilder sb = new StringBuilder();
for (int i=0; i<bytes.length; i++) {
sb.append(String.format("%02X ",bytes[i]));
}
return sb.toString();
}
Pour aller dans le sens opposé (hex à chaîne), vous pouvez utiliser
public String hexToString(String hex) {
return new String(new BigInteger(hex, 16).toByteArray());
}
Convertir une chaîne en hexadécimal :
public String hexToString(String hex) {
return Integer.toHexString(Integer.parseInt(hex));
}
c'est certainement le moyen le plus simple.
import Java.io.*;
import Java.util.*;
public class Exer5{
public String ConvertToHexadecimal(int num){
int r;
String bin="\0";
do{
r=num%16;
num=num/16;
if(r==10)
bin="A"+bin;
else if(r==11)
bin="B"+bin;
else if(r==12)
bin="C"+bin;
else if(r==13)
bin="D"+bin;
else if(r==14)
bin="E"+bin;
else if(r==15)
bin="F"+bin;
else
bin=r+bin;
}while(num!=0);
return bin;
}
public int ConvertFromHexadecimalToDecimal(String num){
int a;
int ctr=0;
double prod=0;
for(int i=num.length(); i>0; i--){
if(num.charAt(i-1)=='a'||num.charAt(i-1)=='A')
a=10;
else if(num.charAt(i-1)=='b'||num.charAt(i-1)=='B')
a=11;
else if(num.charAt(i-1)=='c'||num.charAt(i-1)=='C')
a=12;
else if(num.charAt(i-1)=='d'||num.charAt(i-1)=='D')
a=13;
else if(num.charAt(i-1)=='e'||num.charAt(i-1)=='E')
a=14;
else if(num.charAt(i-1)=='f'||num.charAt(i-1)=='F')
a=15;
else
a=Character.getNumericValue(num.charAt(i-1));
prod=prod+(a*Math.pow(16, ctr));
ctr++;
}
return (int)prod;
}
public static void main(String[] args){
Exer5 dh=new Exer5();
Scanner s=new Scanner(System.in);
int num;
String numS;
int choice;
System.out.println("Enter your desired choice:");
System.out.println("1 - DECIMAL TO HEXADECIMAL ");
System.out.println("2 - HEXADECIMAL TO DECIMAL ");
System.out.println("0 - EXIT ");
do{
System.out.print("\nEnter Choice: ");
choice=s.nextInt();
if(choice==1){
System.out.println("Enter decimal number: ");
num=s.nextInt();
System.out.println(dh.ConvertToHexadecimal(num));
}
else if(choice==2){
System.out.println("Enter hexadecimal number: ");
numS=s.next();
System.out.println(dh.ConvertFromHexadecimalToDecimal(numS));
}
}while(choice!=0);
}
}
new BigInteger(1, myString.getBytes(/*YOUR_CHARSET?*/)).toString(16)
Voici un moyen simple et pratique de convertir une chaîne en notation hexadécimale:
public static void main(String... args){
String str = "Hello! This is test string.";
char ch[] = str.toCharArray();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < ch.length; i++) {
sb.append(Integer.toHexString((int) ch[i]));
}
System.out.println(sb.toString());
}
vérifier cette solution pour String to hex et hex pour String vice-versa
public class TestHexConversion {
public static void main(String[] args) {
try{
String clearText = "testString For;0181;with.love";
System.out.println("Clear Text = " + clearText);
char[] chars = clearText.toCharArray();
StringBuffer hex = new StringBuffer();
for (int i = 0; i < chars.length; i++) {
hex.append(Integer.toHexString((int) chars[i]));
}
String hexText = hex.toString();
System.out.println("Hex Text = " + hexText);
String decodedText = HexToString(hexText);
System.out.println("Decoded Text = "+decodedText);
} catch (Exception e){
e.printStackTrace();
}
}
public static String HexToString(String hex){
StringBuilder finalString = new StringBuilder();
StringBuilder tempString = new StringBuilder();
for( int i=0; i<hex.length()-1; i+=2 ){
String output = hex.substring(i, (i + 2));
int decimal = Integer.parseInt(output, 16);
finalString.append((char)decimal);
tempString.append(decimal);
}
return finalString.toString();
}
Sortie comme suit:
Clear Text = testString For; 0181; with.love
Texte Hex = 74657374537472696e6720466f723b303138313b776974682e6c6f7665
Texte décodé = testString For; 0181; with.love
Beaucoup mieux:
public static String fromHexString(String hex, String sourceEncoding ) throws IOException{
ByteArrayOutputStream bout = new ByteArrayOutputStream();
byte[] buffer = new byte[512];
int _start=0;
for (int i = 0; i < hex.length(); i+=2) {
buffer[_start++] = (byte)Integer.parseInt(hex.substring(i, i + 2), 16);
if (_start >=buffer.length || i+2>=hex.length()) {
bout.write(buffer);
Arrays.fill(buffer, 0, buffer.length, (byte)0);
_start = 0;
}
}
return new String(bout.toByteArray(), sourceEncoding);
}
Voici quelques points de repère comparant différentes approches et bibliothèques. La goyave bat Apache Commons Codec au décodage. Commons Codec bat Guava lors de l'encodage. Et JHex les bat tous les deux pour le décodage et l'encodage.
Exemple JHex
String hexString = "596f752772652077656c636f6d652e";
byte[] decoded = JHex.decodeChecked(hexString);
System.out.println(new String(decoded));
String reEncoded = JHex.encode(decoded);
Tout est dans un fichier single class pour JHex . N'hésitez pas à copier-coller si vous ne voulez pas encore d'une autre bibliothèque dans votre arbre de dépendance. Notez également qu'il est uniquement disponible sous forme de jar Java 9 jusqu'à ce que je sache comment publier plusieurs cibles de publication avec Gradle et le plugin Bintray.