blocks|key|1252815|text|尝试这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1252816|byte+bv+=+10;
String+hexString+=+Integer.toHexString(bv);|code-block|syntax|javascript|1252817|处理数组(如果我没理解错的话)：|1252818|byte[]+bytes+=+{9,+10,+11,+15,+16};
StringBuffer+result+=+new+StringBuffer();
for+(byte+b+:+bytes)+{
++++result.append(String.format("%2502X+",+b));
++++result.append("+");+//+delimiter
}
return+result.toString();|1252819|正如前面提到的多基因修饰符，与Integer.toHexString()相比，String.format()是正确的答案(因为它以正确的方式处理负数)。|offset|length|style|CODE|1252820|entityMap^0|0|0|0|0|F|L|13|F|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@$M|X|N|Y|O|P]|$M|Z|N|10|O|P]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|R|$]]

Try this way:

<pre><code>byte bv = 10;
String hexString = Integer.toHexString(bv);
</code></pre>

Dealing with array (if I understood you correctly):

<pre><code>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();
</code></pre>

As polygenelubricants mentioned, <code>String.format()</code> is the right answer compare to <code>Integer.toHexString()</code> (since it deals with negative numbers in a right way).

blocks|key|1253120|text|最好的解决方案是这个坏家伙的一行代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1253121|String+hex=DatatypeConverter.printHexBinary(byte[]+b);|code-block|syntax|javascript|1253122|如前所述，here|offset|length|1253123|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/5942951/6263968^0|0|0|5|4|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

The Best solution is this badass one-liner:

<pre><code>String hex=DatatypeConverter.printHexBinary(byte[] b);
</code></pre>

as mentioned <a href="https://stackoverflow.com/a/5942951/6263968">here</a>

blocks|key|1252882|text|如果您想要一个恒定宽度的十六进制表示，即0A而不是A，这样您就可以明确地恢复字节，可以尝试format()|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1252883|StringBuilder+result+=+new+StringBuilder();
for+(byte+bb+:+byteArray)+{
++++result.append(String.format("%2502X",+bb));
}
return+result.toString();|code-block|syntax|javascript|1252884|entityMap^0|K|2|P|1|19|8|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|U|8|@]|D|@]|E|$]]]|L|$]]

If you want a constant-width hex representation, i.e. <code>0A</code> instead of <code>A</code>, so that you can recover the bytes unambiguously, try <code>format()</code>:

<pre><code>StringBuilder result = new StringBuilder();
for (byte bb : byteArray) {
 result.append(String.format("%02X", bb));
}
return result.toString();
</code></pre>

blocks|key|1253015|text|如果您愿意使用外部库，那么org.apache.commons.codec.binary.Hex类有一个encodeHex方法，它接受一个byte[]并返回一个char[]。此方法比format选项快得多，并且封装了转换的详细信息。还附带了一个用于相反转换的decodeHex方法。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1253016|entityMap^0|D|Z|1G|9|1X|6|28|6|3L|9|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|G|$]]

If you are happy to use an external library, the <code>org.apache.commons.codec.binary.Hex</code> class has an <code>encodeHex</code> method which takes a <code>byte[]</code> and returns a <code>char[]</code>. This methods is MUCH faster than the format option, and encapsulates the details of the conversion. Also comes with a <code>decodeHex</code> method for the opposite conversion.

blocks|key|1253093|text|这是到目前为止我发现运行速度最快的代码。我在长度为32的109015字节数组上运行它，运行时间为23ms。我在虚拟机上运行它，所以它可能在裸机上运行得更快。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1253094|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%2B%2B+){
++++++++out[j%2B%2B]+=+HEX_DIGITS[(0xF0+&+data[i])+>>>+4];
++++++++out[j%2B%2B]+=+HEX_DIGITS[0x0F+&+data[i]];
++++}
++++return+out;
}|code-block|syntax|javascript|1253095|然后你就可以这样做|1253096|String+s+=+new+String(+encodeHex(myByteArray)+);|1253097|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

This is the code that I've found to run the fastest so far. I ran it on 109015 byte arrays of length 32, in 23ms. I was running it on a VM so it'll probably run faster on bare metal.

<pre><code>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&lt;&lt;1];
 for( int i=0,j=0; i&lt;l; i++ ){
 out[j++] = HEX_DIGITS[(0xF0 &amp; data[i]) &gt;&gt;&gt; 4];
 out[j++] = HEX_DIGITS[0x0F &amp; data[i]];
 }
 return out;
}
</code></pre>

