import android.text.TextUtils;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.nio.ByteBuffer;
public class BytesHexStrTranslate {
private static final char[] HEX_CHAR = {'0', '1', '2', '3', '4', '5',
'6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
public static String flipHexStr(String s) {
StringBuilder result = new StringBuilder();
for (int i = 0; i <= s.length() - 2; i = i + 2) {
result.append(new StringBuilder(s.substring(i, i + 2)).reverse());
}
return result.reverse().toString();
}
/**
* 10进制转16进制
*
* @param inarray
* @return
*/
public static String ByteArrayToHexString(byte[] inarray) {
int i, j, in;
String[] hex = {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A",
"B", "C", "D", "E", "F"};
StringBuilder out = new StringBuilder();
for (j = 0; j < inarray.length; ++j) {
in = (int) inarray[j] & 0xff;
i = (in >> 4) & 0x0f;
out.append(hex[i]);
i = in & 0x0f;
out.append(hex[i]);
}
return out.toString();
}
/**
* 方法一:
* byte[] to hex string
*10进制转16进制
* @param bytes
* @return
*/
public static String bytesToHexFun1(byte[] bytes) {
// 一个byte为8位,可用两个十六进制位标识
char[] buf = new char[bytes.length * 2];
int a = 0;
int index = 0;
for (byte b : bytes) { // 使用除与取余进行转换
if (b < 0) {
a = 256 + b;
} else {
a = b;
}
buf[index++] = HEX_CHAR[a / 16];
buf[index++] = HEX_CHAR[a % 16];
}
return new String(buf);
}
/**
* 方法二:
* byte[] to hex string
*
* @param bytes
* @return
*/
public static String bytesToHexFun2(byte[] bytes) {
char[] buf = new char[bytes.length * 2];
int index = 0;
for (byte b : bytes) { // 利用位运算进行转换,可以看作方法一的变种
buf[index++] = HEX_CHAR[b >>> 4 & 0xf];
buf[index++] = HEX_CHAR[b & 0xf];
}
return new String(buf);
}
/**
* 方法三:
* byte[] to hex string
*
* @param bytes
* @return
*/
public static String bytesToHexFun3(byte[] bytes) {
StringBuilder buf = new StringBuilder(bytes.length * 2);
for (byte b : bytes) { // 使用String的format方法进行转换
buf.append(String.format("%02x", new Integer(b & 0xff)));
}
return buf.toString();
}
/**
* bytes转换成十六进制字符串
*
* @param b byte数组
*/
public static String Bytes2hexStr(byte[] b) {
String stmp = "";
StringBuilder sb = new StringBuilder("");
for (int i = 0; i < b.length; i++) {
stmp = Integer.toHexString(b[i] & 0xFF);
sb.append((stmp.length() == 1) ? "0" + stmp : stmp);
sb.append(",");//每个Byte值之间空格分隔
}
return sb.toString().toUpperCase().trim();
}
/**
* 将16进制字符串转换为10进制byte[]
*
* @param str
* @return
*/
public static byte[] String16toBytes(String str) {
if (str == null || str.trim().equals("")) {
return new byte[0];
}
byte[] bytes = new byte[str.length() / 2];
for (int i = 0; i < str.length() / 2; i++) {
String subStr = str.substring(i * 2, i * 2 + 2);
bytes[i] = (byte) Integer.parseInt(subStr, 16);
}
return bytes;
}
/** 16进制的字符串转换成10进制字符串数组
* @param src
* @return
*/
public static byte[] HexString2Bytes(String src) {
int len = src.length() / 2;
byte[] ret = new byte[len];
byte[] tmp = src.getBytes();
for (int i = 0; i < len; i++) {
ret[i] = uniteBytes(tmp[i * 2], tmp[i * 2 + 1]);
}
return ret;
}
public 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;
}
/**
* byte数组转换成16进制字符数组
*
* @param src
* @return
*/
public static String[] bytesToHexStrings(byte[] src) {
if (src == null || src.length <= 0) {
return null;
}
String[] str = new String[src.length];
for (int i = 0; i < src.length; i++) {
int v = src[i] & 0xFF;
String hv = Integer.toHexString(v);
str[i] = "";
if (hv.length() < 2) {
str[i] = "0";
}
str[i] += hv;
}
return str;
}
/**
* byte数组转换成16进制字符串
*
* @param src
* @return
*/
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();
}
/*
* 字节数组转16进制字符串
*/
public static String bytes2HexString(byte[] b) {
String r = "";
for (int i = 0; i < b.length; i++) {
String hex = Integer.toHexString(b[i] & 0xFF);
if (hex.length() == 1) {
hex = '0' + hex;
}
r += hex.toUpperCase();
}
return r;
}
public static byte[] parseStringToByte(String msg) {
return String16toBytes(strTo16(msg));
}
/**
* * 字符串转化成为16进制字符串
* * @param s
* * @return
* 纯string转换
*/
public static String strTo16(String s) {
String str = "";
for (int i = 0; i < s.length(); i++) {
int ch = (int) s.charAt(i);
String s4 = Integer.toHexString(ch);
str = str + s4;
}
return str;
}
public static short byteToShort(byte[] b) {
short s = 0;
for (int i = 0; i < b.length; i++) {
s += (b[i] & 0xFF) << (8 * (1 - i));
}
return s;
}
public static byte[] toByteArray(double value) {
byte[] bytes = new byte[8];
ByteBuffer.wrap(bytes).putDouble(value);
return bytes;
}
//获取集合中的字符串,并且拼装成带“,”逗号的字符串
public static String getMaxString(double[] pinyuMax) {
if (pinyuMax != null) {
String value = "";
for (int i = 0; i < pinyuMax.length; i++) {
value += pinyuMax[i] + ",";
}
String substring = value.substring(0, value.length() - 1);
return substring;
}
return "";
}
/**
* 对象转数组
*
* @param obj
* @return
*/
public static byte[] toByteArray(Object obj) {
byte[] bytes = null;
ByteArrayOutputStream bos = new ByteArrayOutputStream();
try {
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(obj);
oos.flush();
bytes = bos.toByteArray();
oos.close();
bos.close();
} catch (IOException ex) {
ex.printStackTrace();
}
return bytes;
}
/**
* @param n
* @return
*/
public static byte[] intToBytes2(int n){
byte[] b = new byte[4];
for(int i = 0;i < 4;i++)
{
b[i]=(byte)(n>>(24-i*8));
}
return b;
}
//byte 数组与 int 的相互转换
public static int byteArrayToInt(byte[] b) {
return b[3] & 0xFF |
(b[2] & 0xFF) << 8 |
(b[1] & 0xFF) << 16 |
(b[0] & 0xFF) << 24;
}
public static byte[] intToByteArray(int a) {
byte[] request= new byte[] {
(byte) ((a >> 24) & 0xFF),
(byte) ((a >> 16) & 0xFF),
(byte) ((a >> 8) & 0xFF),
(byte) (a & 0xFF)
};
return request;
}
/**
* 16进制hex字符串转10进制byte数组
* @param inHex 待转换的Hex字符串
* @return 转换后的byte数组结果
*/
public static byte[] hexToByteArray(String inHex){
int hexlen = inHex.length();
byte[] result;
if (hexlen % 2 == 1){
//奇数
hexlen++;
result = new byte[(hexlen/2)];
inHex="0"+inHex;
}else {
//偶数
result = new byte[(hexlen/2)];
}
int j=0;
for (int i = 0; i < hexlen; i+=2){
result[j]=hexToByte(inHex.substring(i,i+2));
j++;
}
return result;
}
/**
* Hex字符串转byte
* @param inHex 待转换的Hex字符串
* @return 转换后的byte
*/
public static byte hexToByte(String inHex){
return (byte) Integer.parseInt(inHex,16);
}
/**
* 10进制转16进制
* @param n 待转数
* @return 转换后的16进制数
* 例如:10进制78 转换后16进制4E
*/
public static String intToHex(int n) {
StringBuffer s = new StringBuffer();
String a;
char []b = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
while(n != 0){
s = s.append(b[n%16]);
n = n/16;
}
a = s.reverse().toString();
return a;
}
/**
* 获取高八位
* @param value 10进制数
* @return
*/
public static byte heigh8(int value){
return (byte) (value>>8);//得到高八位16进制
}
/**
* 获取低八位
* @param value 10进制数
* @return
*/
public static byte low8(int value){
int low = value&0xff;//得到10进制的低八位
// intToHex(low);//把10进制转成16进制
if (TextUtils.isEmpty(String.valueOf(low)) || low == 0){
return 0x00;
}else {
return Integer.valueOf(intToHex(low),16).byteValue();
}
}
}