bytesutils.java

这是本人曾经在公司里用的,内部开发框架,基于struts+hibernate今天分享给大家

package cn.bway.common;

/********************************************************************
 * 新加--字节顺序说明:
 * 高位(数值高位)在前(数组低位)，低位在后. 如int 4的二进制形式是00000000 00000000 00000000 00000100
 * 则byte[0]是第一组的00000000, byte[1]是第二组的00000000,
 * byte[2]是第三组的00000000, byte[3]是第四组的00000100
 ********************************************************************/

public final class BytesUtils {

	/**
	 * copy固定字节数目的函数。固定字节数目的意思是对dest来说必须填充固定数目，而不管src有多长。
	 * 若src不够长，则以0填充
	 * @param src byte[] 允许null
	 * @param dest byte[] 不允许null
	 * @param srcOff int
	 * @param destOff int
	 * @param fixLen int
	 */
	public static void copyFixedBytes(byte[] src, byte[] dest, int srcOff,
			int destOff, int fixedLen) {
		if (src == null) {
			for (int i = 0; i < fixedLen; i++) {
				dest[destOff + i] = 0;
			}
			return;
		}

		if (src.length - srcOff < fixedLen) {
			BytesCopy(src, dest, srcOff, src.length - srcOff, destOff);
			for (int i = 0; i < fixedLen - src.length + srcOff; i++) {
				dest[destOff + src.length - srcOff + i] = 0;
			}
		} else {
			BytesCopy(src, dest, srcOff, fixedLen, destOff);
		}
	}

	/**
	 * copy固定字节数目的函数。固定字节数目的意思是对dest来说必须填充固定数目，
	 * 而不管src有多长。若src不够长，则以0填充
	 * String src以charsetName编码成byte[]，若编码失败，则以系统默认字符集编码
	 * @param src String 允许null
	 * @param charsetName String
	 * @param dest byte[] 不允许null
	 * @param destOff int
	 * @param fixedLen int
	 */
	public static void copyString2FixedBytes(String src, String charsetName,
			byte[] dest, int destOff, int fixedLen) {
		if (src == null) {
			copyFixedBytes(null, dest, 0, destOff, fixedLen);
			return;
		}

		byte[] srcBytes = null;
		if (charsetName == null) { //系统默认
			srcBytes = src.getBytes();
		} else {
			try {
				srcBytes = src.getBytes(charsetName);
			} catch (Exception e) {
				srcBytes = src.getBytes();
			}
		}
		copyFixedBytes(srcBytes, dest, 0, destOff, fixedLen);
	}

	public static int ByteToInt(byte mybyte) {
		return (0xff & mybyte);
	}

	public static byte IntToByte(int i) {
		return (byte) i;
	}

	public static void clearBytes(byte[] mybytes) {
		for (int i = 0; i < mybytes.length; i++) {
			mybytes[i] = 0;
		}
	}

	/**
	 * Adapted by Zhang zhongguang
	 * bug: 符号位.
	 * solution: 先移位,后取与
	 * @param mybytes byte[]
	 * @return int
	 */
	public static int BytesToInt(byte[] mybytes) {
		int tmp = ((0xff000000 & (mybytes[0] << 24))
				| (0xff0000 & (mybytes[1] << 16))
				| (0xff00 & (mybytes[2] << 8)) | (0xff & mybytes[3]));

		return tmp;
	}

	/**
	 * 新加, 为满足少于4字节的byte数组转换到int的需要, 字节顺序同样是高位在前.
	 * @param mybytes
	 * @param off
	 * @param len
	 * @return
	 */
	public static int BytesToInt(byte[] mybytes, int off, int len) {
		byte byte3 = 0;
		byte byte2 = 0;
		byte byte1 = 0;
		byte byte0 = 0;

		if (len > 0) {
			byte3 = mybytes[off + len - 1]; //从后面开始取低位
		}
		if (len > 1) {
			byte2 = mybytes[off + len - 2];
		}
		if (len > 2) {
			byte1 = mybytes[off + len - 3];
		}
		if (len > 3) {
			byte0 = mybytes[off + len - 4];

		}
		return ((0xff000000 & (byte0 << 24)) | (0xff0000 & (byte1 << 16))
				| (0xff00 & (byte2 << 8)) | (0xff & byte3));
	}

	public static byte[] IntToBytes(int i) {
		byte[] mybytes = new byte[2];
		mybytes[1] = (byte) (0xff & i);
		mybytes[0] = (byte) ((0xff00 & i) >> 8);

		return mybytes;
	}