Then you can just do 

<pre><code>String s = new String( encodeHex(myByteArray) );
</code></pre>

blocks|key|1253099|text|BigInteger+n+=+new+BigInteger(byteArray);
String+hexa+=+n.toString(16);|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1253100|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>BigInteger n = new BigInteger(byteArray);
String hexa = n.toString(16);
</code></pre>

blocks|key|1037887|text|下面是一个将字节转换为十六进制的简单函数|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1037888|+++private+static+String+convertToHex(byte[]+data)+{
++++StringBuffer+buf+=+new+StringBuffer();
++++for+(int+i+=+0;+i+<+data.length;+i%2B%2B)+{
++++++++int+halfbyte+=+(data[i]+>>>+4)+&+0x0F;
++++++++int+two_halfs+=+0;
++++++++do+{
++++++++++++if+((0+<=+halfbyte)+&&+(halfbyte+<=+9))
++++++++++++++++buf.append((char)+('0'+%2B+halfbyte));
++++++++++++else
++++++++++++++++buf.append((char)+('a'+%2B+(halfbyte+-+10)));
++++++++++++halfbyte+=+data[i]+&+0x0F;
++++++++}+while(two_halfs%2B%2B+<+1);
++++}
++++return+buf.toString();
}|code-block|syntax|javascript|1037889|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is a simple function to convert byte to Hexadecimal

<pre><code> private static String convertToHex(byte[] data) {
 StringBuffer buf = new StringBuffer();
 for (int i = 0; i &lt; data.length; i++) {
 int halfbyte = (data[i] &gt;&gt;&gt; 4) &amp; 0x0F;
 int two_halfs = 0;
 do {
 if ((0 &lt;= halfbyte) &amp;&amp; (halfbyte &lt;= 9))
 buf.append((char) ('0' + halfbyte));
 else
 buf.append((char) ('a' + (halfbyte - 10)));
 halfbyte = data[i] &amp; 0x0F;
 } while(two_halfs++ &lt; 1);
 }
 return buf.toString();
}
</code></pre>

blocks|key|1253042|text|其他人已经涵盖了一般情况。但是，如果您有一个已知格式的字节数组，例如MAC地址，那么您可以：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1253043|byte[]+mac+=+{+(byte)0x00,+(byte)0x00,+(byte)0x00,+(byte)0x00,+(byte)0x00+};

String+str+=+String.format("%2502X:%2502X:%2502X:%2502X:%2502X:%2502X",
+++++++++++++++++++++++++++mac[0],+mac[1],+mac[2],+mac[3],+mac[4],+mac[5]);+|code-block|syntax|javascript|1253044|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Others have covered the general case. But if you have a byte array of a known form, for example a MAC address, then you can:

<pre><code>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]); 
</code></pre>

blocks|key|1253163|text|这是你的快速方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1253164|++++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];
++++}|code-block|syntax|javascript|1253165|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

There's your fast method:

<pre><code> 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&amp;0xFF];
 }
</code></pre>

blocks|key|1037936|text|如果性能是个问题，那么创建(和销毁)一堆String实例不是一个好方法。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1037937|请忽略那些冗长(重复)的参数检查语句(if)。那是为了(另一个)教育目的。|1037938|完整的maven项目：http://jinahya.googlecode.com/svn/trunk/com.googlecode.jinahya/hex-codec/|1037939|编码...|1037940|/**
+*+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+%2B+0x30;+//+0x30('0')+-+0x39('9')
++++++++case+0x0A:
++++++++case+0x0B:
++++++++case+0x0C:
++++++++case+0x0D:
++++++++case+0x0E:
++++++++case+0x0F:
++++++++++++return+decoded+%2B+0x57;+//+0x41('a')+-+0x46('f')
++++++++default:
++++++++++++throw+new+IllegalArgumentException("illegal+half:+"+%2B+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("+%2B+encoded.length+%2B+")+<+2");
++++}

++++if+(offset+<+0)+{
++++++++throw+new+IllegalArgumentException("offset("+%2B+offset+%2B+")+<+0");
++++}

