❶ String 類型 轉 byte 16進制 java
String str = "#15";
int x = Integer.decode(str);
System.out.println(Integer.toHexString(x));
❷ JAVA串口怎麼發送16進制
那就需要轉換了。
我最近也在做這樣的項目，轉換來，轉換去麻煩死。
發送的16進制串要先轉換為byte[]然後writer
接受方read()後要把位元組在轉換成16進制串。
//16進制串轉換成位元組數組
public static byte[] hexStringToBytes(String hexString)
{
if ((hexString == null) || (hexString.equals(""))) {
return null;
}
hexString = hexString.toUpperCase();
int length = hexString.length() / 2;
char[] hexChars = hexString.toCharArray();
byte[] d = new byte[length];
for (int i = 0; i < length; ++i) {
int pos = i * 2;
d[i] = (byte)(charToByte(hexChars[pos]) << 4 | charToByte(hexChars[(pos + 1)]));
}
return d;
}
private static byte charToByte(char c)
{
return (byte)"0123456789ABCDEF".indexOf(c);
}
//位元組數組轉換成16進制串
public static String byte2HexStr(byte[] b, int length)
{
String hs = "";
String stmp = "";
for (int n = 0; n < length; ++n) {
stmp = Integer.toHexString(b[n] & 0xFF);
if (stmp.length() == 1)
hs = hs + "0" + stmp;
else {
hs = hs + stmp;
}
}
return hs.toUpperCase();
} 不明白+wo 448667
❸ java 16進制字元串轉為二進制bit數組
應該用byte型數組
public static String stringToHexString(String strPart) {
String hexString = "";
for (int i = 0; i < strPart.length(); i++) {
int ch = (int) strPart.charAt(i);
String strHex = Integer.toHexString(ch);
hexString = hexString + strHex;
}
return hexString;
}
private static String hexString="0123456789ABCDEF";
/*
* 將字元串編碼成16進制數字,適用於所有字元（包括中文）
*/
public static String encode(String str)
{
// 根據默認編碼獲取位元組數組
byte[] bytes=str.getBytes();
StringBuilder sb=new StringBuilder(bytes.length*2);
// 將位元組數組中每個位元組拆解成2位16進制整數
for(int i=0;i<bytes.length;i++)
{
sb.append(hexString.charAt((bytes[i]&0xf0)>>4));
sb.append(hexString.charAt((bytes[i]&0x0f)>>0));
}
return sb.toString();
}
/*
* 將16進制數字解碼成字元串,適用於所有字元（包括中文）
*/
public static String decode(String bytes)
{
ByteArrayOutputStream baos=new ByteArrayOutputStream(bytes.length()/2);
// 將每2位16進制整數組裝成一個位元組
for(int i=0;i<bytes.length();i+=2)
baos.write((hexString.indexOf(bytes.charAt(i))<<4 |hexString.indexOf(bytes.charAt(i+1))));
return new String(baos.toByteArray());
}
private static byte uniteBytes(byte src0, byte src1) {
byte _b0 = Byte.decode("0x" + new String(new byte[] {src0})).byteValue();
_b0 = (byte) (_b0 << 4);
byte _b1 = Byte.decode("0x" + new String(new byte[] {src1})).byteValue();
byte ret = (byte) (_b0 | _b1);
return ret;
public static byte[] HexString2Bytes(String src)
{
byte[] ret = new byte[6];
byte[] tmp = src.getBytes();
for(int i=0; i<6; ++i )
{
ret[i] = uniteBytes(tmp[i*2], tmp[i*2+1]);
}
return ret;
}
❹ 用JAVA編程用一個數組來存放一個16進制數,並將該16進制數轉換為二進制後存入該數組中,最後輸出.
//16進制轉二進制
public static void main(String[] args)
{
String hexString = "ABCD";
System.out.println(hexString2binaryString(hexString));
}
public static String hexString2binaryString(String hexString)
{
if (hexString == null || hexString.length() % 2 != 0)
return null;
String bString = "", tmp;
for (int i = 0; i < hexString.length(); i++)
{
tmp = "0000"
+ Integer.toBinaryString(Integer.parseInt(hexString
.substring(i, i + 1), 16));
bString += tmp.substring(tmp.length() - 4);
}
return bString;
}
你說數組只有 1個元素。那改成String[]={}
❺ java中十六進制怎麼轉換為2進制
java十六進制轉換為2進制示例如下：
publicclassHex2Binary
{
publicstaticvoidmain(String[]args)
{
StringhexString="ABCD";
System.out.println(hexString2binaryString(hexString));
}
(StringhexString)
{
if(hexString==null||hexString.length()%2!=0)
returnnull;
StringbString="",tmp;
for(inti=0;i<hexString.length();i++)
{
tmp="0000"
+Integer.toBinaryString(Integer.parseInt(hexString
.substring(i,i+1),16));
bString+=tmp.substring(tmp.length()-4);
}
returnbString;
}
}
❻ JAVA返回語句
有 5.3.1 使用break 語句在Java 中，break語句有3種作用。第一，你已經看到，在switch語句中，它被用來終止一個語句序列。第二，它能被用來退出一個循環。第三，它能作為一種「先進」goto 語句來使用。下面對最後 2種用法進行解釋。 使用break 退出循環 可以使用break 語句直接強行退出循環，忽略循環體中任何其他語句和循環條件測試。在循環中遇到break語句時，循環被終止，程序控制在循環後面語句重新開始。下面是一個簡單例子： // Using break to exit a loop. class BreakLoop { public static void main(String args[]) { for(int i=0; i<100; i++) { if(i == 10) break; // terminate loop if i is 10 System.out.println("i: " + i); } System.out.println("Loop complete."); } } 該程序產生如下輸出： i: 0 i: 1 i: 2 i: 3 i: 4 i: 5 i: 6 i: 7 i: 8 i: 9 Loop complete. 正如你看到那樣，盡管for 循環被設計為從 0執行到99，但是當i等於10時，break語句終止程序。break語句能用於任何 Java 循環中，包括人們有意設置無限循環。例如，將上一個程序用while 循環改寫如下。該程序輸出和剛才看到輸出一樣。 // Using break to exit a while loop. class BreakLoop2 { public static void main(String args[]) { int i = 0; while(i < 100) { if(i == 10) break; // terminate loop if i is 10 System.out.println("i: " + i); i++; } System.out.println("Loop complete."); } } 在一系列嵌套循環中使用break 語句時，它將僅僅終止最裡面循環。例如： // Using break with nested loops. class BreakLoop3 { public static void main(String args[]) { for(int i=0; i<3; i++) { System.out.print("Pass " + i + ": "); for(int j=0; j<100; j++) { if(j == 10) break; // terminate loop if j is 10 System.out.print(j + " "); } System.out.println(); } System.out.println("Loops complete."); } } 該程序產生如下輸出： Pass 0: 0 1 2 3 4 5 6 7 8 9 Pass 1: 0 1 2 3 4 5 6 7 8 9 Pass 2: 0 1 2 3 4 5 6 7 8 9 Loops complete. 從中可以看出，在內部循環中break語句僅僅終止該循環，外部循環不受影響。 break ，在這里要記住兩點。首先，一個循環中可以有一個以上break 語句。但要小心，太多break 語句會破壞你代碼結構。其次，switch語句中break僅僅影響該switch 語句，而不會影響其中任何循環。 注意：break 不是被設計來提供一種正常循環終止方法。循環條件語句是專門用來終止循環。只有在某類特殊情況下，才用break 語句來取消一個循環。 把break 當作goto 一種形式來用 break語句除在switch語句和循環中使用之外，它還能作為goto 語句一種「文明」形式來使用。Java 中沒有 goto 語句，因為goto 語句提供一種改變程序運行流程非結構化方式。這通常使程序難以理解和難於維護。它也阻止某些編譯器優化。但是，有些地方goto 語句對於構造流程式控制制是有用而且是合法。例如，從嵌套很深循環中退出時， goto 語句就很有幫助。因此，Java 定義break 語句一種擴展形式來處理這種情況。通過使用這種形式break，你可以終止一個或者幾個代碼塊。這些代碼塊不必是一個循環或一個switch語句一部分，它們可以是任何塊。而且，由於這種形式break 語句帶有標簽，你可以明確指定執行從何處重新開始。你將看到，break帶給你是goto 益處，並舍棄goto 語句帶來麻煩。 標簽break 語句通用格式如下所示： break label; 這里，標簽label 是標識代碼塊標簽。當這種形式break執行時，控制被傳遞出指定代碼塊。被加標簽代碼塊必須包圍break 語句，但是它不需要是直接包圍break塊。這意味著你可以使用一個加標簽break 語句退出一系列嵌套塊。但是你不能使用break 語句將控制傳遞到不包含break 語句代碼塊。 要指定一個代碼塊，在其開頭加一個標簽即可。標簽（label ）可以是任何合法有效Java 標識符後跟一個冒號。一旦你給一個塊加上標簽後，你就可以使用這個標簽作為break 語句對象。這樣做會使執行在加標簽塊結尾重新開始。例如，下面程序示例 3 個嵌套塊，每一個都有它自己標簽。break語句使執行向前跳，調過定義為標簽second 代碼塊結尾，跳過2個println ( ) 語句。 // Using break as a civilized form of goto. class Break { public static void main(String args[]) { boolean t = true; first: { second: { third: {System.out.println("Before the break.");if(t) break second; // break out of second blockSystem.out.println("This won't execute"); } System.out.println("This won't execute");}System.out.println("This is after second block."); } } } 運行該程序，產生如下輸出： Before the break. This is after second block. 標簽break 語句一個最普遍用法是退出循環嵌套。例如，下面程序中，外層循環只執行一次： // Using break to exit from nested loops class BreakLoop4 { public static void main(String args[]) { outer: for(int i=0; i<3; i++) { System.out.print("Pass " + i + ": "); for(int j=0; j<100; j++) { if(j == 10) break outer; // exit both loops System.out.print(j + " "); } System.out.println("This will not print"); } System.out.println("Loops complete."); } } 該程序產生如下輸出： Pass 0: 0 1 2 3 4 5 6 7 8 9 Loops complete. 你可以看到，當內部循環退到外部循環時，兩個循環都被終止。記住如果一個標簽不在包圍break塊中定義，你就不能break 到該標簽。例如，下面程序就是非法，且不會被編譯： // This program contains an error. class BreakErr { public static void main(String args[]) { one: for(int i=0; i<3; i++) { System.out.print("Pass " + i + ": "); } for(int j=0; j<100; j++) { if(j == 10) break one; // WRONG System.out.print(j + " "); } } } 因為標簽為one循環沒有包圍break 語句，所以不能將控制傳遞到該塊。 5.3.2 使用continue 語句有時強迫一個循環提早反復是有用。也就是，你可能想要繼續運行循環，但是要忽略這次重復剩餘循環體語句。實際上，goto 只不過是跳過循環體，到達循環尾部。continue 語句是break語句補充。在while 和do while 循環中，continue 語句使控制直接轉移給控制循環條件表達式，然後繼續循環過程。在for 循環中，循環反復表達式被求值，然後執行條件表達式，循環繼續執行。對於這3種循環，任何中間代碼將被旁路。 下例使用continue 語句，使每行列印2個數字： // Demonstrate continue. class Continue { public static void main(String args[]) { for(int i=0; i<10; i++) { System.out.print(i + " "); if (i%2 == 0) continue; System.out.println(""); } } } 該程序使用%（模）運算符來檢驗變數i是否為偶數，如果是，循環繼續執行而不輸出一個新行。該程序結果如下： 0 1 2 3 4 5 6 7 8 9 對於break語句，continue 可以指定一個標簽來說明繼續哪個包圍循環。下面例子運用continue 語句來列印0到9三角形乘法表： // Using continue with a label. class ContinueLabel { public static void main(String args[]) { outer: for (int i=0; i<10; i++) { for(int j=0; j<10; j++) { if(j > i) { System.out.println(); continue outer; } System.out.print(" " + (i * j)); }} System.out.println(); } } 在本例中continue 語句終止計數j循環而繼續計數i下一次循環反復。該程序輸出如下： 0 0 1 0 2 4 0 3 6 9 0 4 8 12 16 0 5 10 15 20 25 0 6 12 18 24 30 36 0 7 14 21 28 35 42 49 0 8 16 24 32 40 48 56 64 0 9 18 27 36 45 54 63 72 81 很好利用continue 語句情況很少，一個原因是Java 提供一系列豐富循環語句，可以適用於絕大多數應用程序。但是，對於那些需要提早反復特殊情形，continue 語句提供一個結構化方法來實現。 5.3.3 使用return語句最後一個控制語句是return。return語句用來明確地從一個方法返回。也就是，return 語句使程序控制返回到調用它方法。因此，將它分類為跳轉語句。盡管對return 語句詳細討論在第 7 章開始，這里對其作簡要地介紹。 在一個方法任何時間，return 語句可被用來使正在執行分支程序返回到調用它方法。下面例子說明這一點。下例中，由於是Java 運行系統調用main() ，因此，return語句使程序執行返回到Java 運行系統。 // Demonstrate return. class Return { public static void main(String args[]) { boolean t = true; System.out.println("Before the return."); if(t) return; // return to caller System.out.println("This won't execute."); } } 該程序結果如下： Before the return. 正如你看到一樣，最後println( ) 語句沒有被執行。一旦return語句被執行，程序控制傳遞到它調用者。 最後一點：在上面程序中，if(t)語句是必要。沒有它，Java 編譯器將標記「執行不到代碼」（unreachable code ）錯誤，因為編譯器知道最後println （）語句將永遠不會被執行。為阻止這個錯誤，為這個例子能夠執行，在這里使用if語句來「蒙騙」編譯器。
❼ java中如何將byte[]裡面的數據轉換成十六進制
/* *
* Convert byte[] to hex string.這里我們可以將byte轉換成int，然後利用Integer.toHexString(int)
*來轉換成16進制字元串。
* @param src byte[] data
* @return hex string
*/
public static String bytesToHexString(byte[] src){
StringBuilder stringBuilder = new StringBuilder("");
if (src == null || src.length <= 0) {
return null;
}
for (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();
}
此方法能將byte[]轉化成16進制字元串，希望能幫到你。
❽ Java 進制轉換
public static void main(String[] args) {
int x = (int)(Math.random()*1000+1);
System.out.println("隨機數:"+x);
String allNumber = Integer.toString(x,3);
String[] tmmp = allNumber.split("");
String y = "";
for(String str : tmmp){
if (y.length() == 0 ){
y = y + str;
}else{
y=y+","+str;
}
}
System.out.println("生成的三進制："+y);
// 逆序輸出
StringBuffer sb = new StringBuffer(allNumber);
String tmpx = sb.reverse().toString();
System.out.println("逆序輸出結果："+tmpx);
//計算十六進制
String hexString = Integer.toString(Integer.parseInt(tmpx),16);
System.out.println("hexString="+hexString);
// 都換成十進制進行比較
int intB = Integer.valueOf(hexString,16);
int intA = Integer.valueOf(y,3);
if(intA>intB){
System.out.println("A>B");
}else if(intA==intB){
System.out.println("A=B");
}else{
System.out.println("A<B");
}
❾ 編寫十六進制的字元串轉換為byte數組的函數： public byte[] hexStringToBytes(String hexString); 每兩個
public class Zhuanhuan {
public static byte[] hexStringToByte(String hex) {
int len = (hex.length() / 2);
byte[] result = new byte[len];
char[] achar = hex.toCharArray();
for (int i = 0; i < len; i++) {
int pos = i * 2;
result[i] = (byte) (toByte(achar[pos]) << 4 | toByte(achar[pos + 1]));
}
return result;
}
private static byte toByte(char c) {
byte b = (byte) "0123456789ABCDEF".indexOf(c);
return b;
}
public static void main(String args[]){
Zhuanhuan zh=new Zhuanhuan();
byte[] s=Zhuanhuan.hexStringToByte("23ff2289");
System.out.println(s[4]);
}
}
❿ 誰幫我解釋一下這個演算法（java）
將一個長整型變數value，轉換成String型值返回，String長度為len
定義一個接收結果的char數組
char[] cValue;
cValue = new char[len];
j = value;
while (j>256){
//j除以256取余，結果存入char數組中
t = j/256;
cValue[i++] = (char)(j - t*256);
//將j除以256後的整數部分轉入j中，准備下一個循環的運算
j = t;
}
cValue[i++] = (char)j;
//將char數組轉為String類型，並返回
return String.valueOf(cValue); //.toString();