	public static byte[] IntToBytes4(int i) {
		byte[] mybytes = new byte[4];
		mybytes[3] = (byte) (0xff & i);
		mybytes[2] = (byte) ((0xff00 & i) >> 8);
		mybytes[1] = (byte) ((0xff0000 & i) >> 16);
		mybytes[0] = (byte) ((0xff000000 & i) >> 24);

		return mybytes;
	}

	public static byte[] LongToBytes8(long i) {
		byte[] mybytes = new byte[8];

		mybytes[7] = (byte) (0xff & i);
		mybytes[6] = (byte) ((0xff00 & i) >> 8);
		mybytes[5] = (byte) ((0xff0000 & i) >> 16);
		mybytes[4] = (byte) ((0xff000000 & i) >> 24);

		int high = (int) (i >> 32);
		mybytes[3] = (byte) (0xff & high);
		mybytes[2] = (byte) ((0xff00 & high) >> 8);
		mybytes[1] = (byte) ((0xff0000 & high) >> 16);
		mybytes[0] = (byte) ((0xff000000 & high) >> 24);

		return mybytes;
	}

	public static void IntToBytes(int i, byte[] mybytes) {
		mybytes[1] = (byte) (0xff & i);
		mybytes[0] = (byte) ((0xff00 & i) >> 8);
	}

	public static void IntToBytes4(int i, byte[] mybytes) {
		mybytes[3] = (byte) (0xff & i);
		mybytes[2] = (byte) ((0xff00 & i) >> 8);
		mybytes[1] = (byte) ((0xff0000 & i) >> 16);
		mybytes[0] = (byte) (int) ((0xff000000 & i) >> 24);
	}

	/**
	 * Adapted by Zhang zhongguang
	 * bug: 符号位.
	 * solution: 先移位,后取与
	 * @param mybytes byte[]
	 * @return int
	 */
	public static int Bytes4ToInt(byte[] mybytes) {
		int tmp = ((0xff000000 & (mybytes[0] << 24))
				| (0xff0000 & (mybytes[1] << 16))
				| (0xff00 & (mybytes[2] << 8)) | (0xff & mybytes[3]));

		return tmp;
	}

	/**
	 * Adapted by Zhang zhongguang
	 * bug: 符号位.
	 * solution: 先移位,后取与
	 * @param mybytes byte[]
	 * @return long
	 */
	public static long Bytes8ToLong(byte[] mybytes) {
		long tmp = ((0xff00000000000000L & (mybytes[0] << 56))
				| (0xff000000000000L & (mybytes[1] << 48))
				| (0xff0000000000L & (mybytes[2] << 40))
				| (0xff00000000L & (mybytes[3] << 32))
				| (0xff000000 & (mybytes[4] << 24))
				| (0xff0000 & (mybytes[5] << 16))
				| (0xff00 & (mybytes[6] << 8)) | (0xff & mybytes[7]));

		return tmp;
	}

	/**
	 * 修改
	 * @param source
	 * @param dest
	 * @param sourceOff
	 * @param len
	 * @param destOff
	 */
	public static void BytesCopy(byte[] source, byte[] dest, int sourceOff,
			int len, int destOff) {
		int i = 0;

		while (i < len) {
			dest[i + destOff] = source[i + sourceOff];
			i++;
		}
	}

	public static void printBytes(byte[] bytes, int len) {
		int i;
		int j = 0;

		for (i = 0; i < len; i++) {
			if ((i % 4) == 0) {
				System.out.println('\n');
				j++;
				System.out.print("Line Number " + j + "  :");
			}

			System.out.print(' ');
			System.out.print(' ');
			System.out.print('[');
			System.out.print(Long.toString((long) bytes[i] & 0xff, 16));
			System.out.print('|');
			System.out.print((char) bytes[i]);
			System.out.print(']');
		}

		System.out
				.print("\n------------------------------------------");
	}

	public static void printBytes2(byte[] bytes, int len) {
		int i;

		for (i = 0; i < len; i++) {
			System.out.print(Long.toString((long) bytes[i] & 0xff, 16));
			System.out.print(" ");
			//System.out.print((char) bytes[i]);
		}
		System.out.print("\n");
	}

	/**
	 * 检测末尾是否半个汉字
	 * @param bytes
	 * @param start
	 * @param end
	 * @return 没有:true ,有:false
	 */
	public static boolean notHalfChar(byte[] bytes, int start, int end) {
		int len = bytes.length - 1;
		//如果已经是整个字串末位，或end位置非汉字编码
		if ((len <= end) || ((bytes[end] & 0x80) == 0)) {
			return true;
		}
		for (; start <= end;) {
			if ((bytes[start] & 0x80) != 0) {
				start += 2;
			} else {
				start++;
			}
		}
		if ((start - end) == 2) {
			return false;
		}
		return true;
	}

}