package com.ld.igds.util;
|
|
import java.math.BigInteger;
|
|
public class BytesUtil {
|
|
public static String byteToHex(byte b) {
|
String hex = Integer.toHexString(b & 0xFF);
|
if (hex.length() < 2) {
|
hex = "0" + hex;
|
}
|
return hex;
|
}
|
|
/**
|
* bytes输出十进制
|
*
|
* @param bytes
|
* @return
|
*/
|
public static Integer bytesToInt(byte[] bytes) {
|
String str = "";
|
int i = 0;
|
boolean flag = true && bytes.length > 0;
|
while (flag) {
|
Byte b = bytes[i];
|
i++;
|
Integer bi = Byte.toUnsignedInt(b);
|
str += toHexString(bi);
|
if (i >= bytes.length || str.endsWith("EEEE"))
|
flag = false;
|
}
|
return Integer.parseInt(str, 16);
|
}
|
|
/**
|
* bytes输出十六进制字符串
|
*
|
* @param bytes
|
* @return
|
*/
|
public static String bytesToString(byte[] bytes) {
|
String str = "";
|
int i = 0;
|
boolean flag = true && bytes.length > 0;
|
while (flag) {
|
Byte b = bytes[i];
|
i++;
|
Integer bi = Byte.toUnsignedInt(b);
|
str += toHexString(bi);
|
if (i >= bytes.length)
|
flag = false;
|
}
|
return str;
|
}
|
|
/**
|
* 十六进制转字节
|
*
|
* @param hex
|
* @return
|
*/
|
public static byte hexToByte(Integer hex) {
|
return hex.byteValue();
|
}
|
|
/**
|
* short转2字节 已调整高低位
|
*
|
* @param number
|
* @return
|
*/
|
public static byte[] shortToByte(short number) {
|
int temp = number;
|
byte[] b = new byte[2];
|
for (int i = 0; i < b.length; i++) {
|
b[i] = new Integer(temp & 0xff).byteValue();// 将最低位保存在最低位
|
temp = temp >> 8; // 向右移8位
|
}
|
return b;
|
}
|
|
/**
|
* 二进制子串转16进制子串
|
*
|
* @param bin
|
* @return
|
*/
|
public static String binToHex(String bin) {
|
String hexStr = "";
|
int size = bin.length() / 8;
|
for (int i = 0; i < size; i++) {
|
String value = bin.substring(i * 8, (i + 1) * 8);
|
int temp = Integer.parseInt(value, 2);
|
String tempHex = Integer.toHexString(temp);
|
hexStr += tempHex;
|
}
|
return hexStr;
|
}
|
|
/**
|
* 二进制转16进制，不足2位补位
|
*
|
* @param bin
|
* @return
|
*/
|
public static String bin2Hex(String bin) {
|
String hexStr = "";
|
int size = bin.length() / 8;
|
for (int i = 0; i < size; i++) {
|
String value = bin.substring(i * 8, (i + 1) * 8);
|
int temp = Integer.parseInt(value, 2);
|
String tempHex = Integer.toHexString(temp);
|
if (tempHex.length() < 2) {
|
tempHex = "0" + tempHex;
|
}
|
hexStr += tempHex;
|
}
|
|
return hexStr;
|
}
|
|
/**
|
* 转为十六进制串，不足2位补0
|
*
|
* @param value
|
* @return
|
*/
|
public static String toHexString(int value) {
|
String tempHex = Integer.toHexString(value);
|
if (tempHex.length() < 2) {
|
tempHex = "0" + tempHex;
|
}
|
return tempHex.toUpperCase();
|
}
|
|
public static String getTargetId(String value, boolean isTwo) {
|
String tempHex = Integer.toHexString(Integer.valueOf(value));
|
if (tempHex.length() < 2) {
|
tempHex = "0" + tempHex;
|
}
|
if (isTwo) {
|
if (tempHex.length() < 4) {
|
tempHex = "0" + tempHex;
|
}
|
if (tempHex.length() < 4) {
|
tempHex = "0" + tempHex;
|
}
|
}
|
return tempHex.toUpperCase();
|
}
|
|
/**
|
* 根据数值获取到长度为2字节的16进制字符
|
*
|
* @param value
|
* @return
|
*/
|
public static String getHex2LenStr(int value) {
|
String tempHex = Integer.toHexString(value);
|
if (tempHex.length() < 2) {
|
tempHex = "0" + tempHex;
|
}
|
if (tempHex.length() < 4) {
|
tempHex = "0" + tempHex;
|
}
|
if (tempHex.length() < 4) {
|
tempHex = "0" + tempHex;
|
}
|
return tempHex.toUpperCase();
|
}
|
|
public static String getOrderId(int value) {
|
return getHex2LenStr(value);
|
}
|
|
/**
|
* 将value转为same个相同满8位的二进制字串
|
*
|
* @param value
|
* @param same
|
* @return
|
*/
|
public static String toBinary8StringSame(int value, int same) {
|
String tempBinStr = toBinary8String(value);
|
String rsBinStr = "";
|
for (int i = 0; i < same; i++) {
|
rsBinStr += tempBinStr;
|
}
|
return rsBinStr;
|
}
|
|
public static String hexString2binaryString(String hexString, int num) {
|
//16进制转10进制
|
BigInteger sint = new BigInteger(hexString, num);
|
//10进制转2进制
|
String str = sint.toString(2);
|
if(str.length() < num){
|
for (int i = str.length(); i < num; i++) {
|
str = "0" + str;
|
}
|
}
|
return str;
|
}
|
|
/**
|
* 将二进制转换为10进制
|
* @param binStr
|
* @return
|
*/
|
public static Integer biannary2Decimal(String binStr){
|
|
Integer sum = 0;
|
int len = binStr.length();
|
|
for (int i=1;i<=len;i++){
|
//第i位 的数字为：
|
int dt = Integer.parseInt(binStr.substring(i-1,i));
|
sum+=(int)Math.pow(2,len-i)*dt;
|
}
|
return sum;
|
}
|
|
public static void main(String[] args) {
|
String s = hexString2binaryString("21E9", 16);
|
System.out.println(s);
|
}
|
|
/**
|
* 不足width个字节宽度时，前面补0至width*8
|
*
|
* @param value
|
* @param width
|
* @return
|
*/
|
public static String toBinary8String(int value, int width) {
|
String tempBinStr = toBinary8String(value);
|
int size = tempBinStr.length();
|
for (int i = 0; i < width; i++) {
|
int temp = (i + 1) * 8;
|
if (temp > size) {
|
tempBinStr = "00000000" + tempBinStr;
|
size = tempBinStr.length();
|
}
|
}
|
return tempBinStr;
|
}
|
|
/**
|
* 补足8位
|
*
|
* @param value
|
* @return
|
*/
|
public static String toBinary8String(int value) {
|
String temp = Integer.toBinaryString(value);
|
if (value == 0) {
|
temp = "00000000";
|
}
|
int length = temp.length();
|
while (length < 8) {
|
temp = "0" + temp;
|
length = temp.length();
|
}
|
return temp;
|
}
|
|
public static String toEmptyBinaryWidthString(int width) {
|
String str = "";
|
for (int i = 0; i < width; i++) {
|
str += "00000000";
|
}
|
return str;
|
}
|
|
public static byte[] emptyBytes(int bytes) {
|
byte[] bys = new byte[bytes];
|
for (int i = 0; i < bytes; i++) {
|
bys[i] = emptyByte();
|
}
|
return bys;
|
}
|
|
public static byte emptyByte() {
|
Integer b0 = 0x00;
|
return b0.byteValue();
|
}
|
|
public static byte binToBytes(String bin) {
|
return Integer.valueOf(bin, 2).byteValue();
|
}
|
|
public static byte[] binaryStrToBytes(String binStr) {
|
int size = binStr.length() / 8;
|
byte[] bs = new byte[size];
|
for (int i = 0; i < size; i++) {
|
String temp = binStr.substring(i * 8, (i + 1) * 8);
|
bs[i] = Integer.valueOf(temp, 2).byteValue();
|
}
|
return bs;
|
}
|
|
/**
|
* 十六进制串转字节数组
|
*
|
* @param hexStr
|
* @return
|
*/
|
public static byte[] hexStrToBytes(String hexStr) {
|
int size = hexStr.length() / 2;
|
byte[] bytes = new byte[size];
|
for (int i = 0; i < size; i++) {
|
String tmp = hexStr.substring(i * 2, (i + 1) * 2);
|
Integer tmpHex = Integer.parseInt(tmp, 16);
|
bytes[i] = tmpHex.byteValue();
|
}
|
return bytes;
|
}
|
|
/**
|
* 两字节高低位装换
|
*
|
* @param b
|
* @return
|
*/
|
public static byte[] hexHeightLow(byte[] b) {
|
byte[] b2 = new byte[2];
|
// 转换高低位
|
b2[0] = b[1];
|
b2[1] = b[0];
|
return b2;
|
}
|
|
/**
|
* 16进制转换为10进制
|
*
|
* @param strHex
|
* @return
|
*/
|
public static int hexToInt(String strHex) {
|
short s = (short) (Integer.valueOf(strHex, 16) & 0xffff);
|
return s;
|
}
|
|
/**
|
* 16进制转换为10进制
|
*
|
* @param strHex
|
* @return
|
*/
|
public static int hexToBigInt(String strHex) {
|
BigInteger bigint = new BigInteger(strHex, 16);
|
return bigint.intValue();
|
}
|
|
/**
|
* int转16进制字符串 2位 00 00
|
*
|
* @param num
|
* @return
|
*/
|
public static String intToHexStr(int num) {
|
// 需要使用2字节表示b
|
return String.format("%04x", num).toUpperCase();
|
}
|
|
/**
|
* int转16进制字符串 1位置 00
|
*
|
* @param num
|
* @return
|
*/
|
public static String intToHexStr1(int num) {
|
// 需要使用2字节表示b
|
return String.format("%02x", num).toUpperCase();
|
}
|
|
|
// 计算16进制对应的数值
|
public static int GetHex(char ch) throws Exception {
|
if (ch >= '0' && ch <= '9')
|
return (int) (ch - '0');
|
if (ch >= 'a' && ch <= 'f')
|
return (int) (ch - 'a' + 10);
|
if (ch >= 'A' && ch <= 'F')
|
return (int) (ch - 'A' + 10);
|
throw new Exception("error param");
|
}
|
|
// 计算幂
|
public static int GetPower(int nValue, int nCount) throws Exception {
|
if (nCount < 0)
|
throw new Exception("nCount can't small than 1!");
|
if (nCount == 0)
|
return 1;
|
int nSum = 1;
|
for (int i = 0; i < nCount; ++i) {
|
nSum = nSum * nValue;
|
}
|
return nSum;
|
}
|
|
/**
|
* 16进制字符串 高低换位
|
*
|
* @param info
|
* @return
|
*/
|
public static String tran_LH(String info) {
|
return info.substring(2) + info.substring(0, 2);
|
}
|
|
/**
|
* 16进制字符串 高低换位 8个字符
|
*
|
* @param info
|
* @return
|
*/
|
public static String tran_LH8(String info) {
|
return tran_LH(info.substring(4)) + tran_LH(info.substring(0, 4));
|
}
|
|
/**
|
* 将 4字节的16进制字符串，转换为32位带符号的十进制浮点型
|
*
|
* 42c60000 -> 99.00
|
*
|
* @param str
|
* 4字节 16进制字符
|
* @return
|
*/
|
public static float hexToFloat(String str) {
|
return Float.intBitsToFloat(new BigInteger(str, 16).intValue());
|
}
|
|
/**
|
* 将带符号的32位浮点数装换为16进制
|
*
|
* 99.00 -> 42c60000
|
*
|
*
|
* @param value
|
* @return
|
*/
|
public static String folatToHexString(Float value) {
|
return Integer.toHexString(Float.floatToIntBits(value));
|
}
|
}
|
