wake-up-neo.com

Konvertieren eines Strings in Hexadezimal in Java

Ich versuche, eine Zeichenfolge wie "testing123" in eine hexadezimale Form in Java zu konvertieren. Ich verwende derzeit BlueJ. 

Und um es zurück zu konvertieren, ist es dasselbe, außer rückwärts?

96
Keith

Hier ist ein kurzer Weg, um es in Hex umzuwandeln

public String toHex(String arg) {
    return String.format("%040x", new BigInteger(1, arg.getBytes(/*YOUR_CHARSET?*/)));
}
178
Kaleb Pederson

Um sicherzustellen, dass das Hex immer 40 Zeichen lang ist, muss der BigInteger positiv sein:

public String toHex(String arg) {
  return String.format("%x", new BigInteger(1, arg.getBytes(/*YOUR_CHARSET?*/)));
}
60
Jos Theeuwen
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

40
Joshua Swink

Die Zahlen, die Sie in hexadezimal kodieren, müssen eine Kodierung der Zeichen darstellen, z. B. UTF-8. Konvertieren Sie also zuerst den String in ein Byte [], das den String in dieser Kodierung darstellt, und konvertieren Sie dann jedes Byte in Hexadezimal.

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);
}
18
Stephen Denne

Verwenden Sie DatatypeConverter.printHexBinary() :

public static String toHexadecimal(String text) throws UnsupportedEncodingException
{
    byte[] myBytes = text.getBytes("UTF-8");

    return DatatypeConverter.printHexBinary(myBytes);
}

Verwendungsbeispiel:

System.out.println(toHexadecimal("Hello StackOverflow"));

Drucke:

48656C6C6F20537461636B4F766572666C6F77
12
BullyWiiPlaza

Alle Antworten, die auf String.getBytes () basieren, enthalten coding Ihren String gemäß einem Zeichensatz. Sie erhalten nicht unbedingt den Hex-Wert der 2-Byte-Zeichen Zeichen, aus denen Ihre Zeichenfolge besteht. Wenn das, was Sie eigentlich wollen, einem Hex-Viewer entspricht, müssen Sie direkt auf die Zeichen zugreifen. Hier ist die Funktion, die ich in meinem Code zum Debuggen von Unicode-Problemen verwende:

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

Dann gibt Ihnen stringToHex ("testing123") Folgendes:

0074 0065 0073 0074 0069 006e 0067 0031 0032 0033
8
Bogdan Calmac

Hier eine andere Lösung

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();
}
7
jordeu

Ich würde so etwas vorschlagen, wobei str Ihre Eingabezeichenfolge ist:

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());
}
6
rodion
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

Sie könnten an dieser Stelle hexString zurückgeben, mit der Einschränkung, dass führende Nullzeichen entfernt werden, und das Ergebnis hat eine ungerade Länge, wenn das erste Byte kleiner als 16 ist. Wenn Sie mit diesen Fällen umgehen müssen, können Sie zusätzliche hinzufügen Code zum Auffüllen mit 0s:

StringBuilder sb = new StringBuilder();
while ((sb.length() + hexString.length()) < (2 * bytes.length)) {
  sb.append("0");
}
sb.append(hexString);
return sb.toString();
5

Den Integer-Wert von Hex erhalten

        //hex like: 0xfff7931e to int
        int hexInt = Long.decode(hexString).intValue();
5
TouchBoarder

Wandeln Sie einen Buchstaben in einen Hex-Code und einen Hex-Code in einen Buchstaben um.

        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);
4
Marcus Becker

Konvertieren Sie es zuerst in Bytes mit der getBytes () - Funktion und konvertieren Sie es dann in Hex:

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();
}
3
user2475511

Um den umgekehrten Weg (Hex zu String) zu gehen, können Sie verwenden

public String hexToString(String hex) {
    return new String(new BigInteger(hex, 16).toByteArray());
}
3
Jibbyj

String in Hexadezimal konvertieren :

public String hexToString(String hex) {
    return Integer.toHexString(Integer.parseInt(hex));
}

das ist definitiv der einfache Weg.

1
Elenasys
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);
    }
}
1
Rowena Jimenez
new BigInteger(1, myString.getBytes(/*YOUR_CHARSET?*/)).toString(16)
1
ultraon

Eine kurze und bequeme Möglichkeit, einen String in seine Hexadezimal-Notation zu konvertieren, ist:

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());
}
0
Amit Samuel

überprüfen Sie diese Lösung auf String zu hex und hex zu String umgekehrt

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

Ausgabe wie folgt:

Klartext = testString For; 0181; with.love

Hex Text = 74657374537472696e6720466f723b303138313b776974682e6c6f7665

Decoded Text = testString For; 0181; with.love

0
Nitin Upadhyay

Viel besser:

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

Hier sind einige Benchmarks Vergleich verschiedener Ansätze und Bibliotheken. Guave schlägt Apache Commons Codec bei der Dekodierung. Commons Codec schlägt Guava beim Kodieren. Und JHex schlägt sie sowohl beim Dekodieren als auch beim Kodieren.

JHex Beispiel

String hexString = "596f752772652077656c636f6d652e";
byte[] decoded = JHex.decodeChecked(hexString);
System.out.println(new String(decoded));
String reEncoded = JHex.encode(decoded);

Alles ist in einer einzigen Klassendatei für JHex . Sie können das Einfügen kopieren, wenn Sie keine weitere Bibliothek in Ihrem Abhängigkeitsbaum möchten. Beachten Sie auch, dass es nur als Java 9-Dose verfügbar ist, bis ich herausfinden kann, wie mehrere Release-Ziele mit Gradle und dem Bintray-Plugin veröffentlicht werden. 

0
jamespedwards42