Ada banyak cara untuk mengonversi sistem biner di Java. Di antara mereka, ada kelas pengemasan untuk heksadesimal desimal oktal biner dasar, dll., Yang tidak perlu diimplementasikan melalui algoritma dua-keluar. Dengan rincian sebagai berikut:
Pertama -tama, metode konversi biner yang paling sederhana adalah:
Konversi desimal menjadi heksadesimal:
String integer.tohexstring (int i)
Konversi desimal menjadi oktal
String integer.tooctalstring (int i)
Konversi desimal menjadi biner
String integer.tobinaryString (int i)
Mengubah heksadesimal menjadi desimal
Integer.valueof ("ffff", 16) .tostring () // tidak dapat menangani awalan 0x
Konversi oktal menjadi desimal
Integer.valueof ("76", 8) .tostring () // awalan 0 dapat diproses menjadi biner ke desimal
Integer.valueof ("0101", 2) .tostring ()
Apakah ada cara untuk secara langsung mengonversi 2, 8, heksadesimal menjadi desimal?
kelas java.lang.integer
parseint (string s, int radix)
Gunakan kardinalitas yang ditentukan oleh parameter kedua untuk menguraikan parameter string ke dalam integer yang ditandatangani.
Contoh dari JDK:
Parseint ("0", 10) mengembalikan 0
Parseint ("473", 10) mengembalikan 473
Parseint ("-0", 10) Returns 0
Parseint (" -ff", 16) mengembalikan -255
Parseint ("1100110", 2) Mengembalikan 102
Parseint ("2147483647", 10) Pengembalian 2147483647
Parseint (" -2147483648", 10) kembali -2147483648
ParseInt ("2147483648", 10) Throwsa NumberFormatException
Parseint ("99", Throwsa NumberFormatException
Parseint ("Kona", 10) Throwsa NumberFormatException
Parseint ("Kona", 27) mengembalikan 411787
Cara menulis konversi biner (dua, delapan, enam belas) tanpa algoritma
Integer.tobinarystring
Integer.tooctalString
Integer.tohexstring
Kemudian perkenalkan konversi byte dan heksadesimal di java
Analisis Prinsip:
Byte di Java terdiri dari 8 bit, dan heksadesimal adalah keadaan dalam 16, yang diwakili oleh 4 bit karena 24 = 16. Jadi kita dapat mengubah byte menjadi dua karakter heksadesimal, yaitu, mengubah 4 digit tinggi dan rendah 4 digit menjadi karakter heksadesimal yang sesuai, dan menggabungkan dua string heksadesimal ini untuk mendapatkan string heksadesimal byte. Demikian pula, konversi yang berlawanan juga mengubah dua karakter heksadesimal menjadi satu byte.
Di Java, ada dua ide utama untuk mengubah byte dan heksadesimal:
1. Ketika byte biner dikonversi menjadi heksadesimal, lakukan operasi "&" byte tinggi dan 0xf0, dan kemudian menggeser kiri dengan 4 bit untuk mendapatkan heksadesimal A dari byte tinggi; Lakukan operasi "&" byte rendah dan 0x0f untuk mendapatkan hexadecimal b dari rendah dan digit, dan merakit dua angka heksadesimal menjadi sepotong AB, yang merupakan representasi heksadesimal byte.
2. Ketika heksadesimal ke byte biner, pindahkan nomor desimal yang sesuai dengan karakter heksadesimal ke kanan 4 untuk mendapatkan byte tinggi; Lakukan "|" Pengoperasian nomor desimal B dan A dari karakter heksadesimal yang sesuai dengan byte rendah untuk mendapatkan representasi byte heksadesimal
Salah satu fungsi konversi adalah sebagai berikut:
/** * * @param bytes * @return mengonversi biner ke hexadecimal output karakter */</span> string statis pribadi hexstr = "0123456789AbcDef"; // Global Public Static String BinaryToHexString (byte [] bytes) {string result = ""; String hex = ""; untuk (int i = 0; i <bytes.length; i ++) {// byte adalah 4 bit lebih tinggi <strong> hex = string.valueof (hexstr.charat ((bytes [i] & 0xf0) >> 4)); </strong> // byte adalah 4 bit lebih rendah <strong> hex += string.valueof (hexstr.charat (bytes [i] & 0x0f)); </strong> hasil += hex; } hasil pengembalian; }/** * * @param hexstring * @return mengonversi hexadecimal ke array byte */byte statis publik [] hexStringTobinary (string hexString) {// panjang hexstring dibulatkan oleh 2, seperti panjang byte int len = hexstring.length ()/2; byte [] bytes = byte baru [len]; byte tinggi = 0; // byte tinggi byte empat bit rendah = 0; // byte rendah empat bit untuk (int i = 0; i <len; i ++) {// Transfer ke empat bit kanan untuk mendapatkan bit tinggi tinggi = (byte) ((hexstr.indexof (hexstring.charging (2*)) <<); low = (byte) hexstr.indexof (hexString.charat (2*i+1)); bytes [i] = (byte) (tinggi | rendah); // status tinggi atau operasi} return byte; }} Ada juga metode yang serupa:
<span style = "font-size: 14px;">* Convert byte [] ke string hex. Di sini kita dapat mengonversi byte ke int, dan kemudian menggunakan integer.tohexstring (int) untuk dikonversi ke string hex.
* @param src byte [] data * @return hex string */ public static string bytestoHexString (byte [] src) {stringBuilder stringBuilder = stringBuilder baru (""); if (src == null || src.length <= 0) {return null; } untuk (int i = 0; i <src.length; i ++) {int v = src [i] & 0xff; String hv = integer.tohexstring (v); if (hv.length () <2) {stringBuilder.append (0); } StringBuilder.append (hv); } return stringBuilder.toString (); } / ** * Konversi string hex ke byte [] * @param hexString string hex * @return byte [] * / public static byte [] hexStringTobytes (string hexString) {if (hexString == null || hexstring.equals ("")) {return excRing; } hexString = hexString.touppercase (); int panjang = hexString.length () / 2; char [] hexchars = hexString.tochararray (); byte [] d = byte baru [panjang]; untuk (int i = 0; i <panjang; i ++) {int pos = i * 2; d [i] = (byte) (chartobyte (hexchars [pos]) << 4 | chartobyte (hexchars [pos + 1]))); } return d; } / ** * Konversi char ke byte * @param c char * @return byte * / private byte chartobyte (char c) {return (byte) "0123456789abcDef" .indexof (c); } </span>Kedua metode ini serupa, harap dicatat di sini
Di atas adalah string yang mengonversi byte [] menjadi hexadecimal. Perhatikan bahwa B [i] & 0xff melakukan perhitungan byte dan 0xff, dan kemudian menggunakan integer.tohexstring untuk mendapatkan string hexadecimal. Anda bisa melihat itu
B [i] & Operasi 0xff masih int, jadi mengapa Anda perlu melakukan operasi int dengan 0xff? Direct Integer.tohexstring (b [i]);, tidak dapat memaksa byte untuk dikonversi? Jawabannya adalah tidak.
Alasannya adalah:
1. Ukuran byte adalah 8 bit dan ukuran int adalah 32 bit
2. Sistem dua bagian Java menggunakan komplemen
Oleh karena itu, ketika angka negatif adalah & dengan angka negatif, angka negatif akan secara otomatis mengisi 1, yang akan menyebabkan kesalahan
0xff adalah operasi plastik secara default, jadi ketika byte dan 0xff terlibat, byte akan dikonversi menjadi operasi operasi plastik terlebih dahulu, sehingga 24 bit tinggi dalam hasilnya akan selalu dibersihkan oleh 0, jadi hasilnya selalu seperti yang kita inginkan.
Ada beberapa metode ringkasan online:
Konversi String ke Hexadecimal String Metode 1:
/ *** Konversi string menjadi string hexadecimal*/ public static string str2Hexstr (string str) {char [] chars = "0123456789abcdef" .tochararray (); StringBuilder SB = StringBuilder baru (""); byte [] bs = str.getbytes (); int bit; untuk (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 (); }Konversi string hexadecimal menjadi metode array 1:
/ ** * Konversi hexString menjadi array byte * @param hexString * @return byte [] * / public static byte [] hexStringTobyte (string hex) {int len = (hex.length () / 2); byte [] hasil = byte baru [len]; char [] achar = hex.tochararray (); untuk (int i = 0; i <len; i ++) {int pos = i * 2; hasil [i] = (byte) (tobyte (achar [pos]) << 4 | tobyte (achar [pos + 1]))); } hasil pengembalian; } private static int tobyte (char c) {byte b = (byte) "0123456789AbcDef" .indexof (c); kembali b; }Konversi Array ke Metode String Hexadecimal 1:
/ ** * Konversi array menjadi string hex * @param byte [] * @return hexString */ public static final string bytestoHexString (byte [] barray) {stringBuffer sb = stringBuffer baru (barray.length); String stemp; untuk (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 (); }Metode 2 Mengonversi array byte [] menjadi string heksadesimal:
/ ** * Konversi array menjadi string hex * @param byte [] * @return hexString */ public static String tohexString1 (byte [] b) {stringBuffer buffer = new stringBuffer (); untuk (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; }}Metode 1 dari string konversi string heksadesimal:
/ ** * Konversi hexString menjadi string * @param hexstring * @return string */ public static string hexstr2str (string hexstr) {string str = "0123456789AbcDef"; char [] hexs = hexstr.tochararray (); byte [] bytes = byte baru [hexstr.length () / 2]; int n; untuk (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); }Metode 2 dari string konversi dalam string heksadesimal:
/ ** * hexString convert string * @param hexString * @return string * / public static string toStringHex (string s) {byte [] bakeyword = byte baru [s.length () / 2]; untuk (int i = 0; i <Bakeyword.length; i ++) {coba {Bakeyword [i] = (byte) (0xff & integer.parseint (s.substring (i * 2, i * 2+2), 16)); } catch (Exception e) {E.PrintStackTrace (); }} coba {s = string baru (bakeyword, "utf-8"); // utf-16le: not} catch (pengecualian e1) {e1.printstacktrace (); } return s; }Artikel di atas tentang konversi Java, metode konversi byte dan hexadecimal adalah semua konten yang saya bagikan dengan Anda. Saya harap Anda dapat memberi Anda referensi dan saya harap Anda dapat mendukung wulin.com lebih lanjut.