❶ 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();