package com.zy.common.HslCommunication.BasicFramework;
|
|
|
import java.io.ByteArrayOutputStream;
|
import java.io.IOException;
|
import java.io.UnsupportedEncodingException;
|
import java.lang.reflect.Array;
|
import java.util.Arrays;
|
import java.util.List;
|
import java.util.Random;
|
import java.util.UUID;
|
|
|
public class SoftBasic {
|
|
|
/**
|
* 根据大小获取文本描述信息
|
* @param size 数据大小
|
* @return 字符串文本
|
*/
|
public static String GetSizeDescription(long size) {
|
if (size < 1000) {
|
return size + " B";
|
} else if (size < 1000 * 1000) {
|
float data = (float) size / 1024;
|
return String.format("%.2f", data) + " Kb";
|
} else if (size < 1000 * 1000 * 1000) {
|
float data = (float) size / 1024 / 1024;
|
return String.format("%.2f", data) + " Mb";
|
} else {
|
float data = (float) size / 1024 / 1024 / 1024;
|
return String.format("%.2f", data) + " Gb";
|
}
|
}
|
|
|
/**
|
* 判断两个字节数组是否是一致的，可以指定中间的某个区域
|
* @param b1 第一个字节数组
|
* @param start1 起始字节
|
* @param b2 第二个字节数组
|
* @param start2 起始字节
|
* @param length 对比数据的长度
|
* @return 是否一致
|
*/
|
public static boolean IsTwoBytesEquel(byte[] b1, int start1, byte[] b2, int start2, int length)
|
{
|
if (b1 == null || b2 == null) return false;
|
for (int i = 0; i < length; i++)
|
{
|
if (b1[i + start1] != b2[i + start2])
|
{
|
return false;
|
}
|
}
|
|
return true;
|
}
|
|
|
/**
|
* 将byte数组的长度扩充到指定长度
|
* @param data 原先的数据长度
|
* @param length 扩充或是缩短后的长度
|
* @return 新的扩充后的数据对象
|
*/
|
public static byte[] ArrayExpandToLength(byte[] data,int length){
|
if (data == null) return new byte[0];
|
byte[] buffer = new byte[length];
|
System.arraycopy( data,0, buffer,0, Math.min( data.length, buffer.length ) );
|
return buffer;
|
}
|
|
/**
|
* 将byte数组的长度扩充到偶数长度
|
* @param data 原先的数据长度
|
* @return 新的扩充后的数据对象
|
*/
|
public static byte[] ArrayExpandToLengthEven( byte[] data )
|
{
|
if (data == null) data = new byte[0];
|
if (data.length % 2 == 1)
|
{
|
return ArrayExpandToLength(data, data.length + 1 );
|
}
|
else
|
{
|
return data;
|
}
|
}
|
|
|
|
/**
|
* 将一个数组进行扩充到偶数长度
|
* @param data 原先数据的数据
|
* @param <T> 数组的类型
|
* @return 新数组长度信息
|
*/
|
public static <T> T[] ArrayExpandToLengthEven(Class<T> tClass, T[] data )
|
{
|
if (data == null) data = (T[]) new Object[0];
|
|
if (data.length % 2 == 1)
|
{
|
return ArrayExpandToLength(tClass, data, data.length + 1 );
|
}
|
else
|
{
|
return data;
|
}
|
}
|
|
/**
|
* 将一个数组进行扩充到指定长度，或是缩短到指定长度
|
* @param data 原先数据的数据
|
* @param length 新数组的长度
|
* @param <T> 数组的类型
|
* @return 新数组长度信息
|
*/
|
public static <T> T[] ArrayExpandToLength(Class<T> tClass, T[] data, int length )
|
{
|
if (data == null) return (T[]) Array.newInstance(tClass,0);
|
|
if (data.length == length) return data;
|
|
T[] buffer = (T[]) Array.newInstance(tClass,length);
|
|
System.arraycopy( data,0, buffer,0, Math.min( data.length, buffer.length ) );
|
|
return buffer;
|
}
|
|
|
|
/**
|
* 获取一串唯一的随机字符串，长度为20，由Guid码和4位数的随机数组成，保证字符串的唯一性
|
* @return 随机字符串数据
|
*/
|
public static String GetUniqueStringByGuidAndRandom()
|
{
|
Random random = new Random();
|
return UUID.randomUUID().toString() + (random.nextInt(9000)+1000);
|
}
|
|
|
|
|
/**
|
* 字节数据转化成16进制表示的字符串
|
* @param InBytes 字节数组
|
* @return 返回的字符串
|
*/
|
public static String ByteToHexString(byte[] InBytes)
|
{
|
return ByteToHexString(InBytes, (char)0);
|
}
|
|
|
/**
|
* 字节数据转化成16进制表示的字符串
|
* @param InBytes 字节数组
|
* @param segment 分割符
|
* @return 返回的字符串
|
*/
|
public static String ByteToHexString(byte[] InBytes, char segment)
|
{
|
|
StringBuilder stringBuilder = new StringBuilder("");
|
if (InBytes == null || InBytes.length <= 0) {
|
return null;
|
}
|
for (int i = 0; i < InBytes.length; i++) {
|
int v = InBytes[i] & 0xFF;
|
String hv = Integer.toHexString(v);
|
if (hv.length() < 2) {
|
stringBuilder.append(0);
|
}
|
stringBuilder.append(hv);
|
stringBuilder.append(segment);
|
}
|
return stringBuilder.toString();
|
}
|
|
|
/**
|
*将bool数组转换到byte数组
|
* @param array bool数组
|
* @return 字节数组
|
*/
|
public static byte[] BoolArrayToByte(boolean[] array)
|
{
|
if (array == null) return null;
|
|
int length = array.length % 8 == 0 ? array.length / 8 : array.length / 8 + 1;
|
byte[] buffer = new byte[length];
|
|
for (int i = 0; i < array.length; i++)
|
{
|
int index = i / 8;
|
int offect = i % 8;
|
|
byte temp = 0;
|
switch (offect)
|
{
|
case 0: temp = 0x01; break;
|
case 1: temp = 0x02; break;
|
case 2: temp = 0x04; break;
|
case 3: temp = 0x08; break;
|
case 4: temp = 0x10; break;
|
case 5: temp = 0x20; break;
|
case 6: temp = 0x40; break;
|
case 7: temp = (byte) 0x80; break;
|
default: break;
|
}
|
|
if (array[i]) buffer[index] += temp;
|
}
|
|
return buffer;
|
|
}
|
|
|
/**
|
* 从Byte数组中提取位数组
|
* @param InBytes 原先的字节数组
|
* @param length 想要转换的长度，如果超出自动会缩小到数组最大长度
|
* @return 结果对象
|
*/
|
public static boolean[] ByteToBoolArray(byte[] InBytes, int length)
|
{
|
if (InBytes == null) return null;
|
|
if (length > InBytes.length * 8) length = InBytes.length * 8;
|
boolean[] buffer = new boolean[length];
|
|
for (int i = 0; i < length; i++)
|
{
|
int index = i / 8;
|
int offect = i % 8;
|
|
byte temp = 0;
|
switch (offect)
|
{
|
case 0: temp = 0x01; break;
|
case 1: temp = 0x02; break;
|
case 2: temp = 0x04; break;
|
case 3: temp = 0x08; break;
|
case 4: temp = 0x10; break;
|
case 5: temp = 0x20; break;
|
case 6: temp = 0x40; break;
|
case 7: temp = (byte) 0x80; break;
|
default: break;
|
}
|
|
if ((InBytes[index] & temp) == temp)
|
{
|
buffer[i] = true;
|
}
|
}
|
|
return buffer;
|
}
|
|
|
/**
|
* 字符串数据转化成16进制表示的字符串
|
* @param InString 输入的字符串数据
|
* @return 返回的字符串
|
* @throws UnsupportedEncodingException
|
*/
|
public static String ByteToHexString(String InString) throws UnsupportedEncodingException
|
{
|
return ByteToHexString(InString.getBytes("unicode"));
|
}
|
|
|
/**
|
* 实际的字符串列表
|
*/
|
private static List<Character> hexCharList = Arrays.asList('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F');
|
|
|
|
/**
|
* 将16进制的字符串转化成Byte数据，将检测每2个字符转化，也就是说，中间可以是任意字符
|
* @param hex 16进制表示的字符串数据
|
* @return 字节数组
|
*/
|
public static byte[] HexStringToBytes(String hex)
|
{
|
hex = hex.toUpperCase();
|
|
ByteArrayOutputStream ms = new ByteArrayOutputStream ();
|
|
for (int i = 0; i < hex.length(); i++)
|
{
|
if ((i + 1) < hex.length())
|
{
|
if (hexCharList.contains(hex.charAt(i)) && hexCharList.contains(hex.charAt(i+1)))
|
{
|
// 这是一个合格的字节数据
|
ms.write((byte)(hexCharList.indexOf(hex.charAt(i)) * 16 +hexCharList.indexOf(hex.charAt(i+1))));
|
i++;
|
}
|
}
|
}
|
|
byte[] result = ms.toByteArray();
|
try {
|
ms.close();
|
}
|
catch (IOException ex)
|
{
|
|
}
|
return result;
|
}
|
|
|
/**
|
* 拼接2个字节数组的数据
|
* @param bytes1 数组一
|
* @param bytes2 数组二
|
* @return 拼接后的数组
|
*/
|
public static byte[] SpliceTwoByteArray( byte[] bytes1, byte[] bytes2 )
|
{
|
if (bytes1 == null && bytes2 == null) return null;
|
if (bytes1 == null) return bytes2;
|
if (bytes2 == null) return bytes1;
|
|
byte[] buffer = new byte[bytes1.length + bytes2.length];
|
System.arraycopy(bytes1,0,buffer,0,bytes1.length);
|
System.arraycopy(bytes2,0,buffer,bytes1.length,bytes2.length);
|
return buffer;
|
}
|
|
/**
|
* 将一个byte数组的前面指定位数移除，返回新的一个数组
|
* @param value 字节数组
|
* @param length 等待移除的长度
|
* @return 新的数据
|
*/
|
public static byte[] BytesArrayRemoveBegin( byte[] value, int length )
|
{
|
return BytesArrayRemoveDouble( value, length, 0 );
|
}
|
|
|
/**
|
* 将一个byte数组的后面指定位数移除，返回新的一个数组
|
* @param value 字节数组
|
* @param length 等待移除的长度
|
* @return 新的数据
|
*/
|
public static byte[] BytesArrayRemoveLast( byte[] value, int length )
|
{
|
return BytesArrayRemoveDouble( value, 0, length );
|
}
|
|
/**
|
* 将一个byte数组的前后移除指定位数，返回新的一个数组
|
* @param value 字节数组
|
* @param leftLength 前面的位数
|
* @param rightLength 后面的位数
|
* @return 新的数据
|
*/
|
public static byte[] BytesArrayRemoveDouble( byte[] value, int leftLength, int rightLength )
|
{
|
if (value == null) return null;
|
if (value.length <= (leftLength + rightLength)) return new byte[0];
|
|
byte[] buffer = new byte[value.length - leftLength - rightLength];
|
System.arraycopy( value, leftLength, buffer, 0, buffer.length );
|
|
return buffer;
|
}
|
|
}
|
