Wie konvertiert ein byte-array in einen hex-string in Java?

Den Apache-Commons-Codec Bibliothek hat eine Hex Klasse zu tun, diese Art von Arbeit.

import org.apache.commons.codec.binary.Hex;

String foo = "I am a string";
byte[] bytes = foo.getBytes();
System.out.println( Hex.encodeHexString( bytes ) );

InformationsquelleAutor chooban

Einfachste Lösung, die keine externen libs, keine Ziffern Konstanten:

public static String byteArrayToHex(byte[] a) {
   StringBuilder sb = new StringBuilder(a.length * 2);
   for(byte b: a)
      sb.append(String.format("%02x", b));
   return sb.toString();
}

InformationsquelleAutor Pointer Null

Diese simple oneliner funktioniert für mich

String result = new BigInteger(1, inputBytes).toString(16);

BEARBEITEN - Mit dieser wird das entfernen führender Nullen, aber hey, arbeitete für meinen use-case. Danke @Voicu für den Hinweis it out

InformationsquelleAutor everconfusedGuy

Fand ich drei verschiedene Arten hier:
http://www.rgagnon.com/javadetails/java-0596.html

Den elegantesten, als er bemerkt auch, denke ich, ist dieses hier:

static final String HEXES = "0123456789ABCDEF";
public static String getHex( byte [] raw ) {
    if ( raw == null ) {
        return null;
    }
    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();
}

InformationsquelleAutor Michael Bisbjerg

Ich würde etwas verwenden, wie dies für eine Feste Länge haben, wie hashes:

md5sum = String.format("%032x", new BigInteger(1, md.digest()));

InformationsquelleAutor Usagi Miyamoto

Bevorzuge ich diese:

final protected static char[] hexArray = "0123456789ABCDEF".toCharArray();
public static String bytesToHex(byte[] bytes, int offset, int count) {
    char[] hexChars = new char[count * 2];
    for ( int j = 0; j < count; j++ ) {
        int v = bytes[j+offset] & 0xFF;
        hexChars[j * 2] = hexArray[v >>> 4];
        hexChars[j * 2 + 1] = hexArray[v & 0x0F];
    }
    return new String(hexChars);
}

Es ist etwas flexiblere Anpassung der akzeptierten Antwort.
Persönlich, ich halte sowohl die akzeptierte Antwort, und diese überladung zusammen mit ihm, verwendbar in mehr Kontexten.

InformationsquelleAutor Bamaco

Ok, so gibt es eine Reihe von Möglichkeiten, dies zu tun, aber wenn Sie sich entscheiden, eine Bibliothek, die ich würde vorschlagen, Stossen etwa in Ihrem Projekt zu sehen, wenn etwas umgesetzt wurde, in einer Bibliothek, die bereits Teil des Projekts, bevor das hinzufügen einer neuen Bibliothek, die nur zu diesem Zweck. Zum Beispiel, wenn Sie nicht bereits haben

org.apache.Unterhaus.codec.binären.Hex

vielleicht haben Sie...

org.apache.xerces.impl.dv.util.HexBin

InformationsquelleAutor Aaron Cooley

Finde keine Lösung auf dieser Seite, die nicht

1. Eine Schleife verwenden, die
2. Verwenden javax.xml.binden.DatatypeConverter, die kompiliert in Ordnung, aber oft wirft java.lang.NoClassDefFoundError zur Laufzeit.

Hier ist eine Lösung, die nicht über die Mängel oben(keine Versprechungen mine nicht andere Mängel, obwohl)

import java.math.BigInteger;

import static java.lang.System.out;
public final class App2 {
    //| proposed solution.
    public static String encode(byte[] bytes) {          
        final int length = bytes.length;

        //| BigInteger constructor throws if it is given an empty array.
        if (length == 0) {
            return "00";
        }

        final int evenLength = (int)(2 * Math.ceil(length / 2.0));
        final String format = "%0" + evenLength + "x";         
        final String result = String.format (format, new BigInteger(bytes));

        return result;
    }

