精华内容
下载资源
问答
  • java —— int和byte的相互转化工具方法
    千次阅读
    2019-03-17 23:59:34

    int转byte方法:

        public static byte[] intToByteArray(int i) {
            byte[] result = new byte[4];
            result[0] = (byte)((i >> 24) & 0xFF);
            result[1] = (byte)((i >> 16) & 0xFF);
            result[2] = (byte)((i >> 8) & 0xFF);
            result[3] = (byte)(i & 0xFF);
            return result;
        }

    byte转int方法:

        public static int byteArrayToInt(byte[] bytes) {
            int value=0;
            for(int i = 0; i < 4; i++) {
                int shift= (3-i) * 8;
                value +=(bytes[i] & 0xFF) << shift;
            }
            return value;
        } 

     

    更多相关内容
  • 常用字节转换工具

    2016-08-14 17:20:23
    常用字节转换工具
  • 用来对大小端排序的字节数组进行解析的小工具,包括转为Int32,UInt32,float, double, Int16, UInt16, Long等
  • byte数组操作的工具类,支持byte数组转intint转byte数组,byte数组short,shortbyte数组。。。 下载的人多了,csdn会自动涨分,现在可以手动调了,我给降到最低了
  • Float与Byte互转工具

    2018-03-27 00:44:22
    Float与Byte互转工具,简单,好用 https://blog.csdn.net/kangweijian/article/details/79706672
  • Java 字节数组(byte[])和整型(int)的相互转换


    前言

          恰巧碰到了字节数组和整型的转换问题,特在此总结一下。将 int 按照小端法映射到 byte[] 中。即最低 8 位放在 byte[0] 中,依次类推。


    一、int 转换为 byte[]

          这个实现起来比较简单,先保存最低的 8 位到 byte 数组中,然后不断的右移 8 位,每次保存低 8 位数据即可,参考代码:(这里包含一个 int 到 byte 的转换,转换规则是截取 int 的最低 8 位作为 byte 值)

        public static byte[] intToBytes(int a){
            byte[] ans=new byte[4];
            for(int i=0;i<4;i++)
                ans[i]=(byte)(a>>(i*8));//截断 int 的低 8 位为一个字节 byte,并存储起来
            return ans;
        }
    

    二、测试代码

          为了验证转换结果,简单写了两个方法用来按位打印 int 和 byte,可参考如下:

        public static void intPrint(int a){//将 int 按位从左到右打印
            int count=0;
            for(int i=31;i>=0;i--){
                System.out.print((a>>i)&1);
                count++;
                if(count==4){//每四位为一组,用空格分开
                    System.out.print(" ");
                    count=0;
                }
            }
            System.out.println();
        }
        public static void bytePrint(byte a){//将 byte 按位从左到右打印
            int count=0;
            for(int i=7;i>=0;i--){
                System.out.print((a>>i)&1);
                count++;
                if(count==4){//每四位为一组,用空格分开
                    System.out.print(" ");
                    count=0;
                }
            }
            System.out.println();
        }
    

    三、测试

          测试一下 int 到 byte[] 的正确性:用一个整数来测试一下,如下:

        public static void main(String[] args) {
            int c=968523,d=-65423;
            byte[] ans=intToBytes(d);
            intPrint(d);
            for(int i=0;i<4;i++)
                bytePrint(ans[i]);
                
        }
    

          输出结果为:
          1111 1111 1111 1111 0000 0000 0111 0001
          0111 0001
          0000 0000
          1111 1111
          1111 1111

          算法执行无误。

    四、byte[] 转换为 int

          这个实现起来也比较简单, 每次将 byte 值保存到 int 的最低 8 位,然后 int 左移 8 位,继续保存新的 byte 值即可,参考代码:

        public static int bytesToInt(byte[] a){
            int ans=0;
            for(int i=0;i<4;i++){
                ans<<=8;//左移 8 位
                ans|=a[3-i];//保存 byte 值到 ans 的最低 8 位上
                intPrint(ans);
            }
            return ans;
        }
    

          验证一下(这一次采用整数 c 来说明问题,整数 d 恰好可以得到正确结果…):

        public static void main(String[] args) {
            int c=968523,d=-65423;
            byte[] ans=intToBytes(c);
            intPrint(c);
            for(int i=0;i<4;i++)
                bytePrint(ans[i]);
    
            int e=bytesToInt(ans);
        }
    

          输出结果:
          0000 0000 0000 1110 1100 0111 0100 1011
          0100 1011
          1100 0111
          0000 1110
          0000 0000
          0000 0000 0000 0000 0000 0000 0000 0000
          0000 0000 0000 0000 0000 0000 0000 1110
          1111 1111 1111 1111 1111 1111 1100 0111
          1111 1111 1111 1111 1100 0111 0100 1011

          Error:粗体显示和我们预料中的不太一样,其原因在于:这里包含一个 byte 到 int 的转换,转换规则:如果 byte 值为负,即最高位为 1,那么在前面补上 24 个 1 凑够 32 位作为 int 的值,如果 byte 值为正,即最高位为 0,那么在前面补上 24个 0 得到新的 int 值。

          修改之后:为了每次在将 byte 转换为 int 时,前面都补上 0 ,这里可以将它先和 0xff 取 &。修改之后的代码如下:

        public static int bytesToInt(byte[] a){
            int ans=0;
            for(int i=0;i<4;i++){
                ans<<=8;
                ans|=(a[3-i]&0xff);
                intPrint(ans);
            }
            return ans;
        }
        
        public static void main(String[] args) {
            int c=968523,d=-65423;
            byte[] ans=intToBytes(c);
            intPrint(c);
            for(int i=0;i<4;i++)
                bytePrint(ans[i]);
    
            int e=bytesToInt(ans);
            return;
        }
    

          输出结果:
          0000 0000 0000 1110 1100 0111 0100 1011
          0100 1011
          1100 0111
          0000 1110
          0000 0000
          0000 0000 0000 0000 0000 0000 0000 0000
          0000 0000 0000 0000 0000 0000 0000 1110
          0000 0000 0000 0000 0000 1110 1100 0111
          0000 0000 0000 1110 1100 0111 0100 1011

          能够看到可以得到正确结果。


    总结

          需要注意的是:在 8 位 byte 提升到 32 位 int 时,由于数组在计算机中以补码形式存在,所以要区分正负的。正数前面补 0 ,负数前面补 1。而为了消除其差异性,仅保留我们所感兴趣的低 8 位,需要先将可能存在的 1 均变为 0,所以要先和 0xff 做 & 操作。

    展开全文
  • byte转化工具类,可以实现byte转int,数组,string,小端取高位,低位等
  • 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;
    	}
    
    }
    
    展开全文
  • Java 数字转字节数组工具类 /** * 数字转字节数组工具类 */ public class BitConverter { /** * 以字节数组的形式返回指定的布尔值 * @param data 一个布尔值 * @return 长度为 1 的字节数组 */ ...

    Java 数字转字节数组工具类

    import java.nio.ByteOrder;
    import java.nio.charset.Charset;
    
    /**
     * 数字转字节数组工具类
     */
    public class BitConverter {
    
        /**
         * 以字节数组的形式返回指定的布尔值
         * @param data 一个布尔值
         * @return 长度为 1 的字节数组
         */
        public static byte[] getBytes(boolean data) {
            byte[] bytes = new byte[1];
            bytes[0] = (byte) (data ? 1 : 0);
            return bytes;
        }
        
        /**
         * 以字节数组的形式返回指定的 16 位有符号整数值
         * @param data 要转换的数字
         * @return 长度为 2 的字节数组
         */
        public static byte[] getBytes(short data) {
            byte[] bytes = new byte[2];
            if (isLittleEndian()) {
                bytes[0] = (byte) (data & 0xff);
                bytes[1] = (byte) ((data & 0xff00) >> 8);
            } else {
                bytes[1] = (byte) (data & 0xff);
                bytes[0] = (byte) ((data & 0xff00) >> 8);
            }
            return bytes;
        }
    
        /**
         * 以字节数组的形式返回指定的 Unicode 字符值
         * @param data 要转换的字符
         * @return 长度为 2 的字节数组
         */
        public static byte[] getBytes(char data) {
            byte[] bytes = new byte[2];
            if (isLittleEndian()) {
                bytes[0] = (byte) (data);
                bytes[1] = (byte) (data >> 8);
            } else {
                bytes[1] = (byte) (data);
                bytes[0] = (byte) (data >> 8);
            }
            return bytes;
        }
    
        /**
         * 以字节数组的形式返回指定的 32 位有符号整数值
         * @param data 要转换的数字
         * @return 长度为 4 的字节数组
         */
        public static byte[] getBytes(int data) {
            byte[] bytes = new byte[4];
            if (isLittleEndian()) {
                bytes[0] = (byte) (data & 0xff);
                bytes[1] = (byte) ((data & 0xff00) >> 8);
                bytes[2] = (byte) ((data & 0xff0000) >> 16);
                bytes[3] = (byte) ((data & 0xff000000) >> 24);
            } else {
                bytes[3] = (byte) (data & 0xff);
                bytes[2] = (byte) ((data & 0xff00) >> 8);
                bytes[1] = (byte) ((data & 0xff0000) >> 16);
                bytes[0] = (byte) ((data & 0xff000000) >> 24);
            }
            return bytes;
        }
    
        /**
         * 以字节数组的形式返回指定的 64 位有符号整数值
         * @param data 要转换的数字
         * @return 长度为 8 的字节数组
         */
        public static byte[] getBytes(long data) {
            byte[] bytes = new byte[8];
            if (isLittleEndian()) {
                bytes[0] = (byte) (data & 0xff);
                bytes[1] = (byte) ((data >> 8) & 0xff);
                bytes[2] = (byte) ((data >> 16) & 0xff);
                bytes[3] = (byte) ((data >> 24) & 0xff);
                bytes[4] = (byte) ((data >> 32) & 0xff);
                bytes[5] = (byte) ((data >> 40) & 0xff);
                bytes[6] = (byte) ((data >> 48) & 0xff);
                bytes[7] = (byte) ((data >> 56) & 0xff);
            } else {
                bytes[7] = (byte) (data & 0xff);
                bytes[6] = (byte) ((data >> 8) & 0xff);
                bytes[5] = (byte) ((data >> 16) & 0xff);
                bytes[4] = (byte) ((data >> 24) & 0xff);
                bytes[3] = (byte) ((data >> 32) & 0xff);
                bytes[2] = (byte) ((data >> 40) & 0xff);
                bytes[1] = (byte) ((data >> 48) & 0xff);
                bytes[0] = (byte) ((data >> 56) & 0xff);
            }
            return bytes;
        }
    
        /**
         * 以字节数组的形式返回指定的单精度浮点值
         * @param data 要转换的数字
         * @return 长度为 4 的字节数组
         */
        public static byte[] getBytes(float data) {
            return getBytes(Float.floatToIntBits(data));
        }
    
        /**
         * 以字节数组的形式返回指定的双精度浮点值
         * @param data 要转换的数字
         * @return 长度为 8 的字节数组
         */
        public static byte[] getBytes(double data) {
            return getBytes(Double.doubleToLongBits(data));
        }
        
        /**
         * 将指定字符串中的所有字符编码为一个字节序列
         * @param data 包含要编码的字符的字符串
         * @return 一个字节数组,包含对指定的字符集进行编码的结果
         */
        public static byte[] getBytes(String data) {
            return data.getBytes(Charset.forName("UTF-8"));
        }
        
        /**
         * 将指定字符串中的所有字符编码为一个字节序列
         * @param data 包含要编码的字符的字符串
         * @param charsetName 字符集编码
         * @return 一个字节数组,包含对指定的字符集进行编码的结果
         */
        public static byte[] getBytes(String data, String charsetName) {
            return data.getBytes(Charset.forName(charsetName));
        }
        
        /**
         * 返回由字节数组转换来的布尔值
         * @param bytes 字节数组
         * @return 布尔值
         */
        public static boolean toBoolean(byte[] bytes) {
            return bytes[0] == 0 ? false : true;
        }
        
        /**
         * 返回由字节数组中的指定的一个字节转换来的布尔值
         * @param bytes 字节数组
         * @param startIndex 起始下标
         * @return 布尔值
         */
        public static boolean toBoolean(byte[] bytes, int startIndex) {
            return toBoolean(copyFrom(bytes, startIndex, 1));
        }
        
        /**
         * 返回由字节数组转换来的 16 位有符号整数
         * @param bytes 字节数组
         * @return 由两个字节构成的 16 位有符号整数
         */
        public static short toShort(byte[] bytes) {
            if (isLittleEndian()) {
                return (short) ((0xff & bytes[0]) | (0xff00 & (bytes[1] << 8)));
            } else {
                return (short) ((0xff & bytes[1]) | (0xff00 & (bytes[0] << 8)));
            }
        }
        
        /**
         * 返回由字节数组中的指定的两个字节转换来的 16 位有符号整数
         * @param bytes 字节数组
         * @param startIndex 起始下标
         * @return 由两个字节构成的 16 位有符号整数
         */
        public static short toShort(byte[] bytes, int startIndex) {
            return toShort(copyFrom(bytes, startIndex, 2));
        }
    
        /**
         * 返回由字节数组转换来的 Unicode 字符
         * @param bytes 字节数组
         * @return 由两个字节构成的字符
         */
        public static char toChar(byte[] bytes) {
            if (isLittleEndian()) {
                return (char) ((0xff & bytes[0]) | (0xff00 & (bytes[1] << 8)));
            } else {
                return (char) ((0xff & bytes[1]) | (0xff00 & (bytes[0] << 8)));
            }
        }
        
        /**
         * 返回由字节数组中的指定的两个字节转换来的 Unicode 字符
         * @param bytes 字节数组
         * @param startIndex 起始下标
         * @return 由两个字节构成的字符
         */
        public static char toChar(byte[] bytes, int startIndex) {
            return toChar(copyFrom(bytes, startIndex, 2));
        }
    
        /**
         * 返回由字节数组转换来的 32 位有符号整数
         * @param bytes 字节数组
         * @return 由四个字节构成的 32 位有符号整数
         */
        public static int toInt(byte[] bytes) {
            if (isLittleEndian()) {
                return (0xff & bytes[0]) 
                        | (0xff00 & (bytes[1] << 8)) 
                        | (0xff0000 & (bytes[2] << 16))
                        | (0xff000000 & (bytes[3] << 24));
            } else {
                return (0xff & bytes[3]) 
                        | (0xff00 & (bytes[2] << 8)) 
                        | (0xff0000 & (bytes[1] << 16))
                        | (0xff000000 & (bytes[0] << 24));
            }
        }
        
        /**
         * 返回由字节数组中的指定的四个字节转换来的 32 位有符号整数
         * @param bytes 字节数组
         * @param startIndex 起始下标
         * @return 由四个字节构成的 32 位有符号整数
         */
        public static int toInt(byte[] bytes, int startIndex) {
            return toInt(copyFrom(bytes, startIndex, 4));
        }
    
        /**
         * 返回由字节数组转换来的 64 位有符号整数
         * @param bytes 字节数组
         * @return 由八个字节构成的 64 位有符号整数
         */
        public static long toLong(byte[] bytes) {
            if (isLittleEndian()) {
                return (0xffL & (long) bytes[0]) 
                        | (0xff00L & ((long) bytes[1] << 8)) 
                        | (0xff0000L & ((long) bytes[2] << 16))
                        | (0xff000000L & ((long) bytes[3] << 24)) 
                        | (0xff00000000L & ((long) bytes[4] << 32))
                        | (0xff0000000000L & ((long) bytes[5] << 40)) 
                        | (0xff000000000000L & ((long) bytes[6] << 48))
                        | (0xff00000000000000L & ((long) bytes[7] << 56));
            } else {
                return (0xffL & (long) bytes[7]) 
                        | (0xff00L & ((long) bytes[6] << 8)) 
                        | (0xff0000L & ((long) bytes[5] << 16))
                        | (0xff000000L & ((long) bytes[4] << 24)) 
                        | (0xff00000000L & ((long) bytes[3] << 32))
                        | (0xff0000000000L & ((long) bytes[2] << 40)) 
                        | (0xff000000000000L & ((long) bytes[1] << 48))
                        | (0xff00000000000000L & ((long) bytes[0] << 56));
            }
        }
        
        /**
         * 返回由字节数组中的指定的八个字节转换来的 64 位有符号整数
         * @param bytes 字节数组
         * @param startIndex 起始下标
         * @return 由八个字节构成的 64 位有符号整数
         */
        public static long toLong(byte[] bytes, int startIndex) {
            return toLong(copyFrom(bytes, startIndex, 8));
        }
    
        /**
         * 返回由字节数组转换来的单精度浮点数
         * @param bytes 字节数组
         * @return 由四个字节构成的单精度浮点数
         */
        public static float toFloat(byte[] bytes) {
            return Float.intBitsToFloat(toInt(bytes));
        }
        
        /**
         * 返回由字节数组中的指定的四个字节转换来的单精度浮点数
         * @param bytes 字节数组
         * @param startIndex 起始下标
         * @return 由四个字节构成的单精度浮点数
         */
        public static float toFloat(byte[] bytes, int startIndex) {
            return Float.intBitsToFloat(toInt(copyFrom(bytes, startIndex, 4)));
        }
    
        /**
         * 返回由字节数组转换来的双精度浮点数
         * @param bytes 字节数组
         * @return 由八个字节构成的双精度浮点数
         */
        public static double toDouble(byte[] bytes) {
            return Double.longBitsToDouble(toLong(bytes));
        }
        
        /**
         * 返回由字节数组中的指定的八个字节转换来的双精度浮点数
         * @param bytes 字节数组
         * @param startIndex 起始下标
         * @return 由八个字节构成的双精度浮点数
         */
        public static double toDouble(byte[] bytes, int startIndex) {
            return Double.longBitsToDouble(toLong(copyFrom(bytes, startIndex, 8)));
        }
        
        /**
         * 返回由字节数组转换来的字符串
         * @param bytes 字节数组
         * @return 字符串
         */
        public static String toString(byte[] bytes) {
            return new String(bytes, Charset.forName("UTF-8"));
        }
        
        /**
         * 返回由字节数组转换来的字符串
         * @param bytes 字节数组
         * @param charsetName 字符集编码
         * @return 字符串
         */
        public static String toString(byte[] bytes, String charsetName) {
            return new String(bytes, Charset.forName(charsetName));
        }
        
        /**
         * 以字符串表示形式返回字节数组的内容
         * @param bytes 字节数组
         * @return 字符串形式的 <tt>bytes</tt>
         */
        public static String toHexString(byte[] bytes) {
            if (bytes == null)
                return "null";
            int iMax = bytes.length - 1;
            if (iMax == -1)
                return "[]";
            String digits = "0123456789abcdef";
            StringBuilder b = new StringBuilder();
            b.append('[');
            for (int i = 0; ; i++) {
                b.append(digits.charAt((0xF0 & bytes[i]) >>> 4));
                b.append(digits.charAt(0x0F & bytes[i]));
                if (i == iMax)
                    return b.append(']').toString();
                b.append(',').append(' ');
            }
        }
        
    
        // --------------------------------------------------------------------------------------------
    
     
        /**
         * 数组拷贝。
         * @param src 字节数组。
         * @param off 起始下标。
         * @param len 拷贝长度。
         * @return 指定长度的字节数组。
         */
        private static byte[] copyFrom(byte[] src, int off, int len) {
            // return Arrays.copyOfRange(src, off, off + len);
            byte[] copy = new byte[len];
            System.arraycopy(src, off, copy, 0, Math.min(src.length - off, len));
            return copy;
        }
        
        /**
         * 判断 CPU Endian 是否为 Little
         * @return 判断结果
         */
        private static boolean isLittleEndian() {
            return ByteOrder.nativeOrder() == ByteOrder.LITTLE_ENDIAN;
        }
    }
    
    展开全文
  • java 16进制和int 转换

    千次阅读 2019-10-29 16:39:59
    import java.nio.charset.Charset; import org.apache.commons.lang3.ArrayUtils; /** * 字节数组转换工具类 */ public class BytesUtils { public static final String GBK = "GBK"; ...
  • 1、String和int转换 (1)Sting 转为int String str = "123"; try { int a = Integer.parseInt(str); } catch (NumberFormatException e) { e.printStackTrace(); } (2)int转为String String ...
  • lua 二进制字节int相互转换

    万次阅读 2017-08-15 10:38:30
    看过我转载的http://blog.csdn.net/u013654125/article/details/73381633的同学,如果需要用lua把自定义的二进制数据和protobuf结合成新的数据传给服务器,可以看...-- 工具类 cc.exports.Utils = class("Ut...
  • Java中int为什么占四个字节

    千次阅读 2021-08-25 18:53:57
    因为计算机作为一种电子计算机工具,是由大量的电子器件组成的,在这些电子器件中,电路的通断,电位的高低,用两个数字符号“1”和“0”分别表示容易实现,同时二进制的运算法则也很简单,因此计算机内部通常采用二...
  • 字节转换工具

    千次阅读 2018-07-26 15:06:24
    * 字节转换工具 * @author ThinkGem * @version 2015-6-20 */ public class ByteUtils { private static final int UNIT = 1024; /** * @param byteSize 字节 * @return */ public st...
  • Java字节数组与常见类型转换工具,包括byte[] 与int long double float string boolean 等类型的相互转换。
  • /** * 读取指定长度的字节转为字符串 * @param byteBuf 报文 * @param from 包括的开始字节 * @param to 包括的结束字节 ... public static String getString(ByteBuf byteBuf,int from,int to) ...
  • Float与Byte[]互的小工具

    千次阅读 2018-03-27 00:43:34
    Float与Byte[]互的小工具 晚上需要一个float与byte互的小工具,一时半会没找到合适的,就自己写了一个。 程序也很简单。 private void Float2ByteBtn_Click(object sender, EventArgs e) { float f=0;...
  • ip地址4字节byte,char2字节byte,byte数组char,int整数转换为4字节的byte数组,byte数组转换为int整数,double类型8字节数组,8位数组double,long整数转换为8字节的byte数组,short整数转换为2字节的...
  • 最近跳槽到通信公司 各种解析,传递byte数组 整理下转换为字节工具类 方便下以后开发; 1.截取byte数组   public static byte[] subByteArr(byte[] data, int start, int length) { if (length0) { return new ...
  • 所有能找到的资料中,都对第一种进行了忽略,认为修改源码改动太大,而使用了第二种方式。 不论是注册Map的解析器,还是使用自定义的Bean对象,本质都是指定类型解析,也就是第二种,完全无法解决以下问题。 ...
  • 前言:用于处理Java基本数据的转换及进制转换操作工具 一、实现功能 1、int与byte互 2、int与byte[]互 3、short与byte互 4、short与byte[]互 5、16位short与byte[]互 6、long与byte[]互 7、byte[]与...
  • https://www.jianshu.com/p/4610944ee9be public static String readableFileSize(long size) { if (size &lt;= 0) return "0"; final String[] units = new String[]{"B", "... int d
  • java float转换int

    千次阅读 2019-09-12 11:52:18
    ①当字节类型变量参与运算,java作自动数据运算类型的提升,将其转换为int类型。   byte b;    b=3;    b=(byte)(b*3);//必须声明byte。   ②带小数的变量默认为double类型。   float f;    f=1.3f;//必须...
  • java字节字符转换工具

    千次阅读 2018-07-24 13:45:37
    工具类作用是字节,字符数组的相互转换(避免重复造轮子),分享给大家 public class ConvertUtil {  /**  * 字节数组16进制字符串  */  public static String bytes2HexString(byte[] b) {  String r = ...
  • 在实践中经常会遇到两个btye数组合并成一个,或者多个byte数组合并成一个,以及int类型byte数组,逆向的byte数组转int类型。 下面汇总了上述相关功能的方法,提供了对应的工具类,直接查看源码或更多的工具类可...
  • java实现“进制转换-在线工具

    千次阅读 2018-09-12 16:24:03
    我在开发的过程中是先把每一个字段值成二进制数,位数不够的高位补0,因为设计的时候就已经考虑到,在特殊字段转换中不会超过6位。60—–&amp;amp;amp;amp;gt;111100。 最后我把所有的都拼接...
  • 字符串与字节的相互转换

    千次阅读 2018-12-19 17:15:49
    在某A项目中,需要使用第三方系统socket接口,但第三系统无法提供...抓包工具抓取的都是16进制、2进制字节报文,由此引发字节与字符串互方式的实验。 示例,源码: import java.util.ArrayList; import java.ut...
  • Java int转16进制以后补零及F大写

    千次阅读 2019-08-16 13:25:13
    需要将int类型的数字转换为16进制字符串,不足两位的补零,f全部大写。 用下面这个apache的commons-lang3工具包,功能强大,号称Java第二API。 import org.apache.commons.lang3.StringUtils; 代码: String tmp ...
  • 废话不多说,直接上代码。处理字节数组的常用方法,包括字节数组的拼接/拆分,转换等。做数据处理时用得着!
  • 图片和字节流之间的转换

    千次阅读 2020-05-19 09:37:09
    将图片保存成byte数组保存到... /// 把一幅图片转换成字节数组 /// </summary> /// <param name="imageData"></param> /// <returns></returns> private byte[] ToByte(Image...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 243,015
精华内容 97,206
关键字:

int 转字节在线工具