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的最大值,高出部分的位數也會被截掉,那就是災難性的了,所以一般不做這種轉換,除非你對待轉換的數據大小心中有數.