++++if+(offset+>=+encoded.length+-+1)+{
++++++++throw+new+IllegalArgumentException(
++++++++++++"offset("+%2B+offset+%2B+")+>=+encoded.length("+%2B+encoded.length
++++++++++++%2B+")+-+1");
++++}

++++encoded[offset]+=+(byte)+encodeHalf((decoded+>>+4)+&+0x0F);
++++encoded[offset+%2B+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%2B%2B)+{
++++++++encodeSingle(decoded[i],+encoded,+offset);
++++++++offset+%2B=+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);
}|code-block|syntax|javascript|1037941|解码...|1037942|/**
+*+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:+"+%2B+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("+%2B+encoded.length+%2B+")+<+2");
++++}

++++if+(offset+<+0)+{
++++++++throw+new+IllegalArgumentException("offset("+%2B+offset+%2B+")+<+0");
++++}

++++if+(offset+>=+encoded.length+-+1)+{
++++++++throw+new+IllegalArgumentException(
++++++++++++"offset("+%2B+offset+%2B+")+>=+encoded.length("+%2B+encoded.length
++++++++++++%2B+")+-+1");
++++}

++++return+(decodeHalf(encoded[offset])+<<+4)
+++++++++++%7C+decodeHalf(encoded[offset+%2B+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("+%2B+encoded.length+%2B+")+is+not+even");
++++}

++++final+byte[]+decoded+=+new+byte[encoded.length+>>+1];

++++int+offset+=+0;
++++for+(int+i+=+0;+i+<+decoded.length;+i%2B%2B)+{
++++++++decoded[i]+=+(byte)+decodeSingle(encoded,+offset);
++++++++offset+%2B=+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);
}|1037943|entityMap|0|LINK|mutability|MUTABLE|url|http://jinahya.googlecode.com/svn/trunk/com.googlecode.jinahya/hex-codec/^0|K|6|0|J|2|0|B|21|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|15|8|@$9|16|A|17|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|18|8|@]|D|@$9|19|A|1A|1|1B]]|E|$]]|$1|J|3|K|5|6|7|1C|8|@]|D|@]|E|$]]|$1|L|3|M|5|N|7|1D|8|@]|D|@]|E|$O|P]]|$1|Q|3|R|5|6|7|1E|8|@]|D|@]|E|$]]|$1|S|3|T|5|N|7|1F|8|@]|D|@]|E|$O|P]]|$1|U|3|-4|5|6|7|1G|8|@]|D|@]|E|$]]]|V|$W|$5|X|Y|Z|E|$10|11]]]]

Creating (and destroying) a bunch of <code>String</code> instances is not a good way if performance is an issue.

Please ignore those verbose (duplicate) arguments checking statements (<code>if</code>s). That's for (another) educational purposes. 

Full maven project: <a href="http://jinahya.googlecode.com/svn/trunk/com.googlecode.jinahya/hex-codec/" rel="nofollow">http://jinahya.googlecode.com/svn/trunk/com.googlecode.jinahya/hex-codec/</a>

Encoding...

<pre><code>/**
 * 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 &lt; 2) {
 // not required
 throw new IllegalArgumentException(
 "encoded.length(" + encoded.length + ") &lt; 2");
 }

 if (offset &lt; 0) {
 throw new IllegalArgumentException("offset(" + offset + ") &lt; 0");
 }

 if (offset &gt;= encoded.length - 1) {
 throw new IllegalArgumentException(
 "offset(" + offset + ") &gt;= encoded.length(" + encoded.length
 + ") - 1");
 }

 encoded[offset] = (byte) encodeHalf((decoded &gt;&gt; 4) &amp; 0x0F);
 encoded[offset + 1] = (byte) encodeHalf(decoded &amp; 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 &lt;&lt; 1];

 int offset = 0;
 for (int i = 0; i &lt; 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);
}
</code></pre>

Decoding...

<pre><code>/**
 * 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 &lt; 2) {
 // not required
 throw new IllegalArgumentException(
 "encoded.length(" + encoded.length + ") &lt; 2");
 }

 if (offset &lt; 0) {
 throw new IllegalArgumentException("offset(" + offset + ") &lt; 0");
 }

 if (offset &gt;= encoded.length - 1) {
 throw new IllegalArgumentException(
 "offset(" + offset + ") &gt;= encoded.length(" + encoded.length
 + ") - 1");
 }

 return (decodeHalf(encoded[offset]) &lt;&lt; 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 &amp; 0x01) == 0x01) {
 throw new IllegalArgumentException(
 "encoded.length(" + encoded.length + ") is not even");
 }

 final byte[] decoded = new byte[encoded.length &gt;&gt; 1];

 int offset = 0;
 for (int i = 0; i &lt; 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);
}
</code></pre>

blocks|key|1038043|text|这是一种非常快速的方法。不需要外部库。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1038044|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%2B%2B)+{
++++++++++++int+v+=+bytes[j]+&+0xFF;
++++++++++++hexChars[j+*+2]+=+HEXARRAY[v+>>>+4];
++++++++++++hexChars[j+*+2+%2B+1]+=+HEXARRAY[v+&+0x0F];
++++++++}
++++++++return+new+String(hexChars);
++++}|code-block|syntax|javascript|1038045|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This is a very fast way. No external libaries needed.

<pre><code>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 &lt; bytes.length; j++) {
 int v = bytes[j] &amp; 0xFF;
 hexChars[j * 2] = HEXARRAY[v &gt;&gt;&gt; 4];
 hexChars[j * 2 + 1] = HEXARRAY[v &amp; 0x0F];
 }
 return new String(hexChars);
 }
</code></pre>

blocks|key|1038241|text|如果你喜欢streams，这里有一个格式和连接方法的单表达式版本：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1038242|String+hex+=+IntStream.range(0,+bytes.length)
++++++++++++++++++++++.map(i+->+bytes[i]+&+0xff)
++++++++++++++++++++++.mapToObj(b+->+String.format("%2502x",+b))
++++++++++++++++++++++.collect(Collectors.joining());|code-block|syntax|javascript|1038243|很遗憾，没有像Arrays::streamUnsignedBytes这样的方法来解决这个问题。|offset|length|style|CODE|1038244|entityMap^0|0|0|7|R|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

If you like streams, here is a single-expression version of the format-and-concatenate approach:
<pre><code>String hex = IntStream.range(0, bytes.length)
 .map(i -&gt; bytes[i] &amp; 0xff)
 .mapToObj(b -&gt; String.format(&quot;%02x&quot;, b))
 .collect(Collectors.joining());
</code></pre>
It's a shame there isn't a method like <code>Arrays::streamUnsignedBytes</code> for this.

blocks|key|1038176|text|如果你使用Tink，那么有：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1038177|package+com.google.crypto.tink.subtle;

public+final+class+Hex+{
++public+static+String+encode(final+byte[]+bytes)+{+...+}
++public+static+byte[]+decode(String+hex)+{+...+}
}|code-block|syntax|javascript|1038178|所以像这样的东西应该是有效的：|1038179|import+com.google.crypto.tink.subtle.Hex;

byte[]+bytes+=+{-1,+0,+1,+2,+3+};
String+enc+=+Hex.encode(bytes);
byte[]+dec+=+Hex.decode(enc)|1038180|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

If you use Tink, then there is:
<pre class="lang-java prettyprint-override"><code>package com.google.crypto.tink.subtle;

public final class Hex {
 public static String encode(final byte[] bytes) { ... }
 public static byte[] decode(String hex) { ... }
}
</code></pre>
so something like this should work:
<pre class="lang-java prettyprint-override"><code>import com.google.crypto.tink.subtle.Hex;

byte[] bytes = {-1, 0, 1, 2, 3 };
String enc = Hex.encode(bytes);
byte[] dec = Hex.decode(enc)
</code></pre>

blocks|key|1253356|text|我只是补充我的观点，因为我看到许多答案，使用char数组和/或使用StringBuilder实例，并声称更快或更快。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1253357|因为我有一个不同的想法，使用ASCII表组织，在48-57处有0-9，在65-70处有A-F，在97-102处有a-f，所以我想测试哪个想法是最快的。|1253358|由于我已经有很长一段时间没有做过这样的事情了，所以我对此进行了广泛的尝试。我在不同大小的数组(+1M，1K，10)中使用了10亿字节，所以我们有1000倍1M字节的数组，1M乘以1000字节的数组和100M次的10字节数组。|1253359|结果是1-F中的char数组获胜。使用char数组作为输出，而不是StringBuilder，也会轻松取胜(对象更少，没有容量测试，没有新的数组，在增长时也没有复制)。此外，在使用foreach+(for(var+b:+bytes))循环时，似乎会得到很小的损失。|1253360|使用我的想法的版本大约是。对于每个阵列1M字节，慢15%25；对于每个阵列1000字节，慢21%25；对于每个阵列10字节，慢18%25。StringBuilder版本分别慢了210%25、380%25和310%25。|1253361|很糟糕，但并不是那么出人意料，因为在一级缓存中查找小数组胜过一个if和一个add…。(一次缓存访问%2B偏移量计算与一次if，一次跳转，一次添加->不确定跳转你)。|1253362|我的版本：|1253363|public+static+String+bytesToHex(byte+[]+bytes)+{
++++
++++char+[]+result+=+new+char+[bytes.length+*+2];
++++
++++for(int+index+=+0;+index+<+bytes.length;+index%2B%2B)+{
++++++++int+v+=+bytes[index];+

++++++++int+upper+=+(v+>>>+4)+&+0xF;
++++++++result[index+*+2]+=+(char)(upper+%2B+(upper+<+10+?+48+:+65+-+10));
++++++++
++++++++int+lower+=+v+&+0xF;
++++++++result[index+*+2+%2B+1]+=+(char)(lower+%2B+(lower+<+10+?+48+:+65+-+10));
++++}
++++
++++return+new+String(result);
}|code-block|syntax|javascript|1253364|PS:是的，我做了多次跑步，每次都跑得最好，做了热身，还做了100亿个字符的跑步，以确保相同的图片……。|1253365|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|Z|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|10|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|11|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|12|8|@]|9|@]|A|$]]|$1|N|3|O|5|P|7|13|8|@]|9|@]|A|$Q|R]]|$1|S|3|T|5|6|7|14|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

Just adding my two cents as I see many answers using a char array and/or using a StringBuilder instance and claiming to be fast or faster.
Since I had a different idea using the ASCII table organization having 0-9 at code points 48-57 and A-F at 65-70 and a-f at 97-102, I wanted to test which idea is the fastest.
Since I have not done something like that for quite some years now, I am giving this an extensive shoot out. I use 1 billion bytes in different sized arrays (1M, 1K, 10) so we have 1000 times 1M bytes per array, 1M times 1000 bytes per array and 100M times for 10 bytes per array.
Turns out the char array from 1-F wins. Using a char array as output instead of a StringBuilder also wins hands down (less objects, no test of capacity and no new array nor copying when growing). Furthermore you seem to get a small penalty when using a foreach (for(var b : bytes)) loop.
The version using my idea was approx. 15% slower for 1M bytes per array, 21% slower for 1000 bytes per array and 18% slower for 10 bytes per array. The StringBuilder version was 210%, 380% and 310% slower.
Bad but not that unexpected as a lookup of small arrays in first level cache beats one if and an add... . (one cache access + offset calculation vs. one if, one jump, one add -&gt; not sure about the jump thou).
My version:
<pre><code>public static String bytesToHex(byte [] bytes) {
 
 char [] result = new char [bytes.length * 2];
 
 for(int index = 0; index &lt; bytes.length; index++) {
 int v = bytes[index]; 

 int upper = (v &gt;&gt;&gt; 4) &amp; 0xF;
 result[index * 2] = (char)(upper + (upper &lt; 10 ? 48 : 65 - 10));
 
 int lower = v &amp; 0xF;
 result[index * 2 + 1] = (char)(lower + (lower &lt; 10 ? 48 : 65 - 10));
 }
 
 return new String(result);
}
</code></pre>
PS: Yes I did multiple runs and took the best run each, did warm up and also did runs with 10 billion characters to be sure same picture... .

blocks|key|1037764|text|使用|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1037765|Integer.toHexString((int)b);|code-block|syntax|javascript|1037766|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Use 

<pre><code>Integer.toHexString((int)b);
</code></pre>

I have an array of bytes.
I want each byte String of that array to be converted to its corresponding hexadecimal values.

Is there any function in Java to convert a byte array to Hexadecimal ?

Java code To convert byte to Hexadecimal

虚拟机

Java

我有一个字节数组。我希望该数组中的每个字节字符串都转换为相应的十六进制值。Java中是否有将字节数组转换为十六进制的函数？

问将字节转换为十六进制的Java代码
EN

回答 15

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问将字节转换为十六进制的Java代码EN

回答 15

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问将字节转换为十六进制的Java代码
EN