    public static void main(String[] args) throws Exception {
        //00
        out.println(encode(new byte[] {})); 

        //01
        out.println(encode(new byte[] {1})); 

        //203040
        out.println(encode(new byte[] {0x20, 0x30, 0x40})); 

        //416c6c20796f75722062617365206172652062656c6f6e6720746f2075732e
        out.println(encode("All your base are belong to us.".getBytes()));
    }
}   

Diese hab ich nicht unter 62 opcodes, aber wenn Sie Leben können, ohne 0-Polsterung in Fall ist das erste byte kleiner als 0x10, dann die folgende Lösung verwendet nur 23 opcodes. Wirklich zeigt, wie "einfach zu implementieren-yourself" - Lösungen wie "pad mit einer null, wenn die string-Länge ist ungerade" kann ziemlich teuer werden, wenn eine native Implementierung ist noch nicht verfügbar(oder in diesem Fall, wenn BigInteger hatte eine option Präfix mit Nullen toString).

public static String encode(byte[] bytes) {          
    final int length = bytes.length;

    //| BigInteger constructor throws if it is given an empty array.
    if (length == 0) {
        return "00";
    }

    return new BigInteger(bytes).toString(16);
}

InformationsquelleAutor Dmitry

Wenn Sie mit dem Spring-Security-framework, die Sie verwenden können:

import org.springframework.security.crypto.codec.Hex

final String testString = "Test String";
final byte[] byteArray = testString.getBytes();
System.out.println(Hex.encode(byteArray));

InformationsquelleAutor java-addict301

Wenn Sie auf der Suche für ein byte-array, genau wie diese für python, ich habe konvertiert diese Java-Implementierung in python.

class ByteArray:

@classmethod
def char(cls, args=[]):
    cls.hexArray = "0123456789ABCDEF".encode('utf-16')
    j = 0
    length = (cls.hexArray)

    if j < length:
        v = j & 0xFF
        hexChars = [None, None]
        hexChars[j * 2] = str( cls.hexArray) + str(v)
        hexChars[j * 2 + 1] = str(cls.hexArray) + str(v) + str(0x0F)
        # Use if you want...
        #hexChars.pop()

    return str(hexChars)

array = ByteArray()
print array.char(args=[])

InformationsquelleAutor SkippsDev

Hier ist ein java.util.Base64-wie die Implementierung(teilweise), ist es nicht ziemlich?

public class Base16/*a.k.a. Hex*/ {
    public static class Encoder{
        private static char[] toLowerHex={'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
        private static char[] toUpperHex={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
        private boolean upper;
        public Encoder(boolean upper) {
            this.upper=upper;
        }
        public String encode(byte[] data){
            char[] value=new char[data.length*2];
            char[] toHex=upper?toUpperHex:toLowerHex;
            for(int i=0,j=0;i<data.length;i++){
                int octet=data[i]&0xFF;
                value[j++]=toHex[octet>>4];
                value[j++]=toHex[octet&0xF];
            }
            return new String(value);
        }
        static final Encoder LOWER=new Encoder(false);
        static final Encoder UPPER=new Encoder(true);
    }
    public static Encoder getEncoder(){
        return Encoder.LOWER;
    }
    public static Encoder getUpperEncoder(){
        return Encoder.UPPER;
    }
    //...
}

InformationsquelleAutor fuweichin

          Converts bytes data to hex characters

          @param bytes byte array to be converted to hex string
          @return byte String in hex format

        private static String bytesToHex(byte[] bytes) {
            char[] hexChars = new char[bytes.length * 2];
            int v;
            for (int j = 0; j < bytes.length; j++) {
                v = bytes[j] & 0xFF;
                hexChars[j * 2] = HEX_ARRAY[v >>> 4];
                hexChars[j * 2 + 1] = HEX_ARRAY[v & 0x0F];
            }
            return new String(hexChars);
        }

InformationsquelleAutor Rajneesh Shukla