在写java qq安卓协议的时候,遇到很多麻烦,其中一个就是以下汇编语言
没时间去看具体意思,只能摸索,如下代码
.版本 2
.子程序 到无符号长整型, 长整数型
.参数 long, 整数型
置入代码 ({ 139, 69, 8, 51, 210, 201, 194, 4, 0 })
返回 (0)
//* “长整数形:-2047848776”
// * “转换后:2247118520”
package com.koow.kkwwo.bytes.util;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.Random;
import org.apache.log4j.Logger;
import com.koow.kkwwo.c.Pack;
import com.koow.kkwwo.hex.util.HexUtil;
/**
* 和 byte[]的相互转换
*
* @author Koow
*
*/
public class ToButeArray {
private static Logger logger = Logger.getLogger(ToButeArray.class);
/**
* 16进制字符串转Int Integer.parseInteger的时候,会将传入十六进制数字一致认为成正数,
* 所以这时候表示负数的十六进制字符串所表示的数字就超出了Integer所能表示的数字范围,会报出NumberFormatException
* 转换为BigInteger再转换Int
*
* @param n
* @return
*/
public static Integer String16ToInt(String n) {
n=Pack.c_Null(n);
return Integer.valueOf(n, 16);
}
/**
* 16进制字符串转BigInteger
*
* @param n
* @return
*/
public static BigInteger String16ToBigInteger(String n) {
n=Pack.c_Null(n);
return new BigInteger(n, 16);
}
/**
* Int转16进制字符串
*
* @param n
* @return
*/
public static String LongToString16(long n) {
String st = Long.toHexString(n).toUpperCase();
st = String.format("%5s", st);
st = st.replaceAll(" ", "0");
return st;
}
/**
* 整数转换成字节数组 关键技术:ByteArrayOutputStream和DataOutputStream
*
* @param n
* 需要转换整数
* @return
*/
public static byte[] intToButeArray(int n) {
byte[] byteArray = null;
try {
ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
DataOutputStream dataOut = new DataOutputStream(byteOut);
dataOut.writeInt(n);
byteArray = byteOut.toByteArray();
} catch (IOException e) {
logger.error("IntToButeArray类_intToButeArray方法异常", e);
}
return byteArray;
}
/**
* long转换成字节数组
*
* @param n
* 需要转换long
* @return
*/
public static byte[] longToButeArray(long n) {
byte[] byteArray = null;
try {
ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
DataOutputStream dataOut = new DataOutputStream(byteOut);
dataOut.writeLong(n);
byteArray = byteOut.toByteArray();
} catch (IOException e) {
logger.error("IntToButeArray类_longToButeArray方法异常", e);
}
return byteArray;
}
/**
* 字节数组转换成整数
*
* @param byteArray
* 需要转换的字节数组
* @return
*/
public static int byteArrayToInt(byte[] byteArray) {
int n = 0;
try {
ByteArrayInputStream byteInput = new ByteArrayInputStream(byteArray);
DataInputStream dataInput = new DataInputStream(byteInput);
n = dataInput.readInt();
} catch (IOException e) {
// TODO Auto-generated catch block
logger.error("IntToButeArray类_byteArrayToInt方法异常", e);
}
return n;
}
/**
* 将指定byte数组以16进制的形式打印到控制台
*
* @param b
*/
public static void printHexString(byte[] b) {
for (int i = 0; i < b.length; i++) {
String hex = Integer.toHexString(b[i] & 0xFF);
if (hex.length() == 1) {
hex = '0' + hex;
}
System.out.print(hex.toUpperCase());
}
}
/**
* Convert 字符集转16进制文本(字符串) 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();
}
/**
* Convert hex string to byte[] 16进制文本(字符串)转字符集 当字符串为1的时候,会出现返回为空
* 推荐使用HexUtil 工具类
*
* @param hexString
* the hex string
* @return byte[]
*/
public static byte[] hexStringToBytes(String hexString) {
hexString=Pack.c_Null(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;
}
/**
* 合并byte数组
*/
public static byte[] unitByteArray(byte[] byte1, byte[] byte2) {
byte[] unitByte = new byte[byte1.length + byte2.length];
System.arraycopy(byte1, 0, unitByte, 0, byte1.length);
System.arraycopy(byte2, 0, unitByte, byte1.length, byte2.length);
return unitByte;
}
/**
* 截取byte数组
*
* @param byte1
* @param a
* 从a位置开始截取,0为开始
* @param b
* 截取多少位
* @return
*/
public static byte[] subByteArray(byte[] byte1, Integer a, Integer b) {
byte[] unitByte = new byte[b];
System.arraycopy(byte1, a, unitByte, 0, b);
return unitByte;
}
/**
* 判断byte是否小于零 将byte=-109转换为147
*
* @param b
* @return
*/
public static int byteToPositive(byte b) {
if (b < 0) {
return b + 256;
} else {
return b;
}
}
/**
* 使用 0xFF 与 将byte=-109转换为147
*
* @param b
* @return
*/
public static int byteToPositive2(byte b) {
return b & 0xFF;
}
/**
* Convert char to byte
*
* @param c
* char
* @return byte
*/
private static byte charToByte(char c) {
return (byte) "0123456789ABCDEF".indexOf(c);
}
public static byte[] GetRandomBin(Integer len) {
byte[] b = new byte[len];
Random random = new Random();
random.nextBytes(b);
return b;
}
/**
* 返回b字节集在a字节集中最先出现的位置,查询位置值从 0 开始。如果未找到,返回 -1
* @param a
* @param b
* @param c
* 起始位置
* @return
* 0开始的起始位置
*/
public static Integer getByteIndexOf(byte[] a,byte[] b,Integer c){
String aa=HexUtil.bytesToHex(a);
String bb=HexUtil.bytesToHex(b);
aa=aa.substring(c*2, aa.length());
return aa.indexOf(bb)==-1?-1:aa.indexOf(bb, c)/2;
}
/**
* 返回一个字节集,其中包含指定字节集中从右边算起指定数量的字节。
* @param a
* 字节集
* @param b
* 指定数量
* @return
*/
public static byte[] getByteRight(byte[] a,Integer b){
String aa=HexUtil.bytesToHex(a);
aa=aa.substring(aa.length()-b*2, aa.length());
return HexUtil.hexToByteArray(aa);
}
public static void main(String[] args){
//byte[] a=new byte[]{1,-100,3,-100,101,6};
//byte[] b=new byte[]{-100,101,6};
//System.out.println(getByteIndexOf(a, b, 0));
byte[] a=new byte[]{1,-100,3,-100,101,6};
System.out.println(Arrays.toString(a));
}
}
package com.koow.kkwwo.hex.util;
import com.koow.kkwwo.c.Pack;
public class HexUtil {
/**
* 字节转十六进制
*
* @param b
* 需要进行转换的byte字节
* @return 转换后的Hex字符串
*/
public static String byteToHex(byte b) {
String hex = Integer.toHexString(b & 0xFF);
if (hex.length() < 2) {
hex = "0" + hex;
}
return hex;
}
/**
* 字节数组转16进制
*
* @param bytes
* 需要转换的byte数组
* @return 转换后的Hex字符串
*/
public static String bytesToHex(byte[] bytes) {
StringBuffer sb = new StringBuffer();
for (int i = 0; i < bytes.length; i++) {
String hex = Integer.toHexString(bytes[i] & 0xFF);
if (hex.length() < 2) {
sb.append(0);
}
sb.append(hex);
}
return sb.toString();
}
/**
* 字节数组转16进制(带空格大写)
*
* @param bytes
* 需要转换的byte数组
* @return 转换后的Hex字符串
*/
public static String bytesToHex2(byte[] bytes) {
StringBuffer sb = new StringBuffer();
for (int i = 0; i < bytes.length; i++) {
String hex = Integer.toHexString(bytes[i] & 0xFF);
if (hex.length() < 2) {
sb.append(0);
}
sb.append(hex.toUpperCase()+" ");
}
return sb.toString().trim();
}
/**
* Hex字符串(16进制)转byte
*
* @param inHex
* 待转换的Hex字符串
* @return 转换后的byte
*/
public static byte hexToByte(String inHex) {
return (byte) Integer.parseInt(inHex, 16);
}
/**
* hex字符串(16进制)转byte数组
*
* @param inHex
* 待转换的Hex字符串
* @return 转换后的byte数组结果
*/
public static byte[] hexToByteArray(String inHex) {
inHex=Pack.c_Null(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;
}
}
package com.koow.kkwwo.c;
import java.util.Arrays;
import com.koow.kkwwo.bytes.util.ToButeArray;
import com.koow.kkwwo.hex.util.HexUtil;
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
// QQ安卓协议登陆
Login l=new Login();
l.Fun_Login("763614984", "");
byte[] ss=ToButeArray.longToButeArray(-2047848776);
System.out.println("转换为byte[]:"+Arrays.toString(ss));
byte[] sa=ToButeArray.subByteArray(ss, ss.length/2, ss.length/2);
System.out.println("byte[]截取后:"+Arrays.toString(sa));
System.out.println("byte[]转换16位字符串再转换为BigInteger:"+ToButeArray.String16ToBigInteger(HexUtil.bytesToHex(sa)));
System.out.println("易语言__________________到无符号长整型:2247118520");
}
}
以下为控制台输出
原byte[]:[-1, -1, -1, -1, -123, -16, 78, -72]
byte[]截取后:[-123, -16, 78, -72]
byte[]转换16位字符串再转换为BigInteger:2247118520
易语言__________________到无符号长整型:2247118520