javaint转bcd

① java中int强制转换byte

int 是32位 4个字节 8位1字激芹节
int转换成byte 前面的3个字节 即24位 直接砍掉 就剩最后一位
所以 266 ——（00000000）（00000000）（00000001）（00001010）
== 0001010 = 1* 2 + 1 *2*2*2 = 10
最开始的0 表宴铅郑示是正数
如果是1表示负数 还要先按位取反再加1 然后才能算出来表示晌颂的数值

② JAVA里int型强制转化成byte型

因为java的byte类型只占一个字节，即2的8次方，碰指表笑者配示的范围是0~127，128溢出了当做0，129为1，以此类推。所以 257转换为byte后的值为：嫌基257-128-128=1323转换为byte后：323-128-128=67

③ 请问如何将int型的数转化为BCD码

应先把二进制转为十进制，再转为BCD码，如果右移的话就把二进制数拆开了

④ 在java中int类型能自动转换成什么类型

int是基础数据类型，不能直接转成string类型，但是可以通过以下方式启枝转换悄埋敏：
与String相加，例如 int i = 10; String s = ""+i;
调用液弊String提供的api String.valueOf(i); 得到的就是String类型。
使用int的包装类，Integer.toString()也可以。

⑤ java中如何实现BCD码字符串与16进制字符串的互转

nt main(void)
4{
5 unsigned char array[4] = {"0x0","0x0","0x02","0xe7"};
6 unsigned long num;
7 num = 0;
8 for(int i=0; i<sizeof(array); i++)
9 {
10 num<<=8;
11 num |= array[i];
12 }
13 printf("核拿num = %d",num);
14 return 0;
15
16}

二进制,字节数组拆氏洞,字符,十六进制,BCD编码转换
* 把16进制字旅枯符串转换成字节数组
* @param hex
* @return
*/
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 final String bytesToHexString(byte[] bArray) {
StringBuffer sb = new StringBuffer(bArray.length);
String 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();
}

public static final Object bytesToObject(byte[] bytes) throws IOException, ClassNotFoundException {
ByteArrayInputStream in = new ByteArrayInputStream(bytes);
ObjectInputStream oi = new ObjectInputStream(in);
Object o = oi.readObject();
oi.close();
return o;
}

public static final byte[] objectToBytes(Serializable s) throws IOException {
ByteArrayOutputStream out = new ByteArrayOutputStream();
ObjectOutputStream ot = new ObjectOutputStream(out);
ot.writeObject(s);
ot.flush();
ot.close();
return out.toByteArray();
}

public static final String objectToHexString(Serializable s) throws IOException{
return bytesToHexString(objectToBytes(s));
}

public static final Object hexStringToObject(String hex) throws IOException, ClassNotFoundException{
return bytesToObject(hexStringToByte(hex));
}

public static String bcd2Str(byte[] bytes){
StringBuffer temp=new StringBuffer(bytes.length*2);

for(int i=0;i<bytes.length;i++){
temp.append((byte)((bytes[i]& 0xf0)>>>4));
temp.append((byte)(bytes[i]& 0x0f));
}
return temp.toString().substring(0,1).equalsIgnoreCase("0")?temp.toString().substring(1):temp.toString();
}

public static byte[] str2Bcd(String asc) {
int len = asc.length();
int mod = len % 2;

if (mod != 0) {
asc = "0" + asc;
len = asc.length();
}

byte abt[] = new byte[len];
if (len >= 2) {
len = len / 2;
}

byte bbt[] = new byte[len];
abt = asc.getBytes();
int j, k;

for (int p = 0; p < asc.length()/2; p++) {
if ( (abt[2 * p] >= '0') && (abt[2 * p] <= '9')) {
j = abt[2 * p] - '0';
} else if ( (abt[2 * p] >= 'a') && (abt[2 * p] <= 'z')) {
j = abt[2 * p] - 'a' + 0x0a;
} else {
j = abt[2 * p] - 'A' + 0x0a;
}

if ( (abt[2 * p + 1] >= '0') && (abt[2 * p + 1] <= '9')) {
k = abt[2 * p + 1] - '0';
} else if ( (abt[2 * p + 1] >= 'a') && (abt[2 * p + 1] <= 'z')) {
k = abt[2 * p + 1] - 'a' + 0x0a;
}else {
k = abt[2 * p + 1] - 'A' + 0x0a;
}

int a = (j << 4) + k;
byte b = (byte) a;
bbt[p] = b;
}
return bbt;
}

