精华内容
下载资源
问答
  • import java.nio.charset.Charset; import org.apache.commons.lang3.ArrayUtils;... * @Description: 字节数组转换工具类 * @author fun * @date 2019年3月27日 */ public class BytesUtil...
    package com.fun.utils;
    
    import java.nio.charset.Charset;
    
    import org.apache.commons.lang3.ArrayUtils;
    
    /**
     * 
     * @Description: 字节数组转换工具类
     * @author fun
     * @date 2019年3月27日
     */
    public class BytesUtils {
    
    	public static final String GBK = "GBK";
    	public static final String UTF8 = "utf-8";
    	public static final char[] ascii = "0123456789ABCDEF".toCharArray();
    	private static char[] HEX_VOCABLE = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
    
    	/**
    	 * 将short整型数值转换为字节数组
    	 * 
    	 * @param data
    	 * @return
    	 */
    	public static byte[] getBytes(short data) {
    		byte[] bytes = new byte[2];
    		bytes[0] = (byte) ((data & 0xff00) >> 8);
    		bytes[1] = (byte) (data & 0xff);
    		return bytes;
    	}
    
    	/**
    	 * 将字符转换为字节数组
    	 * 
    	 * @param data
    	 * @return
    	 */
    	public static byte[] getBytes(char data) {
    		byte[] bytes = new byte[2];
    		bytes[0] = (byte) (data >> 8);
    		bytes[1] = (byte) (data);
    		return bytes;
    	}
    
    	/**
    	 * 将布尔值转换为字节数组
    	 * 
    	 * @param data
    	 * @return
    	 */
    	public static byte[] getBytes(boolean data) {
    		byte[] bytes = new byte[1];
    		bytes[0] = (byte) (data ? 1 : 0);
    		return bytes;
    	}
    
    	/**
    	 * 将整型数值转换为字节数组
    	 * 
    	 * @param data
    	 * @return
    	 */
    	public static byte[] getBytes(int data) {
    		byte[] bytes = new byte[4];
    		bytes[0] = (byte) ((data & 0xff000000) >> 24);
    		bytes[1] = (byte) ((data & 0xff0000) >> 16);
    		bytes[2] = (byte) ((data & 0xff00) >> 8);
    		bytes[3] = (byte) (data & 0xff);
    		return bytes;
    	}
    
    	/**
    	 * 将long整型数值转换为字节数组
    	 * 
    	 * @param data
    	 * @return
    	 */
    	public static byte[] getBytes(long data) {
    		byte[] bytes = new byte[8];
    		bytes[0] = (byte) ((data >> 56) & 0xff);
    		bytes[1] = (byte) ((data >> 48) & 0xff);
    		bytes[2] = (byte) ((data >> 40) & 0xff);
    		bytes[3] = (byte) ((data >> 32) & 0xff);
    		bytes[4] = (byte) ((data >> 24) & 0xff);
    		bytes[5] = (byte) ((data >> 16) & 0xff);
    		bytes[6] = (byte) ((data >> 8) & 0xff);
    		bytes[7] = (byte) (data & 0xff);
    		return bytes;
    	}
    
    	/**
    	 * 将float型数值转换为字节数组
    	 * 
    	 * @param data
    	 * @return
    	 */
    	public static byte[] getBytes(float data) {
    		int intBits = Float.floatToIntBits(data);
    		return getBytes(intBits);
    	}
    
    	/**
    	 * 
    	 * @Title: getBytes 
    	 * @Description: 将double型数值转换为字节数组 
    	 * @return byte[] 
    	 * @author fun
    	 * @date 2019年3月27日
    	 */
    
    	public static byte[] getBytes(double data) {
    		long intBits = Double.doubleToLongBits(data);
    		return getBytes(intBits);
    	}
    
    	/**
    	 * 
    	 * @Title: getBytes 
    	 * @Description: 将字符串按照charsetName编码格式的字节数组 
    	 * @return byte[] 
    	 * @param data 字符串
    	 * @param charsetName
    	 * @author fun
    	 * @date 2019年3月27日
    	 */
    	public static byte[] getBytes(String data, String charsetName) {
    		Charset charset = Charset.forName(charsetName);
    		return data.getBytes(charset);
    	}
    
    	/**
    	 * 
    	 * @Title: getBytes 
    	 * @Description: 将字符串按照GBK编码格式的字节数组 
    	 * @return byte[] 
    	 * @author fun
    	 * @date 2019年3月27日
    	 */
    	public static byte[] getBytes(String data) {
    		return getBytes(data, GBK);
    	}
    
    	/**
    	 * 
    	 * @Title: getBoolean 
    	 * @Description: 将字节数组第0字节转换为布尔值 
    	 * @return boolean 
    	 * @author fun
    	 * @date 2019年3月27日
    	 */
    	public static boolean getBoolean(byte[] bytes) {
    		return bytes[0] == 1;
    	}
    
    	/**
    	 * 
    	 * @Title: getBoolean 
    	 * @Description: 将字节数组的第index字节转换为布尔值 
    	 * @return boolean 
    	 * @author fun
    	 * @date 2019年3月27日
    	 */
    	public static boolean getBoolean(byte[] bytes, int index) {
    		return bytes[index] == 1;
    	}
    
    	/**
    	 * 
    	 * @Title: getShort 
    	 * @Description: 将字节数组前2字节转换为short整型数值 
    	 * @return short 
    	 * @author fun
    	 * @date 2019年3月27日
    	 */
    	public static short getShort(byte[] bytes) {
    		return (short) ((0xff00 & (bytes[0] << 8)) | (0xff & bytes[1]));
    	}
    
    	/**
    	 * 
    	 * @Title: getShort 
    	 * @Description: 将字节数组从startIndex开始的2个字节转换为short整型数值 
    	 * @return short 
    	 * @author fun
    	 * @date 2019年3月27日
    	 */
    	public static short getShort(byte[] bytes, int startIndex) {
    		return (short) ((0xff00 & (bytes[startIndex] << 8)) | (0xff & bytes[startIndex + 1]));
    	}
    
    	/**
    	 * 
    	 * @Title: getChar 
    	 * @Description: 将字节数组前2字节转换为字符 
    	 * @return char 
    	 * @author fun
    	 * @date 2019年3月27日
    	 */
    	public static char getChar(byte[] bytes) {
    		return (char) ((0xff00 & (bytes[0] << 8)) | (0xff & bytes[1]));
    	}
    
    	/**
    	 * 
    	 * @Title: getChar 
    	 * @Description: 将字节数组从startIndex开始的2个字节转换为字符 
    	 * @return char 
    	 * @author fun
    	 * @date 2019年3月27日
    	 */
    	public static char getChar(byte[] bytes, int startIndex) {
    		return (char) ((0xff00 & (bytes[startIndex] << 8)) | (0xff & bytes[startIndex + 1]));
    	}
    
    	/**
    	 * 
    	 * @Title: getInt 
    	 * @Description: 将字节数组前4字节转换为整型数值 
    	 * @return int 
    	 * @author fun
    	 * @date 2019年3月27日
    	 */
    	public static int getInt(byte[] bytes) {
    		return (0xff000000 & (bytes[0] << 24) | (0xff0000 & (bytes[1] << 16)) | (0xff00 & (bytes[2] << 8))
    				| (0xff & bytes[3]));
    	}
    
    	/**
    	 * 
    	 * @Title: getInt 
    	 * @Description: 将字节数组从startIndex开始的4个字节转换为整型数值 
    	 * @return int 
    	 * @author fun
    	 * @date 2019年3月27日
    	 */
    	public static int getInt(byte[] bytes, int startIndex) {
    		return (0xff000000 & (bytes[startIndex] << 24) | (0xff0000 & (bytes[startIndex + 1] << 16))
    				| (0xff00 & (bytes[startIndex + 2] << 8)) | (0xff & bytes[startIndex + 3]));
    	}
    
    	/**
    	 * 将字节数组前8字节转换为long整型数值
    	 * 
    	 * @param bytes
    	 * @return
    	 */
    	public static long getLong(byte[] bytes) {
    		return (0xff00000000000000L & ((long) bytes[0] << 56) | (0xff000000000000L & ((long) bytes[1] << 48))
    				| (0xff0000000000L & ((long) bytes[2] << 40)) | (0xff00000000L & ((long) bytes[3] << 32))
    				| (0xff000000L & ((long) bytes[4] << 24)) | (0xff0000L & ((long) bytes[5] << 16))
    				| (0xff00L & ((long) bytes[6] << 8)) | (0xffL & (long) bytes[7]));
    	}
    
    	/**
    	 * 将字节数组从startIndex开始的8个字节转换为long整型数值
    	 * 
    	 * @param bytes
    	 * @param startIndex
    	 * @return
    	 */
    	public static long getLong(byte[] bytes, int startIndex) {
    		return (0xff00000000000000L & ((long) bytes[startIndex] << 56)
    				| (0xff000000000000L & ((long) bytes[startIndex + 1] << 48))
    				| (0xff0000000000L & ((long) bytes[startIndex + 2] << 40))
    				| (0xff00000000L & ((long) bytes[startIndex + 3] << 32))
    				| (0xff000000L & ((long) bytes[startIndex + 4] << 24))
    				| (0xff0000L & ((long) bytes[startIndex + 5] << 16)) | (0xff00L & ((long) bytes[startIndex + 6] << 8))
    				| (0xffL & (long) bytes[startIndex + 7]));
    	}
    
    	/**
    	 * 将字节数组前4字节转换为float型数值
    	 * 
    	 * @param bytes
    	 * @return
    	 */
    	public static float getFloat(byte[] bytes) {
    		return Float.intBitsToFloat(getInt(bytes));
    	}
    
    	/**
    	 * 将字节数组从startIndex开始的4个字节转换为float型数值
    	 * 
    	 * @param bytes
    	 * @param startIndex
    	 * @return
    	 */
    	public static float getFloat(byte[] bytes, int startIndex) {
    		byte[] result = new byte[4];
    		System.arraycopy(bytes, startIndex, result, 0, 4);
    		return Float.intBitsToFloat(getInt(result));
    	}
    
    	/**
    	 * 将字节数组前8字节转换为double型数值
    	 * 
    	 * @param bytes
    	 * @return
    	 */
    	public static double getDouble(byte[] bytes) {
    		long l = getLong(bytes);
    		return Double.longBitsToDouble(l);
    	}
    
    	/**
    	 * 将字节数组从startIndex开始的8个字节转换为double型数值
    	 * 
    	 * @param bytes
    	 * @param startIndex
    	 * @return
    	 */
    	public static double getDouble(byte[] bytes, int startIndex) {
    		byte[] result = new byte[8];
    		System.arraycopy(bytes, startIndex, result, 0, 8);
    		long l = getLong(result);
    		return Double.longBitsToDouble(l);
    	}
    
    	/**
    	 * 将charsetName编码格式的字节数组转换为字符串
    	 * 
    	 * @param bytes
    	 * @param charsetName
    	 * @return
    	 */
    	public static String getString(byte[] bytes, String charsetName) {
    		return new String(bytes, Charset.forName(charsetName));
    	}
    
    	/**
    	 * 将GBK编码格式的字节数组转换为字符串
    	 * 
    	 * @param bytes
    	 * @return
    	 */
    	public static String getString(byte[] bytes) {
    		return getString(bytes, GBK);
    	}
    
    	/**
    	 * 将16进制字符串转换为字节数组
    	 * 
    	 * @param hex
    	 * @return
    	 */
    	public static byte[] hexStringToBytes(String hex) {
    		if (hex == null || "".equals(hex)) {
    			return null;
    		}
    		int len = hex.length() / 2;
    		byte[] result = new byte[len];
    		char[] chArr = hex.toCharArray();
    		for (int i = 0; i < len; i++) {
    			int pos = i * 2;
    			result[i] = (byte) (toByte(chArr[pos]) << 4 | toByte(chArr[pos + 1]));
    		}
    		return result;
    	}
    
    	/**
    	 * 将16进制字符串转换为字节数组
    	 * 
    	 * @param hex
    	 * @return
    	 */
    	public static byte[] hexToBytes(String hex) {
    		if (hex.length() % 2 != 0)
    			throw new IllegalArgumentException("input string should be any multiple of 2!");
    		hex.toUpperCase();
    
    		byte[] byteBuffer = new byte[hex.length() / 2];
    
    		byte padding = 0x00;
    		boolean paddingTurning = false;
    		for (int i = 0; i < hex.length(); i++) {
    			if (paddingTurning) {
    				char c = hex.charAt(i);
    				int index = indexOf(hex, c);
    				padding = (byte) ((padding << 4) | index);
    				byteBuffer[i / 2] = padding;
    				padding = 0x00;
    				paddingTurning = false;
    			} else {
    				char c = hex.charAt(i);
    				int index = indexOf(hex, c);
    				padding = (byte) (padding | index);
    				paddingTurning = true;
    			}
    
    		}
    		return byteBuffer;
    	}
    
    	private static int indexOf(String input, char c) {
    		int index = ArrayUtils.indexOf(HEX_VOCABLE, c);
    
    		if (index < 0) {
    			throw new IllegalArgumentException("err input:" + input);
    		}
    		return index;
    
    	}
    
    	/**
    	 * 将BCD编码的字节数组转换为字符串
    	 * 
    	 * @param bcds
    	 * @return
    	 */
    	public static String bcdToString(byte[] bcds) {
    		if (bcds == null || bcds.length == 0) {
    			return null;
    		}
    		byte[] temp = new byte[2 * bcds.length];
    		for (int i = 0; i < bcds.length; i++) {
    			temp[i * 2] = (byte) ((bcds[i] >> 4) & 0x0f);
    			temp[i * 2 + 1] = (byte) (bcds[i] & 0x0f);
    		}
    		StringBuffer res = new StringBuffer();
    		for (int i = 0; i < temp.length; i++) {
    			res.append(ascii[temp[i]]);
    		}
    		return res.toString();
    	}
    
    	/**
    	 * 字节转整形
    	 * 
    	 * @param value
    	 * @return
    	 */
    	public static int bcdToInt(byte value) {
    		return ((value >> 4) * 10) + (value & 0x0F);
    	}
    
    	/**
    	 * 字节数组转16进制字符串
    	 * 
    	 * @param bs
    	 * @return
    	 */
    	public static String bytesToHex(byte[] bs) {
    		StringBuilder sb = new StringBuilder();
    		for (byte b : bs) {
    			int high = (b >> 4) & 0x0f;
    			int low = b & 0x0f;
    			sb.append(HEX_VOCABLE[high]);
    			sb.append(HEX_VOCABLE[low]);
    		}
    		return sb.toString();
    	}
    
    	/**
    	 * 字节数组取前len个字节转16进制字符串
    	 * 
    	 * @param bs
    	 * @param len
    	 * @return
    	 */
    	public static String bytesToHex(byte[] bs, int len) {
    		StringBuilder sb = new StringBuilder();
    		for (int i = 0; i < len; i++) {
    			byte b = bs[i];
    			int high = (b >> 4) & 0x0f;
    			int low = b & 0x0f;
    			sb.append(HEX_VOCABLE[high]);
    			sb.append(HEX_VOCABLE[low]);
    		}
    		return sb.toString();
    	}
    
    	/**
    	 * 字节数组偏移offset长度之后的取len个字节转16进制字符串
    	 * 
    	 * @param bs
    	 * @param offset
    	 * @param len
    	 * @return
    	 */
    	public static String bytesToHex(byte[] bs, int offset, int len) {
    		StringBuilder sb = new StringBuilder();
    		for (int i = 0; i < len; i++) {
    			byte b = bs[offset + i];
    			int high = (b >> 4) & 0x0f;
    			int low = b & 0x0f;
    			sb.append(HEX_VOCABLE[high]);
    			sb.append(HEX_VOCABLE[low]);
    		}
    		return sb.toString();
    	}
    
    	/**
    	 * 字节转16进制字符串
    	 * 
    	 * @param bs
    	 * @return
    	 */
    	public static String byteToHex(byte b) {
    		StringBuilder sb = new StringBuilder();
    		int high = (b >> 4) & 0x0f;
    		int low = b & 0x0f;
    		sb.append(HEX_VOCABLE[high]);
    		sb.append(HEX_VOCABLE[low]);
    		String s = sb.toString();
    		if ("".equals(s.substring(0, 1))) {
    			return s.substring(1);
    		} else {
    			return s;
    		}
    	}
    
    	/**
    	 * 将字节数组取反
    	 * 
    	 * @param src
    	 * @return
    	 */
    	public static String negate(byte[] src) {
    		if (src == null || src.length == 0) {
    			return null;
    		}
    		byte[] temp = new byte[2 * src.length];
    		for (int i = 0; i < src.length; i++) {
    			byte tmp = (byte) (0xFF ^ src[i]);
    			temp[i * 2] = (byte) ((tmp >> 4) & 0x0f);
    			temp[i * 2 + 1] = (byte) (tmp & 0x0f);
    		}
    		StringBuffer res = new StringBuffer();
    		for (int i = 0; i < temp.length; i++) {
    			res.append(ascii[temp[i]]);
    		}
    		return res.toString();
    	}
    
    	/**
    	 * 比较字节数组是否相同
    	 * 
    	 * @param a
    	 * @param b
    	 * @return
    	 */
    	public static boolean compareBytes(byte[] a, byte[] b) {
    		if (a == null || a.length == 0 || b == null || b.length == 0 || a.length != b.length) {
    			return false;
    		}
    		if (a.length == b.length) {
    			for (int i = 0; i < a.length; i++) {
    				if (a[i] != b[i]) {
    					return false;
    				}
    			}
    		} else {
    			return false;
    		}
    		return true;
    	}
    
    	/**
    	 * 只比对指定长度byte
    	 * 
    	 * @param a
    	 * @param b
    	 * @param len
    	 * @return
    	 */
    	public static boolean compareBytes(byte[] a, byte[] b, int len) {
    		if (a == null || a.length == 0 || b == null || b.length == 0 || a.length < len || b.length < len) {
    			return false;
    		}
    		for (int i = 0; i < len; i++) {
    			if (a[i] != b[i]) {
    				return false;
    			}
    		}
    		return true;
    	}
    
    	/**
    	 * 将字节数组转换为二进制字符串
    	 * 
    	 * @param items
    	 * @return
    	 */
    	public static String bytesToBinaryString(byte[] items) {
    		if (items == null || items.length == 0) {
    			return null;
    		}
    		StringBuffer buf = new StringBuffer();
    		for (byte item : items) {
    			buf.append(byteToBinaryString(item));
    		}
    		return buf.toString();
    	}
    
    	/**
    	 * 将字节转换为二进制字符串
    	 * 
    	 * @param items
    	 * @return
    	 */
    	public static String byteToBinaryString(byte item) {
    		byte a = item;
    		StringBuffer buf = new StringBuffer();
    		for (int i = 0; i < 8; i++) {
    			buf.insert(0, a % 2);
    			a = (byte) (a >> 1);
    		}
    		return buf.toString();
    	}
    
    	/**
    	 * 对数组a,b进行异或运算
    	 * 
    	 * @param a
    	 * @param b
    	 * @return
    	 */
    	public static byte[] xor(byte[] a, byte[] b) {
    		if (a == null || a.length == 0 || b == null || b.length == 0 || a.length != b.length) {
    			return null;
    		}
    		byte[] result = new byte[a.length];
    		for (int i = 0; i < a.length; i++) {
    			result[i] = (byte) (a[i] ^ b[i]);
    		}
    		return result;
    	}
    
    	/**
    	 * 对数组a,b进行异或运算 运算长度len
    	 * 
    	 * @param a
    	 * @param b
    	 * @param len
    	 * @return
    	 */
    	public static byte[] xor(byte[] a, byte[] b, int len) {
    		if (a == null || a.length == 0 || b == null || b.length == 0) {
    			return null;
    		}
    		if (a.length < len || b.length < len) {
    			return null;
    		}
    		byte[] result = new byte[len];
    		for (int i = 0; i < len; i++) {
    			result[i] = (byte) (a[i] ^ b[i]);
    		}
    		return result;
    	}
    
    	/**
    	 * 将short整型数值转换为字节数组
    	 * 
    	 * @param num
    	 * @return
    	 */
    	public static byte[] shortToBytes(int num) {
    		byte[] temp = new byte[2];
    		for (int i = 0; i < 2; i++) {
    			temp[i] = (byte) ((num >>> (8 - i * 8)) & 0xFF);
    		}
    		return temp;
    	}
    
    	/**
    	 * 将字节数组转为整型
    	 * 
    	 * @param num
    	 * @return
    	 */
    	public static int bytesToShort(byte[] arr) {
    		int mask = 0xFF;
    		int temp = 0;
    		int result = 0;
    		for (int i = 0; i < 2; i++) {
    			result <<= 8;
    			temp = arr[i] & mask;
    			result |= temp;
    		}
    		return result;
    	}
    
    	/**
    	 * 将整型数值转换为指定长度的字节数组
    	 * 
    	 * @param num
    	 * @return
    	 */
    	public static byte[] intToBytes(int num) {
    		byte[] temp = new byte[4];
    		for (int i = 0; i < 4; i++) {
    			temp[i] = (byte) ((num >>> (24 - i * 8)) & 0xFF);
    		}
    		return temp;
    	}
    
    	/**
    	 * 将整型数值转换为指定长度的字节数组
    	 * 
    	 * @param src
    	 * @param len
    	 * @return
    	 */
    	public static byte[] intToBytes(int src, int len) {
    		if (len < 1 || len > 4) {
    			return null;
    		}
    		byte[] temp = new byte[len];
    		for (int i = 0; i < len; i++) {
    			temp[len - 1 - i] = (byte) ((src >>> (8 * i)) & 0xFF);
    		}
    		return temp;
    	}
    
    	/**
    	 * 将字节数组转换为整型数值
    	 * 
    	 * @param arr
    	 * @return
    	 */
    	public static int bytesToInt(byte[] arr) {
    		int mask = 0xFF;
    		int temp = 0;
    		int result = 0;
    		for (int i = 0; i < 4; i++) {
    			result <<= 8;
    			temp = arr[i] & mask;
    			result |= temp;
    		}
    		return result;
    	}
    
    	/**
    	 * 将long整型数值转换为字节数组
    	 * 
    	 * @param num
    	 * @return
    	 */
    	public static byte[] longToBytes(long num) {
    		byte[] temp = new byte[8];
    		for (int i = 0; i < 8; i++) {
    			temp[i] = (byte) ((num >>> (56 - i * 8)) & 0xFF);
    		}
    		return temp;
    	}
    
    	/**
    	 * 将字节数组转换为long整型数值
    	 * 
    	 * @param arr
    	 * @return
    	 */
    	public static long bytesToLong(byte[] arr) {
    		int mask = 0xFF;
    		int temp = 0;
    		long result = 0;
    		int len = Math.min(8, arr.length);
    		for (int i = 0; i < len; i++) {
    			result <<= 8;
    			temp = arr[i] & mask;
    			result |= temp;
    		}
    		return result;
    	}
    
    	/**
    	 * 将16进制字符转换为字节
    	 * 
    	 * @param c
    	 * @return
    	 */
    	public static byte toByte(char c) {
    		byte b = (byte) "0123456789ABCDEF".indexOf(c);
    		return b;
    	}
    
    	/**
    	 * 功能描述:把两个字节的字节数组转化为整型数据,高位补零,例如:<br/>
    	 * 有字节数组byte[] data = new byte[]{1,2};转换后int数据的字节分布如下:<br/>
    	 * 00000000 00000000 00000001 00000010,函数返回258
    	 * 
    	 * @param lenData
    	 *            需要进行转换的字节数组
    	 * @return 字节数组所表示整型值的大小
    	 */
    	public static int bytesToIntWhereByteLengthEquals2(byte lenData[]) {
    		if (lenData.length != 2) {
    			return -1;
    		}
    		byte fill[] = new byte[] { 0, 0 };
    		byte real[] = new byte[4];
    		System.arraycopy(fill, 0, real, 0, 2);
    		System.arraycopy(lenData, 0, real, 2, 2);
    		int len = byteToInt(real);
    		return len;
    
    	}
    
    	/**
    	 * 功能描述:将byte数组转化为int类型的数据
    	 * 
    	 * @param byteVal
    	 *            需要转化的字节数组
    	 * @return 字节数组所表示的整型数据
    	 */
    	public static int byteToInt(byte[] byteVal) {
    		int result = 0;
    		for (int i = 0; i < byteVal.length; i++) {
    			int tmpVal = (byteVal[i] << (8 * (3 - i)));
    			switch (i) {
    			case 0:
    				tmpVal = tmpVal & 0xFF000000;
    				break;
    			case 1:
    				tmpVal = tmpVal & 0x00FF0000;
    				break;
    			case 2:
    				tmpVal = tmpVal & 0x0000FF00;
    				break;
    			case 3:
    				tmpVal = tmpVal & 0x000000FF;
    				break;
    			}
    
    			result = result | tmpVal;
    		}
    		return result;
    	}
    
    	public static byte CheckXORSum(byte[] bData) {
    		byte sum = 0x00;
    		for (int i = 0; i < bData.length; i++) {
    			sum ^= bData[i];
    		}
    		return sum;
    	}
    
    	/**
    	 * 从offset开始 将后续长度为len的byte字节转为int
    	 * 
    	 * @param data
    	 * @param offset
    	 * @param len
    	 * @return
    	 */
    	public static int bytesToInt(byte[] data, int offset, int len) {
    		int mask = 0xFF;
    		int temp = 0;
    		int result = 0;
    		len = Math.min(len, 4);
    		for (int i = 0; i < len; i++) {
    			result <<= 8;
    			temp = data[offset + i] & mask;
    			result |= temp;
    		}
    		return result;
    	}
    
    	/**
    	 * byte字节数组中的字符串的长度
    	 * 
    	 * @param data
    	 * @return
    	 */
    	public static int getBytesStringLen(byte[] data) {
    		int count = 0;
    		for (byte b : data) {
    			if (b == 0x00)
    				break;
    			count++;
    		}
    		return count;
    	}
    
    	/**
    	 * 
    	 * @Title: hexString2binaryString
    	 * @Description: 十六进制字符串转二进制字符串
    	 * @return String
    	 * @author fun
    	 * @date 2019年3月27日
    	 */
    	public static String hexString2binaryString(String hexString) {
    		if (hexString == null || hexString.length() % 2 != 0)
    			return null;
    		String bString = "", tmp;
    		for (int i = 0; i < hexString.length(); i++) {
    			tmp = "0000" + Integer.toBinaryString(Integer.parseInt(hexString.substring(i, i + 1), 16));
    			bString += tmp.substring(tmp.length() - 4);
    		}
    		return bString;
    	}
    
    }
    
    展开全文
  • 主要介绍了C#中结构体和字节数组转换实现,本文直接给出了字节数组与结构体的转换代码,代码中包含详细注释,需要的朋友可以参考下
  • 在本教程中,我将向您展示两种将图像转换为字节数组并将字节数组转换为图像的不同方法。 首先,Java中的字节类型是一个8位带符号的二进制补码整数。其范围是[-128,127]。字节数组只是字节数组。图像本质上是一个...

    在本教程中,我将向您展示两种将图像转换为字节数组并将字节数组转换为图像的不同方法。

    首先,Java中的字节类型是一个8位带符号的二进制补码整数。其范围是[-128,127]。字节数组只是字节数组。图像本质上是一个文件。因此,任务是将文件转换为数组,以便可以在不同类型的应用程序中更轻松地存储或传输文件。
    1.方法1

    import java.awt.Graphics2D;
    import java.awt.Image;
    import java.awt.image.BufferedImage;
    import java.io.ByteArrayInputStream;
    import java.io.ByteArrayOutputStream;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
     
    import java.util.Iterator;
    import java.util.logging.Level;
    import java.util.logging.Logger;
    import javax.imageio.ImageIO;
    import javax.imageio.ImageReadParam;
    import javax.imageio.ImageReader;
    import javax.imageio.stream.ImageInputStream;
     
    public class ConvertImage {
     
        public static void main(String[] args) throws FileNotFoundException, IOException {
        	/ *
        	 * 1.如何将图像文件转换为字节数组?
        	 * /
     
            File file = new File("C:\\rose.jpg");
     
            FileInputStream fis = new FileInputStream(file);
            //创建从文件系统中的文件获取输入字节的
             // FileInputStream用于读取原始字节流,例如图像数据。要读取字符流,请考虑使用FileReader。
     
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            byte[] buf = new byte[1024];
            try {
                for (int readNum; (readNum = fis.read(buf)) != -1;) {
                    //写入该字节数组输出流 
                    bos.write(buf, 0, readNum); 
                    System.out.println("read " + readNum + " bytes,");
                }
            } catch (IOException ex) {
                Logger.getLogger(ConvertImage.class.getName()).log(Level.SEVERE, null, ex);
            }
     
            byte[] bytes = bos.toByteArray();
     
            / *
             * 2.如何将字节数组转换回图像文件?
             * /
     
            ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
            Iterator<?> readers = ImageIO.getImageReadersByFormatName("jpg");
     
            // ImageIO是一个类,包含用于定位ImageReaders 
            //和ImageWriters并执行简单编码和解码的静态方法。
     
            ImageReader reader = (ImageReader) readers.next();
            Object source = bis; 
            ImageInputStream iis = ImageIO.createImageInputStream(source); 
            reader.setInput(iis, true);
            ImageReadParam param = reader.getDefaultReadParam();
     
            Image image = reader.read(0, param);
            //得到一个图像文件
     
            BufferedImage bufferedImage = new BufferedImage(image.getWidth(null), image.getHeight(null), BufferedImage.TYPE_INT_RGB);
            // bufferedImage是要写入的RenderedImage
     
            Graphics2D g2 = bufferedImage.createGraphics();
            g2.drawImage(image, null, null);
     
            File imageFile = new File("C:\\newrose2.jpg");
            ImageIO.write(bufferedImage, "jpg", imageFile);
     
            System.out.println(imageFile.getPath());
        }
    }
    

    2.方法2

    以下是做相同事情的简单版本。它使用BufferedImage类,这是一种更为有效的方法。

    import java.awt.image.BufferedImage;
    import java.io.ByteArrayInputStream;
    import java.io.ByteArrayOutputStream;
    import java.io.File;
    import java.io.IOException;
    import javax.imageio.ImageIO;
    import com.sun.org.apache.xerces.internal.impl.dv.util.Base64;
     
     
    public class SimpleConvertImage {
    	public static void main(String[] args) throws IOException{
    		String dirName="C:\\";
    		ByteArrayOutputStream baos=new ByteArrayOutputStream(1000);
    		BufferedImage img=ImageIO.read(new File(dirName,"rose.jpg"));
    		ImageIO.write(img, "jpg", baos);
    		baos.flush();
     
    		String base64String=Base64.encode(baos.toByteArray());
    		baos.close();
     
    		byte[] bytearray = Base64.decode(base64String);
     
    		BufferedImage imag=ImageIO.read(new ByteArrayInputStream(bytearray));
    		ImageIO.write(imag, "jpg", new File(dirName,"snap.jpg"));
    	}
    }
    

    在这里插入图片描述

    展开全文
  • 主要介绍了C#将字节数组转换成数字的方法,涉及C#类型转换的技巧,非常具有实用价值,需要的朋友可以参考下
  • 在用C#进行软件开发的时候,需要用到字节数组和浮点数组转换功能。 其中字节数组是小端编码,为了便于以后提高,先整理记录如下: ... //第一种方法,字节数组转换类转换,最容易想到和处理 ...

                在用C#进行软件开发的时候,需要用到字节数组和浮点数组转换功能。

                其中字节数组是小端编码,为了便于以后提高,先整理记录如下:                

                byte[] data= ...;    //字节数组, 从外部获取
                float[] floatArr = new float[data.Length / 4];
                //第一种方法,字节数组转换类转换,最容易想到和处理
                for (int i = 0; i < floatArr.Length; i++)
                {
                    floatArr[i] = BitConverter.ToSingle(data, i * 4);
                }
                //第二种方法,缓存复制--最为简洁
                Buffer.BlockCopy(data, 0, floatArr, 0, data.Length);
                //第三种方法,字节转换处理方法,速度最快
                for (int i = 0; i < floatArr.Length; i++)
                {
                    floatArr[i] = data[i*4] | data[i *4+ 1] << 8 | data[i*4+2]<<16|data[i*4+3]<<24;
                }
                //第四种方法,不安全字节,首先,需要调整项目属性,勾选上允许不安全代码
                unsafe
                {
                    fixed (byte* pBuffer = data)
                    {
                        float* pSample = (float*)pBuffer;
                        // now we can access samples via pSample e.g.:
                        for (int i = 0; i < floatArr.Length; i++)
                        {
                            floatArr[i] = pSample[i];
                        }
                    }
                }

     

    展开全文
  • 加速数据转换 将 Android 上的字节数组转换回 Pebble 发送的 AccelData
  • java下字符串和字节数组转换    http://blog.sina.com.cn/s/blog_7e8c7d560101lwta.html 1、字节数组转换为字符串 byte[] byBuffer = new byte[20]; ... ... String strRead = new String...

    原文章地址:

    java下字符串和字节数组转换

         http://blog.sina.com.cn/s/blog_7e8c7d560101lwta.html

    1、字节数组转换为字符串

    byte[] byBuffer = new byte[20];
    ... ...
    String strRead = new String(byBuffer);
    strRead = String.copyValueOf(strRead.toCharArray(), 0, byBuffer.length]);

    2、字符串转换成字节数组

    byte[] byBuffer = new byte[200];
    String strInput="abcdefg";
    byBuffer= strInput.getBytes();

    注意:如果字符串里面含有中文,要特别注意,在android系统下,默认是UTF8编码,一个中文字符相当于3个字节,只有gb2312下一个中文相当于2字节。这种情况下可采取以下办法:

    byte[] byBuffer = new byte[200];
    String strInput="我是字符串";
    byBuffer= strInput.getBytes("gb2312");


    展开全文
  • ASCII字节数组转换成字符串

    千次阅读 2019-10-16 10:11:52
    在数据解析的过程中,就需要将字节数组转换成字符串。 byte[] data; String version; data的数据如下: 50 4D 55 2D 56 31 2E 30 2E 30 代码: version = new String(data,"ascii"); 转换后字符串version如下: ...
  • C#字节数组转换成字符串 C#字节数组转换成字符串 如果还想从 System.String 类中找到方法进行字符串和字节数组之间的转换,恐怕你会失望了。为了进行这样的转换,我们不得不借助另一个类:System.Text....
  • android byte字节数组转换十六进制字符串一个demo。里面有几种转换测试代码。我的博客地址:http://blog.csdn.net/qq_16064871。
  • 字节数组转换为字符串

    千次阅读 2017-09-17 14:28:03
    1、字节数组转换为字符串 byte[] byBuffer = new byte[20]; ... ... String strRead = new String(byBuffer); strRead = String.copyValueOf(strRead.toCharArray(), 0, byBuffer.length]); 2、字符串转换...
  • scala 字符串转换数组Byte Array in Scala is an array of elements of a byte type. String in Scala is a collection of the character data type. Scala中的字节数组是字节类型的... 将字节数组转换为字符串 (Co...
  • 1. 2个字节数组转换为整数 1 def bytes2uint8(_bytes: Array[Byte], _offset: Int): Int = { 2 val b0 = _bytes(_offset) & 0xff 3 return b0 4 } 5 6 def bytes2sint8(_bytes: Array[By...
  • C#实现 MFC的CString字节数组转换为C#的String 由于项目需要兼容老的MFC软件所保存的文档,而这些文档中又包含了CString数据,所以研究了一下CString保存结构,写了这个类。
  • 不用担心Java有解决方案,您可以使用 ByteArrayInputStream 在Java中将字节数组转换为InputStream 。 此类使用字节数组作为源,并且由于它是InputStream的子类,因此您可以轻松地将其传递给任何接受InputStream作为...
  • C#字节数组转换成字符串<转>

    千次阅读 2016-06-03 23:38:51
    C#字节数组转换成字符串如果还想从 System.String 类中找到方法进行字符串和字节数组之间的转换,恐怕你会失望了。为了进行这样的转换,我们不得不借助另一个类:System.Text.Encoding。该类提供了 bye[] GetBytes...
  • link将字节数组转换成字符串的写法是什么?
  • java中字节数组转换为字符串

    万次阅读 2017-05-29 21:56:59
    1、字节数组转换为字符串 byte[] byBuffer = new byte[20]; ... ... String strRead = new String(byBuffer); strRead=String.copyValueOf(strRead.toCharArray(), 0, byBuffer.length]); 2、字符串转换成字节...
  • java中 如何将一个字节数组转换成字符串
  • 自己主要想用的是将字节数组转换为int型,double型 具体来说,将接收到的4字节数组数据转换为int型 将接收到的8字节数组数据转换为double型 java中有大量的函数可直接利用,C语言只能自己写了,主要用到了<...
  • 不用担心Java有解决方案,您可以使用ByteArrayInputStream以Java将字节数组转换为InputStream 。 此类使用字节数组作为源,并且由于它是InputStream的子类,因此您可以轻松地将其传递给任何接受InputStream作为参数...
  • String与字节数组转换

    2020-10-14 20:03:04
    字节数组–>字符串 String(byte[]): 通过使用平台的默认字符集解码指定的byte数组,构造一个新的String String(byte[],int offset,int length): 用指定的字节数组的一部分,即从数组起始位置offset开始取length个...
  • 字节数组转换为String类型, 说一下为什么要转换为String呢? JSON所能够发送的数据类型 1、Number 在JavaScript中的双精度浮点格式  2、String 双引号的反斜杠转义的Unicode  3、Boolean true 或 false...
  • solidity智能合约[14]-动态字节数组转换为string  2018-11-19 智能合约 solidity语法 solidity, 以太坊, 智能合约 6 评论 字数统计: 74(字) 阅读时长: 1(分) 动态字节数组转换为string 动态字节数组可以...
  • 我们可以参考下思路,完成我们的方法,我们可以用类似下面的代码实现inputStream转化为byte[]数组 public static byte[] ... } 字节数组转换成字符串: String mString = new String(byte);//假设为上面的字节数组

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 332,284
精华内容 132,913
关键字:

字节数组转换