Hay muchas formas de convertir el sistema binario en Java. Entre ellos, hay clases de embalaje para hexadecimal decimal octal binario básico común, etc., que no necesitan ser implementados a través de algoritmos de dos outs. Los detalles son los siguientes:
En primer lugar, los métodos de conversión binarios más simples son:
Convertir decimal a hexadecimal:
String integer.tohexstring (int i)
Convertir decimal a octal
String Integer.ToocTalString (int i)
Convertir decimal a binario
String Integer.TobinaryString (int i)
Convertir hexadecimal a decimal
Integer.ValueOf ("ffff", 16) .ToString () // No se puede manejar el prefijo 0x
Convertir octal a decimal
Integer.ValueOf ("76", 8) .ToString () // Prefijo 0 puede procesarse para ser binario a decimal
Integer.ValueOF ("0101", 2) .ToString ()
¿Hay alguna forma de convertir directamente 2, 8, hexadecimal a decimal?
java.lang.intenger clase
parseint (cadena s, int radix)
Use la cardinalidad especificada por el segundo parámetro para analizar el parámetro de cadena en un entero firmado.
Ejemplos de JDK:
parseint ("0", 10) devuelve 0
ParseInt ("473", 10) Devuelve 473
parseint ("-0", 10) devuelve 0
parseInt (" -ff", 16) Devuelve -255
ParseInt ("1100110", 2) Devuelve 102
Parseint ("2147483647", 10) Devuelve 2147483647
ParseInt (" -2147483648", 10) Devuelve -2147483648
ParseInt ("2147483648", 10) SHOLESA NumberFormateException
parseint ("99", throwsa numberFormateException
parseint ("kona", 10) shrowsa numberFormateException
Parseint ("Kona", 27) regresa 411787
Cómo escribir una conversión binaria (dos, ocho, dieciséis) sin algoritmo
Entero.tobinarystring
Entero.tooctalstring
Entero.tohexstring
Luego introduzca la conversión de byte y números hexadecimales en Java
Análisis principal:
El byte en Java está compuesto por 8 bits, y el hexadecimal es el estado en 16, que está representado por 4 bits porque 24 = 16. Por lo tanto, podemos convertir un byte en dos caracteres hexadecimales, es decir, convertir los 4 dígitos de 4 y bajos 4 en los caracteres hexadecimales correspondientes, y combinar estas dos cadenas hexadecimales para obtener la cadena hexadecimal de byte. Del mismo modo, la conversión opuesta también convierte dos personajes hexadecimales en un byte.
En Java, hay dos ideas principales para convertir bytes y hexadecimales:
1. Cuando el byte binario se convierte en hexadecimal, realice la operación "&" del byte alto y 0xf0, y luego cambie la izquierda por 4 bits para obtener la hexadecimal A del byte alto; Realice la operación "&" del byte Low y 0x0F para obtener la B hexadecimal de los bajos y los dígitos, y ensamble dos números hexadecimales en un pedazo de AB, que es la representación hexadecimal del byte.
2. Cuando hexadecimal a bytes binarios, mueva el número decimal correspondiente al carácter hexadecimal a la derecha 4 para obtener el byte alto A; hacer el "|" Operación del número decimal B y A del carácter hexadecimal correspondiente al byte bajo para obtener la representación binaria binaria hexadecimal
Una de las funciones de conversión es la siguiente:
/** * * * @param bytes * @return convierte binario a la salida de caracteres hexadecimal */</span> string static private hexstr = "0123456789abcdef"; // String estático público global binaryToxString (byte [] bytes) {string dulter = ""; Cadena hex = ""; for (int i = 0; i <bytes.length; i ++) {// bytes son 4 bits más altos <strong> hex = string.valueOf (hexstr.charat ((bytes [i] & 0xf0) >> 4)); </strong> // bytes son 4 bits más bajos <strong> hex += string.valueOf (hexstr.charat (bytes [i] & 0x0f)); </strong> resultado += hex; } resultado de retorno; }/** * * @param hexstring * @return convierte hexadecimal a matriz de byte */public static byte [] hexstringtobinary (string hexstring) {// La longitud de hexstring es redondeada por 2, como la longitud de los bytes int Len = hexstring.length ()/2; byte [] bytes = new byte [len]; byte high = 0; // El byte alto de cuatro bits de cuatro bits Low = 0; // El byte bajo cuatro bits para (int i = 0; i <len; i ++) {// transfiere a los cuatro bits correctos para obtener el bit alto alto = (byte) ((hexstr.indexof (hexstring.charat (2*i)) << 4); Low = (byte) hexstr.indexof (hexString.charat (2*i+1)); bytes [i] = (byte) (alto | bajo); // alto estado u operación} bytes de retorno; }} También hay un método similar:
<span style = "font-size: 14px;">* Convertir byte [] a la cadena hex. Aquí podemos convertir el byte a int, y luego usar integer.tohexstring (int) para convertir a hexadrícula.
* @param src byte [] data * @return hex string */ public static string bytestoString (byte [] src) {stringBuilder stringBuilder = new StringBuilder (""); if (src == null || src.length <= 0) {return null; } para (int i = 0; i <src.length; i ++) {int v = src [i] & 0xff; Cadena hv = integer.toHexString (v); if (hv.length () <2) {stringBuilder.append (0); } stringBuilder.append (HV); } return StringBuilder.ToString (); } / ** * Convierta la cadena Hex a Byte [] * @param HexString la cadena hex * @return byte [] * / public static byte [] hexStringTobytes (String hexString) {if (hexString == null || hexString.equals ("")) {return null; } hexString = hexString.ToUpperCase (); int longitud = hexString.length () / 2; char [] hexchars = hexString.ToCarArray (); byte [] d = nuevo byte [longitud]; para (int i = 0; i <longitud; i ++) {int pos = i * 2; d [i] = (byte) (ChartoByte (hexchars [pos]) << 4 | CHARTOBYTE (HEXCHARS [POS + 1])); } retorno d; } / ** * Convertir char a byte * @param c char * @return byte * / private byte chartobyte (char c) {return (byte) "0123456789abcdef" .indexof (c); } </span>Los dos métodos son similares, tenga en cuenta aquí
Lo anterior es una cadena que convierte el byte [] en hexadecimal. Tenga en cuenta que b [i] & 0xff realiza un cálculo de un byte y 0xff, y luego usa integer.tohexstring para obtener la cadena hexadecimal. Puedes ver eso
B [i] & 0xff La operación sigue siendo un int, entonces, ¿por qué necesita realizar una operación int con 0xff? Directo entero.tohexstring (b [i]);, ¿no puede forzar el byte a convertirse? La respuesta es no.
La razón es:
1. El tamaño de byte es de 8 bits y el tamaño de int es de 32 bits
2. El sistema de dos partes de Java utiliza complemento
Por lo tanto, cuando los números negativos son y con números negativos, los números negativos se llenarán automáticamente 1, lo que conducirá a errores
0xff es cirugía plástica por defecto, por lo que cuando un byte y 0xff están involucrados, el byte se convertirá primero en una operación de cirugía plástica, por lo que los 24 bits altos en el resultado siempre se despejarán por 0, por lo que el resultado siempre es lo que queremos.
Hay algunos métodos de resumen en línea:
Convertir la cadena a hexadecimal string Method 1:
/ *** Convertir la cadena en hexadecimal String*/ public static String str2HexStr (string str) {char [] chars = "0123456789abcdef" .ToCarArray (); StringBuilder sb = new StringBuilder (""); byte [] bs = str.getBytes (); int bit; for (int i = 0; i <bs.length; i ++) {bit = (bs [i] & 0x0f0) >> 4; sb.append (chars [bit]); bit = bs [i] & 0x0f; sb.append (chars [bit]); } return sb.ToString (); }Convertir la cadena hexadecimal en el método de matriz 1:
/ ** * Convierta hexstring en matriz de bytes * @param hexstring * @return byte [] * / public static byte [] hexstringtobyte (string hex) {int len = (hex.length () / 2); byte [] resultado = nuevo byte [len]; char [] achar = hex.ToCarArray (); para (int i = 0; i <len; i ++) {int pos = i * 2; resultado [i] = (byte) (tobyte (achar [pos]) << 4 | tobyte (achar [pos + 1])); } resultado de retorno; } private static int tObyte (char c) {byte b = (byte) "0123456789abcdef" .indexof (c); regreso B; }Convertir la matriz a hexadecimal string método 1:
/ ** * Convertir la matriz en cadena hex * @param byte [] * @return hexString */ public static final string bytestoHexString (byte [] barra) {stringbuffer sb = new StringBuffer (Barray.length); Cadena stemp; for (int i = 0; i <barray.length; i ++) {stemp = integer.tohexString (0xff & barray [i]); if (stemp.length () <2) sb.append (0); sb.append (stemp.touppercase ()); } return sb.ToString (); }Método 2 de convertir la matriz de byte [] en cadena hexadecimal:
/ ** * Convierta la matriz en cadena Hex * @param byte [] * @return hexString */ public static string toHexString1 (byte [] b) {stringBuffer buffer = new StringBuffer (); for (int i = 0; i <b.length; ++ i) {buffer.append (toHexString1 (b [i])); } return buffer.ToString (); } public static string toHexString1 (byte b) {String s = integer.toHexString (b & 0xff); if (s.length () == 1) {return "0" + s; } else {return s; }}Método 1 de cadena de conversión de cadena hexadecimal:
/ ** * Convertir hexString en cadena * @param hexstring * @return string */ public static string hexstr2str (string hexstr) {string str = "0123456789abcdef"; char [] hexs = hexstr.toCarArray (); byte [] bytes = new byte [hexstr.length () / 2]; int n; for (int i = 0; i <bytes.length; i ++) {n = str.indexof (hexs [2 * i]) * 16; n + = str.indexof (hexs [2 * i + 1]); bytes [i] = (byte) (n & 0xff); } return new String (bytes); }Método 2 de las cadenas de conversión en cadenas hexadecimales:
/ ** * HexString Convertir cadena * @param hexString * @return string * / public static string toStringhex (String s) {byte [] Bakeyword = new Byte [s.Length () / 2]; for (int i = 0; i <bakeyword.length; i ++) {try {Bakeyword [i] = (byte) (0xff & integer.parseInt (s.substring (i * 2, i * 2+2), 16)); } catch (Exception e) {E.PrintStackTrace (); }} try {s = new String (Bakeyword, "UTF-8"); // utf-16le: no} capt (excepción e1) {e1.printstacktrace (); } return s; }El artículo anterior sobre la conversión de Java, el método de conversión de byte y hexadecimal son todo el contenido que comparto con ustedes. Espero que pueda darle una referencia y espero que pueda apoyar más a Wulin.com.