public static String BCD2ASC(byte[] bytes) {
StringBuffer temp = new StringBuffer(bytes.length * 2);

for (int i = 0; i < bytes.length; i++) {
int h = ((bytes[i] & 0xf0) >>> 4);
int l = (bytes[i] & 0x0f);
temp.append(BToA[h]).append( BToA[l]);
}
return temp.toString() ;
}

public static String MD5EncodeToHex(String origin) {
return bytesToHexString(MD5Encode(origin));
}

public static byte[] MD5Encode(String origin){
return MD5Encode(origin.getBytes());
}

public static byte[] MD5Encode(byte[] bytes){
MessageDigest md=null;
try {
md = MessageDigest.getInstance("MD5");
return md.digest(bytes);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
return new byte[0];
}

}
//关于byte: signed byte 把 0x00 ~ 0xff 映射成范围 0~127和 -128~-1 两段,比较简单的办法用 (b+256)%256的办法令其值回到0~255，或者用&0xff并赋给一个int

⑥ java中int如何转换byte

因为在java中，int类型的占4个字节，而byte占1个字节，所以int类型转化为byte类型时会出现位丢失情况，即将int的低8位作为byte类型的值。int型变量的值为257，对应的二进制是100000001，后8位是00000001，第一个0表示符号位，表示正数，所以变量x的值为1。

⑦ JAVA中怎么将int数据转换为byte数据

JAVA中根据以下代码将int数据转换为byte数据：

public static byte[] int32ToBytes(int val) {

int size = Integer.SIZE / Byte.SIZE;

byte[] ret = new byte[size];

for (int i = 0; i < size; ++i) {

ret[i] = (byte) (val << (8 * i) >>茄颂闹 56);

}

return ret;

}

(7)javaint转bcd扩展阅读

Java也提供了一个byte数据类型，并且是基本类型。java byte是做为最小的数字来处理的，因此它的值域被定义为-128~127，也就是signed byte。

byte，颤罩即字节，由8位的二进制组成。在Java中，byte类型的数据是8位带符号的二进制数。在计算机中，8位带符号二进制数的取值范围是[-128, 127]，所以在Java中，byte类型的取值范围也是[-128, 127]。樱坦

运算规则：

####正数的最高位都是 0 ，正数的值就是二进制表示的值。 ####

####负数的最高位都是 1 ，负数的值是 取反后加一 然后加个负号得到得值。 ####

⑧ Java 中怎样将 int 强制转化为 double

• 高向低转换，因为涉及到位数变少，所以可能会丢失数字，产生误差，所以一般不让转化，确实需要转化的时候就如兆行你所说格式，进行强制类型转换，反过码樱来，低向高转化，则完全不用考虑数据产生误差问题，可以直接使用的，方法为：

1. 比如直接将a赋给一个double变量，double c=a。

2. 总结：往面向对象来说，double就相当于int的抽象

⑨ JAVA中怎么把int型数据转为BigInteger型数据

1、创建java类，TestBigInteger.java；

⑩ 在java里怎么把Int转换为double型

使用强制类型转换,就是要转换的类型,加个括号.
int iA;
double dA;
iA=1234;
dA=(double)iA;
//这样dA就等于1234.00
dA=12.34567;
iA=(int)dA;
//这样iA就等于12,问题是这种转换回会损失精度,小数部分被截答取还可以接受,如果double超出了int的最大值,高出部分的位数也会被截掉,那就是灾难性的了,所以一般不做这种转换,除非你对待转换的数据大小心中有数.