在Java中将字符串转换为十六进制

107

我试图在Java中将类似“ testing123”的字符串转换为十六进制形式。我当前正在使用BlueJ。

并将其转换回去，除了向后转换，是否一样？

java  string  hex 
请编辑您的问题以显示您到目前为止的代码。您应该至少包含遇到问题的代码的大纲（但最好是一个最小的可重现示例），然后我们可以尝试解决特定的问题。您还应该阅读如何提问。
— Toby Speight

Answers:

201

这是将其转换为十六进制的简短方法：

public String toHex(String arg) {
    return String.format("%040x", new BigInteger(1, arg.getBytes(/*YOUR_CHARSET?*/)));
}
— 卡莱布·佩德森（Kaleb Pederson）
source
24
+1是我见过的最纯净的3vilness样本：使用BigInteger从字节转换为[] ...
— Eduardo Costa
13
爱它！没有循环，也没有位翻转。我想给您0xFF的赞誉：）
— laher 11-10-22
5
为确保40个字符，您应该添加零填充：return String.format（“％040x”，new BigInteger（arg.getBytes（/ * YOUR_CHARSET？* /）））;
— 罗恩
4
@Kaleb您是否知道是否可以将结果字符串转换回去？如果可以，可以给我一些提示吗？谢谢！
— artaxerxe 2012年
1
您必须使用BigInteger(int,byte[])构造函数。否则，如果第一个字节为负，则得到负的BigInteger。
— 乔尼
62

为了确保十六进制始终长40个字符，BigInteger必须为正数：

public String toHex(String arg) {
  return String.format("%x", new BigInteger(1, arg.getBytes(/*YOUR_CHARSET?*/)));
}
— 乔斯·泰文
source
1
这种方法实际上是正确的。尝试byte[] data = { -1, 1 };-此答案中的代码可以正常工作，而17次投票失败。
— hudolejev 2012年
1
是否可以-1从字符串中获取具有值的字节（如示例中所要求的）？
— Kaleb Pederson
@KalebPederson 是的。这甚至不是很难。。如果您选择的编码曾经使用任何字符的最高有效位（例如，就像UTF- * do一样），则您byte的数组中有负数s。
— 基金莫妮卡的诉讼
45 
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

— 约书亚·斯威克（Joshua Swink）
source
3
有趣的是，如果您不想重新发明轮子。
— Federico Zancan
3
@MelNicholson，十六进制中有一个decodeHex函数，可以转到一个字节[]。您需要使用它，因为无法保证可以将随机HEX字符串转换为编码中的字符串。
— BxlSofty 2014年
18

您编码为十六进制的数字必须表示字符的某种编码，例如UTF-8。因此，首先将String转换为表示该编码中的字符串的byte []，然后将每个字节转换为十六进制。

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);
}
— 斯蒂芬·丹尼
source
这是一种有趣的解决方案，它是数据数字表示形式的核心。您能否解释一下您在做什么，以及解决方案中的“魔术数字”代表什么？新手可能不知道>>>运算符的含义，为什么我们使用按位与和＆以及0xF0的掩码，或者为什么chars数组的大小为[2 * buf.length]。
— 鲍里斯（Boris）
16

用途DatatypeConverter.printHexBinary()：

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

    return DatatypeConverter.printHexBinary(myBytes);
}

用法示例：

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

印刷品：

48656C6C6F20537461636B4F766572666C6F77

注意：Java 9由于默认情况下不包含API，因此会带来一些新的麻烦和更新。供参考，例如，参见此 GitHub问题。

— 恶霸威利广场
source
11

这是另一种解决方案

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();
}
— 乔杜
source
3
很好，但我会使用，format("%02x")因此format（）始终使用2个字符。即使ASCII是两位数的十六进制，即A = 0x65
— mike jones，2013年
8

所有基于String.getBytes（）的答案都涉及根据字符集对字符串进行编码。您不一定会获得组成字符串的2字节字符的十六进制值。如果您真正想要的是一个十六进制查看器，那么您需要直接访问chars。这是我在代码中用于调试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();
}

然后，stringToHex（“ testing123”）将为您提供：

0074 0065 0073 0074 0069 006e 0067 0031 0032 0033
— 博格丹·卡尔马克
source
如果您希望看到Java字符的内部表示形式（即UTF-16）（Unicode的特定表示形式），则很好。
— 乔纳森·罗森
5 
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

您可能会hexString在此时返回，但要注意的是，将删除开头的空字符，如果第一个字节小于16，则结果的长度将为奇数。如果需要处理这些情况，则可以添加一些额外的代码补0：

StringBuilder sb = new StringBuilder();
while ((sb.length() + hexString.length()) < (2 * bytes.length)) {
  sb.append("0");
}
sb.append(hexString);
return sb.toString();
— 劳伦斯·贡萨尔维斯（Laurence Gonsalves）
source
5

获取十六进制的整数值

        //hex like: 0xfff7931e to int
        int hexInt = Long.decode(hexString).intValue();
— 触摸板
source
5

转换为十六进制代码的字母和十六进制代码的字母。

        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);
— 马库斯·贝克尔（Marcus Becker）
source
5

我建议这样的事情，str您的输入字符串在哪里：

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());
}
— rod
source
感谢您的更正，软件猴子。当我写下答案时，我非常疲倦，对“ raw [i] <= 9”的测试显然不够。
— 2009年
1
这真的很好，有没有办法将生成的十六进制再次反转回字符串？
1
str在哪里？
— Viswanath Lekshmanan '16
3

首先使用getBytes（）函数将其转换为字节，然后使用this将其转换为十六进制：

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();
}
— 用户名
source
3

换种方式（十六进制转换为字符串），您可以使用

public String hexToString(String hex) {
    return new String(new BigInteger(hex, 16).toByteArray());
}
— 吉比
source
1 
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);
    }
}
— 罗娜·希门尼斯（Rowena Jimenez）
source
1 
new BigInteger(1, myString.getBytes(/*YOUR_CHARSET?*/)).toString(16)
— 超子
source
1

将String转换为十六进制：

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

肯定这是简单的方法。

— 豪尔赫西斯
source
这不是解决方案。问题是询问如何获取任意String的内容的十六进制表示，并专门提供“ testing123”作为示例。
— skomisa
1

使用来自多个线程的多人帮助。

我知道已经回答了这个问题，但是我想为我在相同情况下的其他任何人提供完整的编码和解码方法。

这是我的编码和解码方法。

// Global Charset Encoding
public static Charset encodingType = StandardCharsets.UTF_8;

// Text To Hex
public static String textToHex(String text)
{
    byte[] buf = null;
    buf = text.getBytes(encodingType);
    char[] HEX_CHARS = "0123456789abcdef".toCharArray();
    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);
}

// Hex To Text
public static String hexToText(String hex)
{
    int l = hex.length();
    byte[] data = new byte[l / 2];
    for (int i = 0; i < l; i += 2)
    {
        data[i / 2] = (byte) ((Character.digit(hex.charAt(i), 16) << 4)
            + Character.digit(hex.charAt(i + 1), 16));
    }
    String st = new String(data, encodingType);
    return st;
}
— 小工具大师
source
真好！仅在第13行上，““ >>>”应为“ >>”
— Spigyang
0

好多了：

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);
}
— 德米特里（Dmitriy Bocharov）
source
0

以下是一些比较不同方法和库的基准。番石榴在解码方面击败了Apache Commons Codec。Commons Codec在编码方面击败了Guava。JHex在解码和编码方面都击败了他们。

JHex示例

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

一切都在JHex的单个类文件中。如果您不想在依赖关系树中再建一个库，请随意复制粘贴。还要注意，它仅作为Java 9 jar可用，直到我能弄清楚如何使用Gradle和Bintray插件发布多个发行目标。

— jamespedwards42
source
0

将字符串转换为十六进制表示法的一种简便快捷方法是：

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());
}
— 阿米特·塞缪尔（Amit Samuel）
source
0

检查此解决方案以将字符串转换为十六进制，并将十六进制转换为字符串，反之亦然

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

输出如下：

明文= testString For; 0181; with.love

十六进制文本= 74657374537472696e6720466f723b303138313b776974682e6c6f7665

解码文本= testString For; 0181; with.love

— 尼丁·阿帕德（Nitin Upadhyay）
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.