精华内容
下载资源
问答
  • 常用的byte字串、asciii码字串 留底以备后用

    之前写过一个C++中ascii码字串、十六进制字串、byte字串之间的互转 的文章  http://blog.csdn.net/jimbo_lee/article/details/10404295


    先整一个java常用的byte字串、asciii码字串、十六进制字串的互相转换, 留底以备后用


    import android.graphics.Bitmap;
    import android.graphics.Matrix;
    import java.io.UnsupportedEncodingException;
    import java.util.Arrays;
    
    public class StrUtil {
    	public static int hexCharToInt(char c) {
    		if ((c >= '0') && (c <= '9'))
    			return (c - '0');
    		if ((c >= 'A') && (c <= 'F'))
    			return (c - 'A' + 10);
    		if ((c >= 'a') && (c <= 'f'))
    			return (c - 'a' + 10);
    
    		throw new RuntimeException("invalid hex char '" + c + "'");
    	}
    
    	public static String bytesToAscii(byte[] bytes, int offset, int dateLen) {
    		if ((bytes == null) || (bytes.length == 0) || (offset < 0) || (dateLen <= 0)) {
    			return null;
    		}
    		if ((offset >= bytes.length) || (bytes.length - offset < dateLen)) {
    			return null;
    		}
    
    		String asciiStr = null;
    		byte[] data = new byte[dateLen];
    		System.arraycopy(bytes, offset, data, 0, dateLen);
    		try {
    			asciiStr = new String(data, "ISO8859-1");
    		} catch (UnsupportedEncodingException e) {
    		}
    		return asciiStr;
    	}
    
    	public static String bytesToAscii(byte[] bytes, int dateLen) {
    		return bytesToAscii(bytes, 0, dateLen);
    	}
    
    	public static String bytesToAscii(byte[] bytes) {
    		return bytesToAscii(bytes, 0, bytes.length);
    	}
    
    	public static String bytesToHexString(byte[] bytes, int offset, int len) {
    		if (bytes == null)
    			return "null!";
    
    		StringBuilder ret = new StringBuilder(2 * len);
    
    		for (int i = 0; i < len; ++i) {
    			int b = 0xF & bytes[(offset + i)] >> 4;
    			ret.append("0123456789abcdef".charAt(b));
    			b = 0xF & bytes[(offset + i)];
    			ret.append("0123456789abcdef".charAt(b));
    		}
    
    		return ret.toString();
    	}
    
    	public static String bytesToHexString(byte[] bytes, int len) {
    		return ((bytes == null) ? "null!" : bytesToHexString(bytes, 0, len));
    	}
    
    	public static String bytesToHexString(byte[] bytes) {
    		return ((bytes == null) ? "null!" : bytesToHexString(bytes, bytes.length));
    	}
    
    	public static byte[] hexStringToBytes(String s) {
    		if (s == null)
    			return null;
    
    		int sz = s.length();
    		try {
    			byte[] ret = new byte[sz / 2];
    			for (int i = 0; i < sz; i += 2) {
    				ret[(i / 2)] = (byte) (hexCharToInt(s.charAt(i)) << 4 | hexCharToInt(s.charAt(i + 1)));
    			}
    
    			return ret;
    		} catch (RuntimeException re) {
    		}
    		return null;
    	}
    
    	public static byte[] shortToBytesLe(short shortValue) {
    		byte[] bytes = new byte[2];
    
    		for (int i = 0; i < bytes.length; ++i) {
    			bytes[i] = (byte) (shortValue >> i * 8 & 0xFF);
    		}
    
    		return bytes;
    	}
    
    	public static byte[] shortToBytesBe(short shortValue) {
    		byte[] bytes = new byte[2];
    
    		for (int i = 0; i < bytes.length; ++i) {
    			bytes[(bytes.length - i - 1)] = (byte) (shortValue >> i * 8 & 0xFF);
    		}
    
    		return bytes;
    	}
    
    	public static byte[] intToBytesLe(int intValue) {
    		byte[] bytes = new byte[4];
    
    		for (int i = 0; i < bytes.length; ++i) {
    			bytes[i] = (byte) (intValue >> i * 8 & 0xFF);
    		}
    
    		return bytes;
    	}
    
    	public static byte[] intToBytesBe(int intValue) {
    		byte[] bytes = new byte[4];
    
    		for (int i = 0; i < bytes.length; ++i) {
    			bytes[(bytes.length - i - 1)] = (byte) (intValue >> i * 8 & 0xFF);
    		}
    
    		return bytes;
    	}
    
    	public static int bytesToIntLe(byte[] bytes) {
    		if ((bytes == null) || (bytes.length > 4)) {
    			throw new RuntimeException("invalid arg");
    		}
    
    		int ret = 0;
    
    		for (int i = 0; i < bytes.length; ++i) {
    			ret += ((bytes[i] & 0xFF) << i * 8);
    		}
    
    		return ret;
    	}
    
    	public static int bytesToIntLe(byte[] data, int start, int end) {
    		return bytesToIntLe(Arrays.copyOfRange(data, start, end));
    	}
    
    	public static int bytesToIntBe(byte[] bytes) {
    		if ((bytes == null) || (bytes.length > 4)) {
    			throw new RuntimeException("invalid arg");
    		}
    
    		int ret = 0;
    
    		for (int i = 0; i < bytes.length; ++i) {
    			ret += ((bytes[i] & 0xFF) << (bytes.length - i - 1) * 8);
    		}
    
    		return ret;
    	}
    
    	public static int bytesToIntBe(byte[] data, int start, int end) {
    		return bytesToIntBe(Arrays.copyOfRange(data, start, end));
    	}
    
    	public static int bytesToIntLe(byte b0, byte b1, byte b2, byte b3) {
    		int ret = 0;
    
    		ret = b0 & 0xFF;
    		ret += ((b1 & 0xFF) << 8);
    		ret += ((b2 & 0xFF) << 16);
    		ret += ((b3 & 0xFF) << 24);
    
    		return ret;
    	}
    
    	public static int bytesToIntBe(byte b0, byte b1, byte b2, byte b3) {
    		int ret = 0;
    
    		ret = (b0 & 0xFF) << 24;
    		ret += ((b1 & 0xFF) << 16);
    		ret += ((b2 & 0xFF) << 8);
    		ret += (b3 & 0xFF);
    
    		return ret;
    	}
    
    	public static void byteArraySetByte(byte[] bytesArray, byte setValue, int index) {
    		bytesArray[index] = setValue;
    	}
    
    	public static void byteArraySetByte(byte[] bytesArray, int setValue, int index) {
    		bytesArray[index] = (byte) (setValue & 0xFF);
    	}
    
    	public static void byteArraySetBytes(byte[] bytesArray, byte[] setValues, int index) {
    		System.arraycopy(setValues, 0, bytesArray, index, setValues.length);
    	}
    
    	public static void byteArraySetWord(byte[] bytesArray, int setValue, int index) {
    		bytesArray[index] = (byte) (setValue & 0xFF);
    		bytesArray[(index + 1)] = (byte) (setValue >> 8 & 0xFF);
    	}
    
    	public static void byteArraySetWordBe(byte[] bytesArray, int setValue, int index) {
    		bytesArray[index] = (byte) (setValue >> 8 & 0xFF);
    		bytesArray[(index + 1)] = (byte) (setValue & 0xFF);
    	}
    
    	public static void byteArraySetInt(byte[] bytesArray, int setValue, int index) {
    		bytesArray[index] = (byte) (setValue & 0xFF);
    		bytesArray[(index + 1)] = (byte) (setValue >> 8 & 0xFF);
    		bytesArray[(index + 2)] = (byte) (setValue >> 16 & 0xFF);
    		bytesArray[(index + 3)] = (byte) (setValue >> 24 & 0xFF);
    	}
    
    	public static void byteArraySetIntBe(byte[] bytesArray, int setValue, int index) {
    		bytesArray[index] = (byte) (setValue >> 24 & 0xFF);
    		bytesArray[(index + 1)] = (byte) (setValue >> 16 & 0xFF);
    		bytesArray[(index + 2)] = (byte) (setValue >> 8 & 0xFF);
    		bytesArray[(index + 3)] = (byte) (setValue & 0xFF);
    	}
    
    	public static void delayms(int ms) {
    		if (ms <= 0)
    			return;
    		try {
    			Thread.sleep(ms);
    		} catch (InterruptedException e) {
    		}
    	}
    
    	public static Bitmap bitmapRotate(Bitmap b, int degrees) {
    		if ((degrees != 0) && (b != null)) {
    			Matrix m = new Matrix();
    			m.setRotate(degrees, b.getWidth() / 2.0F, b.getHeight() / 2.0F);
    			try {
    				Bitmap b2 = Bitmap.createBitmap(b, 0, 0, b.getWidth(), b.getHeight(), m, true);
    
    				if (b != b2) {
    					b.recycle();
    					b = b2;
    				}
    			} catch (OutOfMemoryError ex) {
    			}
    		}
    		return b;
    	}
    
    	public static boolean isAscii(char ch) {
    		return (ch <= '');
    	}
    
    	public static boolean isAscii(String text) {
    		for (int i = 0; i < text.length(); ++i) {
    			if (!(isAscii(text.charAt(i)))) {
    				return false;
    			}
    		}
    		return true;
    	}
    
    	public static boolean hasAsciiChar(String text) {
    		for (int i = 0; i < text.length(); ++i) {
    			if (isAscii(text.charAt(i))) {
    				return true;
    			}
    		}
    		return false;
    	}
    }
    


    import java.io.ByteArrayOutputStream;
    
    import javax.crypto.Cipher;
    import javax.crypto.SecretKey;
    import javax.crypto.SecretKeyFactory;
    import javax.crypto.spec.DESKeySpec;
    import javax.crypto.spec.DESedeKeySpec;
    
    /**
     * 字节、整数、长整数等数据类型之间的拆分和转换。<br/>
     * 还包括BCD码,十六进制码,网络字节序等等相互转换
     *
     * @author 
     * @version 1.0
     */
    public class TypeConvert
    {
        /**
         * 字节数组转换成整型。(网络字节序,高字节在前)
         *
         * @param b 字节数组。
         * @param offset 待转换字节开始的位置。
         * @return 整数形式。
         */
        public final static int byte2int(byte[] b, int offset)
        {
            return (b[offset + 3] & 0xff) | ((b[offset + 2] & 0xff) << 8) | ((b[offset + 1] & 0xff) << 16)
                    | ((b[offset] & 0xff) << 24);
        }
    
        /**
         * 字节数组转换成整型。(网络字节序,高字节在前)
         *
         * @param b 字节数组。
         * @return 整数形式。
         */
        public final static int byte2int(byte[] b)
        {
            return (b[3] & 0xff) | ((b[2] & 0xff) << 8) | ((b[1] & 0xff) << 16) | ((b[0] & 0xff) << 24);
        }
    
        /**
         * 低字节在前,高字节在后字节流转换为整型
         *
         * @param buf byte[]
         * @param offset int
         * @return int
         */
        public final static int Sbyte2int(byte[] buf, int offset)
        { // 读取4个.
            return (buf[offset] & 0xff) | ((buf[offset + 1] << 8) & 0xff00) | (((buf[offset + 2] << 16) & 0xff0000))
                    | (((buf[offset + 3] << 24) & 0xff000000));
        }
    
        /**
         * 低字节在前,高字节在后整型转换为字符串
         *
         * @param n int
         * @param buf byte[]
         * @param offset int
         */
        public final static void Sint2byte(int n, byte[] buf, int offset)
        {
            buf[offset + 3] = (byte) (n >> 24);
            buf[offset + 2] = (byte) (n >> 16);
            buf[offset + 1] = (byte) (n >> 8);
            buf[offset + 0] = (byte) n;
        }
    
        /**
         * 整型转换成16进制,,负数最后要在最高位加1就是8
         *
         * @param nInt int
         * @return 16进制度字符串。
         */
        public final static String int2hex(int nInt)
        {
            int n = nInt, tmp;
            // 不断的移动,4个分一小段,,移位和与或操作。
            char[] bb = new char[8];
            for (int i = 0; i < 32; i += 4)
            {
                tmp = (int) ((n >> i) & 0x0000000f);
                tmp = getHex(tmp);
                bb[7 - i / 4] = (char) tmp;
            }
            return new String(bb);
        }
    
        private final static String HEX = "0123456789ABCDEF";
    
        public final static int hex2int(String hex)
        {
            int ret = 0;
            for (int i = 0, len = hex.length(); i < len; i++)
            {
                ret = (ret << 8) + HEX.indexOf(hex.charAt(i));
            }
    
            return ret;
        }
    
        // 默认要求是大写十六进制,否则出错
        public final static byte hex2Byte(char hex)
        {
            byte b = (byte) HEX.indexOf(hex);
            return b;
        }
    
        /**
         * 将字节数组内容按照二进制码打印出来
         *
         * @param buf byte[]
         * @return String
         */
        public final static String byte2binary(byte[] buf)
        {
            int len = buf.length;
            StringBuilder chars = new StringBuilder();
            byte tmp;
            int inch = 0;
            int j;
            for (int i = 0; i < len; i++)
            {
                tmp = buf[i];
                chars.append(' ');
                for (j = 7; j >= 0; j--)
                {
                    inch = ((tmp >> j) & 0x01);
                    if (inch == 0)
                    {
                        chars.append('0');
                    }
                    else
                    {
                        chars.append('1');
                    }
                }
            }
            return chars.substring(1);
        }
    
        /**
         * BCD码转为10进制串(阿拉伯数据)<br/>
         * * BCD与十进制字符串的转换.<br/>
         * BCD(Binary Coded Decimal)是用二进制编码表示的十进制数,<br/>
         * 十进制数采用0~9十个数字,是人们最常用的。在计算机中,同一个数可以用两种BCD格式来表示:<br/>
         * ①压缩的BCD码 ②非压缩的BCD码<br/>
         * 压缩的BCD码:<br/>
         * 压缩的BCD码用4位二进制数表示一个十进制数位,整个十进制数用一串BCD码来表示。<br/>
         * 例如,十进制数59表示成压缩的BCD码为0101 1001,十进制数1946表示成压缩的BCD码为0001 1001 0100 0110。<br/>
         * 非压缩的BCD码:<br/>
         * 非压缩的BCD码用8位二进制数表示一个十进制数位,其中低4位是BCD码,高4位是0。<br/>
         * 例如,十进制数78表示成压缩的BCD码为0111 1000。<br/>
         * 从键盘输入数据时,计算机接收的是ASCII码,要将ASCII码表示的数转换成BCD码是很简单的,<br/>
         * 只要把ASCII码的高4位清零即可。反之,如果要把BCD码转换成ASII码,只要把BCD码 "或|"00110000即可。
         *
         * @param bytes BCD码
         * @return String 10进制串
         */
        public static String bcd2Str(byte[] bytes)
        {
            if (bytes.length == 0)
            {
                return "";
            }
    
            StringBuffer sb = new StringBuffer();
            for (int i = 0; i < bytes.length; i++)
            {
                int h = ((bytes[i] & 0xff) >> 4) + 48;
                sb.append((char) h);
                int l = (bytes[i] & 0x0f) + 48;
                sb.append((char) l);
            }
            return sb.toString();
        }
    
        /**
         * 10进制串转为BCD码<br/>
         *
         * @param asc 10进制串
         * @return byte[] BCD码
         */
        public static byte[] str2Bcd(String data)
        {
            if (data.length() == 0)
            {
                return new byte[0];
            }
    
            String str = data;
            // 奇数个数字需左补零
            if (str.length() % 2 != 0)
            {
                str = "0" + str;
            }
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            char[] cs = str.toCharArray();
            for (int i = 0; i < cs.length; i += 2)
            {
                int high = cs[i] - 48;
                int low = cs[i + 1] - 48;
                baos.write(high << 4 | low);
            }
            return baos.toByteArray();
        }
    
        /**
         * 将字节数组内容按照十六进制码打印出来
         *
         * @param buf byte[]
         * @param split String 分隔符
         * @return String
         */
        public final static String bytes2hex(byte[] buf, String split)
        {
            if ((split == null) || (split.length() == 0))
            {
                return bytes2hex(buf);
            }
    
            if ((buf == null) || (buf.length == 0))
            {
                return "";
            }
            StringBuilder chars = new StringBuilder();
            for (byte tmp : buf)
            {
                chars.append(split);
                int inch = ((tmp >> 4) & 0x0F);
                inch = getHex(inch);
                chars.append((char) inch);
    
                inch = (tmp & 0x0F);
                inch = getHex(inch);
                chars.append((char) inch);
            }
    
            return chars.substring(split.length());
        }
    
        /**
         * 将字节数组内容按照十六进制码打印出来
         *
         * @param buf byte[]
         * @param split String 分隔符
         * @return String
         */
        public final static String bytes2hex(byte[] buf)
        {
            if ((buf == null) || (buf.length == 0))
            {
                return "";
            }
    
            StringBuilder chars = new StringBuilder();
            for (byte b : buf)
            {
                int inch = ((b >> 4) & 0x0F);
                inch = getHex(inch);
                chars.append((char) inch);
    
                inch = (b & 0x0F);
                inch = getHex(inch);
                chars.append((char) inch);
            }
    
            return chars.toString();
        }
    
        private static int getHex(int inch)
        {
            if (inch >= 10)
            {
                return inch + 55;
            }
            else
            {
                return inch + 48;
            }
        }
    
        public static String byte2hex(byte b)
        {
            String hex = "";
            int inch = ((b >> 4) & 0x0F);
            inch = getHex(inch);
            hex += (char) inch;
    
            inch = (b & 0x0F);
            inch = getHex(inch);
            hex += (char) inch;
            return hex;
        }
    
        /**
         * 将十六进制码字符串转换成字节数组内容
         *
         * @param str String
         * @return String
         */
        public final static byte[] hex2bytes(String str)
        {
            str = str.toUpperCase();
            int len = str.length() / 2;
            byte[] buf = new byte[len];
            int inch = 0;
            for (int i = 0; i < len; i++)
            {
                inch = str.charAt(i + i);
                if (inch >= 65)
                {
                    buf[i] = (byte) (((inch - 55) << 4) & 0xF0);
                }
                else
                {
                    buf[i] = (byte) (((inch - 48) << 4) & 0xF0);
                }
                inch = str.charAt(i + i + 1);
                if (inch >= 65)
                {
                    buf[i] = (byte) (buf[i] | ((inch - 55) & 0x0F));
                }
                else
                {
                    buf[i] = (byte) (buf[i] | ((inch - 48) & 0x0F));
                }
    
            }
            return buf;
        }
    
        /***
         * 根据实际长度返回,不补任何东西.
         *
         * @param aa int
         * @return String 一个16进制的字符串.
         */
        public final static String int2hexA(int aa)
        {
            char[] cc = new char[8];
            int len = 0;
            int tmp = 0;
            for (int offset = 28; offset >= 0; offset -= 4)
            {
                tmp = ((aa >> offset) & 0x0f);
                if ((tmp == 0) && (len == 0))
                { // 开头是0则省略调.
                    continue;
                }
                else
                    tmp = getHex(tmp);
                // 遇到正常字符.
                // len++;
                cc[len++] = (char) tmp;
            }
            return new String(cc, 0, len);
        }
    
        public final static void main(String[] args)
        {
           /* System.out.println(TypeConvert.byte2binary("asdf".getBytes()));
            System.out.println(TypeConvert.bytes2hex("asdf".getBytes(), " "));
            byte[] buf = TypeConvert.hex2bytes("f1234f");
            System.out.println(TypeConvert.bytes2hex(buf, ""));
            System.out.println(TypeConvert.int2hex(255).substring(6));*/
        	byte[] tmpbytes=binaryTobytes("010001000111010000000000000000000000010100000000000000000000000");
        	System.out.println(bytes2hex(tmpbytes));
        	System.out.println(byte2binary(hex2bytes("A23A000002800000")));
        }
    
        /**
         * 字节数组转换成长整型。(网络字节序,高字节在前)
         *
         * @param b 字节数组。
         * @return 长整数形式。
         */
        public final static long byte2long(byte[] b)
        {
            return ((long) b[7] & 0xff) | (((long) b[6] & 0xff) << 8) | (((long) b[5] & 0xff) << 16)
                    | (((long) b[4] & 0xff) << 24) | (((long) b[3] & 0xff) << 32) | (((long) b[2] & 0xff) << 40)
                    | (((long) b[1] & 0xff) << 48) | ((long) b[0] << 56);
        }
    
        /**
         * 字节数组转换成长整型。(网络字节序,高字节在前)
         *
         * @param b byte[] 字节数组。
         * @param offset int
         * @return long 长整数形式。
         */
        public final static long byte2long(byte[] b, int offset)
        {
            return ((long) b[offset + 7] & 0xff) | (((long) b[offset + 6] & 0xff) << 8)
                    | (((long) b[offset + 5] & 0xff) << 16) | (((long) b[offset + 4] & 0xff) << 24)
                    | (((long) b[offset + 3] & 0xff) << 32) | (((long) b[offset + 2] & 0xff) << 40)
                    | (((long) b[offset + 1] & 0xff) << 48) | ((long) b[offset] << 56);
        }
    
        /**
         * 整型转换成字节。(网络字节序,高字节在前)
         *
         * @param n 整数。
         * @return 长度为4的字节数组。
         */
        public final static byte[] int2byte(int n)
        {
            byte[] b = new byte[4];
            b[0] = (byte) (n >> 24);
            b[1] = (byte) (n >> 16);
            b[2] = (byte) (n >> 8);
            b[3] = (byte) n;
            return b;
        }
    
        /**
         * 整型转换成字节。(网络字节序,高字节在前)
         *
         * @param n 整数。
         * @param buf 存放转换结果的字节数组。
         * @param offset 存放位置的偏移地址。
         */
        public final static void int2byte(int n, byte[] buf, int offset)
        {
            buf[offset] = (byte) (n >> 24);
            buf[offset + 1] = (byte) (n >> 16);
            buf[offset + 2] = (byte) (n >> 8);
            buf[offset + 3] = (byte) n;
        }
    
        /**
         * 短整型转换成字节。(网络字节序,高字节在前)
         *
         * @param n 整数。
         * @return 长度为4的字节数组。
         */
        public final static byte[] short2byte(int n)
        {
            byte[] b = new byte[2];
            b[0] = (byte) (n >> 8);
            b[1] = (byte) n;
            return b;
        }
    
        /**
         * 短整型转换成字节。(网络字节序,高字节在前)
         *
         * @param n 整数。
         * @param buf 存放转换结果的字节数组。
         * @param offset 存放位置的偏移地址。
         */
        public final static void short2byte(int n, byte[] buf, int offset)
        {
            buf[offset] = (byte) (n >> 8);
            buf[offset + 1] = (byte) n;
        }
    
        /**
         * 长整型转换成字节。(网络字节序,高字节在前)
         *
         * @param n 长整数。
         * @return 长度为8的字节数组。
         */
        public final static byte[] long2byte(long n)
        {
            byte[] b = new byte[8];
            // b[0]=(byte)(n>>57); // comment by edong 20011203
            b[0] = (byte) (n >> 56);
            b[1] = (byte) (n >> 48);
            b[2] = (byte) (n >> 40);
            b[3] = (byte) (n >> 32);
            b[4] = (byte) (n >> 24);
            b[5] = (byte) (n >> 16);
            b[6] = (byte) (n >> 8);
            b[7] = (byte) n;
            return b;
        }
    
        /**
         * 长整型转换成字节。(网络字节序,高字节在前)
         *
         * @param n 长整数。
         * @param buf 存放转换结果的字节数组。
         * @param offset 存放位置的偏移地址。
         */
        public final static void long2byte(long n, byte[] buf, int offset)
        {
            // buf[offset]=(byte)(n>>57); // comment by edong
            // 20011203
            buf[offset] = (byte) (n >> 56);
            buf[offset + 1] = (byte) (n >> 48);
            buf[offset + 2] = (byte) (n >> 40);
            buf[offset + 3] = (byte) (n >> 32);
            buf[offset + 4] = (byte) (n >> 24);
            buf[offset + 5] = (byte) (n >> 16);
            buf[offset + 6] = (byte) (n >> 8);
            buf[offset + 7] = (byte) n;
        }
    
        // **************低字节在前*******************
    
        /**
         * 长整型转换成字节。(网络字节序,高字节在前)
         *
         * @param n 长整数。
         * @param buf 存放转换结果的字节数组。
         * @param offset 存放位置的偏移地址。
         * @author zhangyong 2004-05-27
         */
        public final static void Slong2byte(long n, byte[] buf, int offset)
        {
            buf[offset + 7] = (byte) (n >> 56);
            buf[offset + 6] = (byte) (n >> 48);
            buf[offset + 5] = (byte) (n >> 40);
            buf[offset + 4] = (byte) (n >> 32);
            buf[offset + 3] = (byte) (n >> 24);
            buf[offset + 2] = (byte) (n >> 16);
            buf[offset + 1] = (byte) (n >> 8);
            buf[offset] = (byte) n;
        }
    
        /**
         * 整型转换成字节。(网络字节序,低字节在前)
         *
         * @param iSource int 整数。
         * @param buf byte[] 存放转换结果的字节数组。
         * @param offset int 存放位置的偏移地址。
         * @return byte[]
         */
        static public byte[] inttobyte(int iSource, byte[] buf, int offset)
        {
            buf[offset] = (byte) iSource;
            buf[offset + 1] = (byte) (iSource >> 8);
            buf[offset + 2] = (byte) (iSource >> 16);
            buf[offset + 3] = (byte) (iSource >> 24);
            return (buf);
        }
    
        /**
         * 短整数转换成字节。(网络字节序,低字节在前)
         *
         * @param n 短整数。
         * @param buf 存放转换结果的字节数组。
         * @param offset 存放位置的偏移地址。
         * @author zhangyong 2004-05-27
         */
    
        public final static void shorttobyte(int n, byte[] buf, int offset)
        {
            buf[offset] = (byte) n;
            buf[offset + 1] = (byte) (n >> 8);
        }
    
        /**
         * 短整数转换成字节。(网络字节序,低字节在前)
         *
         * @param b byte[] 存放转换结果的字节数组。
         * @param offset int 存放位置的偏移地址。
         * @return int
         */
        public final static int bytetoshort(byte[] b, int offset)
        {
            return (b[offset] & 0xff) | ((b[offset + 1] & 0xff) << 8);
        }
    
        /**
         * 字节数组转换成整型。(网络字节序,低字节在前)
         *
         * @param b 字节数组。
         * @param offset 待转换字节开始的位置。
         * @return 整数形式。
         */
        public final static int bytetoint(byte[] b, int offset)
        {
            return (b[offset] & 0xff) | ((b[offset + 1] & 0xff) << 8) | ((b[offset + 2] & 0xff) << 16)
                    | ((b[offset + 3] & 0xff) << 24);
        }
    
        /**
         * 字节数组转换成整型。(网络字节序,低字节在前)
         *
         * @param b 字节数组。
         * @return 整数形式。
         */
        public final static int bytetoint(byte[] b)
        {
            return (b[0] & 0xff) | ((b[1] & 0xff) << 8) | ((b[2] & 0xff) << 16) | ((b[3] & 0xff) << 24);
        }
    
        /**
         * 字节数组转换成长整型。(网络字节序,低字节在前)
         *
         * @param b 字节数组。
         * @return 长整数形式。
         */
        public final static long bytetolong(byte[] b)
        {
            // System.out.println("typeconvert="+((int)b[7]));
            // System.out.println("typeconvert"+((int)b[6]));
            // System.out.println("typeconvert"+((int)b[5]));
            // System.out.println("typeconvert"+((int)b[4]));
            // System.out.println("typeconvert"+((int)b[3]));
            // System.out.println("typeconvert"+((int)b[2]));
            // System.out.println("typeconvert"+((int)b[1]));
            // System.out.println("typeconvert"+((int)b[0]));
            return ((long) b[0] & 0xff) | (((long) b[1] & 0xff) << 8) | (((long) b[2] & 0xff) << 16)
                    | (((long) b[3] & 0xff) << 24) | (((long) b[4] & 0xff) << 32) | (((long) b[5] & 0xff) << 40)
                    | (((long) b[6] & 0xff) << 48) | ((long) b[7] << 56);
        }
    
        /**
         * 字节数组转换成长整型。(网络字节序,高字节在前)
         *
         * @param b byte[] 字节数组。
         * @param offset int
         * @return long 长整数形式。
         */
        public final static long bytetolong(byte[] b, int offset)
        {
            return ((long) b[offset] & 0xff) | (((long) b[offset + 1] & 0xff) << 8) | (((long) b[offset + 2] & 0xff) << 16)
                    | (((long) b[offset + 3] & 0xff) << 24) | (((long) b[offset + 4] & 0xff) << 32)
                    | (((long) b[offset + 5] & 0xff) << 40) | (((long) b[offset + 6] & 0xff) << 48)
                    | ((long) b[offset + 7] << 56);
        }
    
       /* *//**
         * 二进制字符串转为字节数组
         *//*
        public final static byte[] binaryTobytes(String binary){
            if(binary==null){
            	return null;
            }
    
            while(binary.length()%8!=0){
            	binary=binary+"0";
            }
            int byteLen=binary.length()/8;
            byte[] desBytes=new byte[byteLen];
    
            String tmpstr=null;
            int tmpint=0;
            int offset=1;
            for(int i=0 ;i<byteLen;i++){
            	tmpstr=binary.substring(i*8,i*8+8);
            	System.out.println("转换之前的二进制字符串:"+tmpstr);
            	offset=1;
            	tmpint=0;
                for(int j=8;j>0;j--){
                	if(tmpstr.substring(j-1,j).equals("1")){
                		tmpint=tmpint+offset;
                	}
                	offset=offset*2;
                }
                System.out.println("转换之后的二进制字符串:"+Integer.toBinaryString(tmpint));
                desBytes[i]=(byte)tmpint;
     	    }
            return desBytes;
        }*/
    
        /**
         * 二进制字符串转为字节数组
         */
        public final static byte[] binaryTobytes(String binary){
            if(binary==null){
            	return null;
            }
    
            while(binary.length()%8!=0){
            	binary=binary+"0";
            }
            int byteLen=binary.length()/8;
            String s=null;
            byte b;
            ByteArrayOutputStream tmpOs=new ByteArrayOutputStream();
            for (int i = 0; i < byteLen;i++) {
    			s = binary.substring(i*8, i*8 + 8);
    			if (s.substring(0, 1).equals("1")) {
    				s = "0" + s.substring(1);
    				b = Byte.valueOf(s, 2);
    				b |= 128;
    			} else {
    				b = Byte.valueOf(s, 2);
    			}
    			tmpOs.write(b);
    		}
    		return tmpOs.toByteArray();
        }
    
        /**
         * 将字节数组内容按照二进制码打印出来
         *
         * @param buf byte[]
         * @return String
         */
        public final static String bytes2binary(byte[] buf)
        {
            int len = buf.length;
            StringBuilder chars = new StringBuilder();
            byte tmp;
            int inch = 0;
            int j;
            for (int i = 0; i < len; i++)
            {
                tmp = buf[i];
                //chars.append(' ');
                for (j = 7; j >= 0; j--)
                {
                    inch = ((tmp >> j) & 0x01);
                    if (inch == 0)
                    {
                        chars.append('0');
                    }
                    else
                    {
                        chars.append('1');
                    }
                }
            }
            return chars.substring(0);
        }
    
        public static byte[] des(String keys, String value) throws Exception{
        	if(keys.length() == 32) {
        		String s = keys.substring(0,16);
        		keys += s;
        	}
        	byte[] key = TypeConvert.hex2bytes(keys);
        	byte[] val = TypeConvert.hex2bytes(value);
        	if (key.length == 8) {
    			DESKeySpec desKey;
    			desKey = new DESKeySpec(key);
    			SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
    			SecretKey sKey = keyFactory.generateSecret(desKey);
    			Cipher cipher = Cipher.getInstance("DES/ECB/NoPadding");
    			cipher.init(Cipher.ENCRYPT_MODE, sKey);
    			return cipher.doFinal(val);
    		} else {
    			DESedeKeySpec desKey;
    			desKey = new DESedeKeySpec(key);
    			SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DESede");
    			SecretKey sKey = keyFactory.generateSecret(desKey);
    			Cipher cipher = Cipher.getInstance("DESede/ECB/NoPadding");
    			cipher.init(Cipher.ENCRYPT_MODE, sKey);
    			return cipher.doFinal(val);
    		}
        }
        /**
         * 敏感信息加* 处理
         * @param oldStr
         * @return string
         */
    	public static String coverString(String oldStr){
    		if(oldStr == null || oldStr.length() <= 0){
    			return oldStr;
    		}else{
    		   	int oldLen= oldStr.length();
    		   	int secrLen = oldLen/3 ;
    		   	String coverStr = oldStr.substring(oldLen/3, secrLen + oldLen/3);
    
    		   	StringBuffer str = new StringBuffer("");
    		   	for(int i=0;i<coverStr.length();i++){
    		   		str.append('*');
    		   	}
    
    			return oldStr.replace(coverStr, str);
    		}
    	}
    	 /**
         * 敏感信息加* 处理
         * @param oldStr
         * @return string
         */
    	public static String coverAllString(String oldStr){
    		if(oldStr == null || oldStr.length() <= 0){
    			return oldStr;
    		}else{
    			return oldStr.replaceAll(".", "*");
    		}
    	}
    
    }



    展开全文
  • ANSI字符:8位 Unicode字符:16位 ASCII码: 1、byte:字节,8bit位; 2、char:字符, java:2byte c++ :默认一般都是1byte 3、string

    ANSI字符:8位

    Unicode字符:16位

    ASCII码:

    1、byte:字节,8bit位;

    2、char:字符,

        java:2byte

        c++ :默认一般都是1byte

    3、string

    展开全文
  • JAVA byte 类型

    2019-09-27 14:39:25
    JAVA byte 类型 不管什么数据,计算机最终存储的是二进制的0和1,每个二进制占1位(bit); 因为最早是老美发明的计算机,英语的所有字符使用8位二进制就能都表征了,所以老美规定了8位等于1字节(byte); 即是最早的ASCII...
    • centos 6.5
    • CDH 5.15
    • JDK 1.8
    • hbase 1.2

    简介

    不管什么数据,计算机最终存储的是二进制的0和1,每个二进制占1位(bit);

    因为最早是老美发明的计算机,英语的所有字符使用8位二进制就能都表征了,所以老美规定了8位等于1字节(byte); 即是最早的ASCII编码;

    比如字母a,占用1字节,即8个位的二进制(01),ASCII编码就是0110 0001,二进制对人类不友好,于是用数学里的进制转换,将二进制转为十进制的97,十六进制的0x61;

    byte类型

    JAVA中提供了专门的byte类型,用来表示占1字节的数据,也就是ASCII码里的所有数据;

    8位可表征的数字范围是-128 ~ +127,超过这个范围会报错;
    1个字节只能表征1个字母,2个字母需要2个字节;

    public class Test
    {
        public static void main(String[] args)
        {
            byte byteB1 = 127;
            byte byteB2 = 'a';  //# 只能有单引号,双引号是字符串;
    
            System.out.print(byteB1); //# 127
            System.out.print(byteB2); //# 97 (a的ASCII码的十进制)
            System.out.print(byteToHex(byteB2)); //# 61 (a的ASCII码的十六进制)
    
            //# 强制类型转换,int(32位) 转 byte(8位),高低转低位,会发生精度丢失
            byte byteB3 = (byte) 18;
            System.out.print(byteB3); //# 18
        }
        /**
            # byte 类型转为 十六进制
            @ param b : byte类型的变量或数据
        */
        public static String byteToHex(byte b){
            String hex = Integer.toHexString(b & 0xFF);
            if(hex.length() < 2){
                hex = "0" + hex;
            }
            return hex;
        }
    }
    

    编译运行

    $ javac Test.java
    $ java Test
    

    byte类型有长度限制,不能表征复杂的数据;
    使用byte[]类型,没有长度限制;

    byte[] 类型

    JAVA还提供了byte[] 类型,表征字节数组;

    import java.util.Arrays;
    
    public class Test
    {
        public static void main(String[] args)
        {
            byte[] byteA = new byte[2]; //# [0, 0]
            byte[] byteA1 = new byte[] {1,2,3,4};
            byte[] byteA2 = {1,2,3,4};
            byte[] byteA3 = {'a','b','c','d'};
            byte[] byteA4 = {0x12,0x00,0x00,0x00,0x03,0x03};
    
            System.out.println(byteA); //# [B@7852e922  数组首个元素的内存地址
            System.out.println(Arrays.toString(byteA)); //# [0, 0]
            System.out.println(Arrays.toString(byteA1)); //# [1, 2, 3, 4]
            System.out.println(Arrays.toString(byteA2)); //# [1, 2, 3, 4]
            System.out.println(Arrays.toString(byteA3)); //# [97, 98, 99, 100]
            System.out.println(Arrays.toString(byteA4)); //# [18, 0, 0, 0, 3, 3]
    
            //# 将字节加入字节数组
            byte byteB1 = 127;
            byte byteB2 = 'a';
    
            byte[] byteA4 = new byte[2];
            byteA4[0] = byteB1;
            byteA4[1] = byteB2;
            System.out.println(Arrays.toString(byteA4)); //# [127, 97]
    
            byte[] byteA5 = {byteB1, byteB2};
            System.out.println(Arrays.toString(byteA5)); //# [127, 97]
    
        }
    }
    

    编译运行

    $ javac Test.java
    $ java Test
    

    16进制字节数组,使用0x标识

    import java.util.Arrays;
    public class Test
    {
        public static void main(String[] args)
        {
            byte[] rowKey = new byte[6];
            rowKey[0] = 0x12;
            rowKey[1] = 0x00;
            rowKey[2] = 0x00;
            rowKey[3] = 0x00;
            rowKey[4] = 0x03;
            rowKey[5] = 0x03;
    
            System.out.println(Arrays.toString(rowKey));
            //# [18, 0, 0, 0, 3, 3]
        }
    }
    

    编译运行

    $ javac Test.java
    $ java Test
    

    字符串转byte[]

    使用String类的方法getBytes;

    getBytes()读取file.encoding的编码格式,然后进行转换; 所以会受到系统的影响;

    import java.util.Arrays;
    
    public class Test
    {
        public static void main(String[] args)
        {
            //Original String
            String string = "hello world";
    
            //Convert to byte[]
            byte[] byteA = string.getBytes();
    
            System.out.println(Arrays.toString(byteA));
            //# [104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100]
        }
    }
    

    编译运行

    $ javac Test.java
    $ java Test
    

    Byte类

    Byte 类将基本类型为 byte 的值包装在一个对象中;
    一个 Byte 类的对象只包含一个类型为 byte 的字段;
    通过关键字new来申请对象;

    public class Test
    {
        public static void main(String[] args)
        {
            byte byteB1 = 5;
            byte byteB2 = 'a';
            Byte byteBC1 = new Byte(byteB1);
            Byte byteBC2 = new Byte(byteB2);
    
            Byte byteBC3 = new Byte("123"); //# 必须为数字类型的String,其他类型会报错
            //# Byte byteBC4 = new Byte("a"); //# 报错
    
            System.out.println(byteBC1); //# 5
            System.out.println(byteBC2); //# 97
            System.out.println(byteBC3); //# 123
        }
    }
    

    编译运行

    $ javac Test.java
    $ java Test
    

    常用方法

    方法返回值功能
    byteValue()byte以一个 byte 值返回 Byte 对象
    intValue()int以一个 int 值返回此 Byte 的值
    toString()String返回表示此 byte 值的 String 对象
    valueOf(String s)Byte返回一个保持指定 String 所给出的值的 Byte 对象
    decode(String nm)Byte将String转为Byte
    public class Test
    {
        public static void main(String[] args)
        {
            //# create 4 Byte objects
            Byte byteBC1, byteBC2, byteBC3, byteBC4;
    
            //# 将数字字符串转为Byte对象
            byteBC1 = Byte.decode("100");
    
            //# 将普通字符串转为Byte对象; 无法直接转,会报错;
            //# byteBC4 = Byte.decode("abcd");
    
            //# 将十六进制字符串转为Byte对象;
            //# 十六进制字符串的标识: 0x|0X|#
            byteBC2 = Byte.decode("-#4c");
    
            //# 将八进制字符串转为Byte对象;八进制标识:0
            byteBC3 = Byte.decode("0127");
    
            System.out.println(byteBC1); //# 100
            System.out.println(byteBC2); //# -76
            System.out.println(byteBC3); //# 87
        }
    }
    

    编译运行

    $ javac Test.java
    $ java Test
    

    HBase Bytes类

    HBase提供了一个工具类: Bytes, 提供了更强大和灵活的功能;

    常用方法

    方法返回值功能
    toBytes()byte[]将字符串转为byte[],编码使用utf8
    add()byte[]合并byte[]
    toString()string将byte[]转为字符串
    import java.util.Arrays;
    import org.apache.hadoop.hbase.util.Bytes;
    public class Test
    {
        public static void main(String[] args)
        {
            //Convert to byte[]
            byte[] byteBC = Bytes.toBytes("hello");
    
            System.out.println(Arrays.toString(byteBC));
            //# [104, 101, 108, 108, 111]
    
            System.out.println(Bytes.toString(byteBC));
            //# hello
        }
    }
    

    编译运行

    $ javac -cp $(hbase classpath) Test.java
    $ java -cp $(hbase classpath) Test
    

    参考
    org.apache.hadoop.hbase.util.Bytes
    Java.lang.Byte Class
    bit,byte,位,字节,汉字,字符

    展开全文
  • java ascii

    2013-01-15 17:17:51
    import org.junit.Test;...public class byte2ascii { public static char convertChar1(byte b) { return (char) b; } public static char convertChar2(byte b) { return (char) ((0xff & b)); } public

    import org.junit.Test;
    
    public class byte2ascii {
    	public static char convertChar1(byte b) {
    		return (char) b;
    	}
    
    	public static char convertChar2(byte b) {
    		return (char) ((0xff & b));
    	}
    
    	public static char convertChar3(byte b) {
    		return (char) ((0 | b));
    	}
    
    	@Test
    	public void test() {
    		byte b = 65;
    		System.out.println(convertChar1(b));
    		System.out.println(convertChar2(b));
    		System.out.println(convertChar3(b));
    	}
    	
    	// 打印ascii码
    	@Test
    	public void printCode(){
    	      for(byte b=0;b>=0 && b<128;b++){
    	          System.out.print("十进制数: "+ b + "  |  ");
    	          System.out.print("八进制数: "+ Integer.toOctalString(b) + "  |  ");
    	          System.out.print("十六进制数: "+ Integer.toHexString(b) + "  |  ");
    	          System.out.print("ASCII字符: "+(char)b);
    	          System.out.println();  
    	       }
    	}
    }
    展开全文
  • @Launcher:public string EncMsg(string Msg, string Key, out string EncMsg){int iResult;EncMsg = "";StringBuilder sbEncMsg = new StringBuilder...byte[] ret = new byte[3];byte[] curMsg;int processedLen =...
  • 这个东西讲起来很蹩脚.Java应用程序一般来讲在上层界面中都是...两个字节的字符对于经常做底层开发的人是比较讨厌的事情.底层开发一般都使用单字节的ascii码字符.在数据传输时将单字节的字符按照byte的方式进行传输.
  • import java.util.Arrays; /** * Created by XiChuan on 2018-11-07. */ public class TestMain { private static final char[] HEX_CHAR = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c'...
  • public class StringToAscii2 { public static byte[] ConvertToASCII(String string) { ... byte[] tmp = new byte[ch.length]; for (int i = 0; i < ch.length; i++) { tmp[i] = (byte) Intege.
  • java数据类型:byte

    2021-01-23 15:45:18
    java数据类型:byte byte数据类型为1个字节,8个比特位,最高位为符号位。在Java中,表示的数据范围为[-128~127]。 byteASCII 标准ASCII码也叫基础ASCII码,使用7位二进制数来表示所有的大小字母、写小写字母、...
  • Java byte的运算

    千次阅读 2018-06-24 12:56:23
    byte b1=1,b2=2,b3,b6; final byte b4=4,b5=6; b6=b4+b5; b3=(b1+b2); System.out.println(b3+b6); ... 被final修饰的变量是常量,这里的b6=b4+b5可以看成是b6=10... 而b1和b2是byte类型,java中进行计算时候将他...
  • JAVA ASCII码 读入字符串测试       public class RhzfYunTest {  public static void main(String[] args) {    int lenSize =6;  byte[] line = (byte[])null;  byte[] lenBuffer = new byte...
  • 您可以将ASCII编码用于7位字符String s =...byte[] b = s.getBytes("ASCII");System.out.println(new String(b, "ASCII"));或8位asciiString s = "Hello World! \u00ff";byte[] b = s.getBytes("ISO-8859-1");System...
  • JAVAASCII转码问题

    万次阅读 2009-12-13 10:45:00
    问题:我用java开发的,根据业务需要,要把字符集为asciibyte[],转为中文?如String chinaString = "你好";byte[] cascii = chinaString.getBytes("US-ASCII");有什么方法以将 byte[] cascii 里的内容,转为中文?...
  • rter; public class CoderUtils { /** * 将Ascii转换成中文字符串 */ public static String AsciiToChineseString ( String s ) ... byte[] dest = new byte[ orig.length ]; for
  • Java ascii to hex

    千次阅读 2014-03-21 18:47:35
    表达 数字的ascii string 转换回原始的数字 public static final byte[] toHex (byte hash[]) {  byte[] bytes = new byte[hash.length/2];  int i;  int j = 0;  int len = ((int)(hash.length /
  • java-byte-char

    2014-07-17 22:43:49
    java八种基本类型:byte、char、short、int、long、float、double、boolean。 其zho
  • java 字符与ASCII码互转

    2018-02-24 13:16:00
    字符转对应ASCII码 ...byte byteAscii = (byte) ch; System.out.println(byteAscii); // 方法二:将char直接转化为int,其值就是字符的ascii int byteAscii1 = (int) ch; System.out.printl...
  • java byte[] 学习总结

    万次阅读 2018-11-07 16:40:53
    byte表是字符,一个字节,8位,可以组成2^8=256中不同数字。byte存值范围: -128 - 127;  -128 -&gt; -1 在十六进制表示范围: 0x80 -&gt; 0xff ,在二进制表示范围:10000000 -&gt; 11...
  • Javabyte类型的范围

    2020-06-28 11:30:42
    char是Java中的保留字,与别的语言不同的是,char在Java中是16位的,因为Java用的是Unicode。不过8位的ASCII码包含在Unicode中,是从0~127的。 Java中使用Unicode的原因是,Java的Applet允许全世界范围内运行,那它...
  • java的char和byte

    2012-04-09 12:43:49
    java的char和byte,很简单的2种基本类型;java编程里很常用,但又不是很常用。有些java程序员还是没有真正理解byte和char。今天再来复习一下 byte:字节,占8位(bit)二进制,能表示的最大数字为2的8次方,含正负...
  • https://blog.csdn.net/qq_37131037/article/details/86566891 ... 1、数字 转ASCII 字符 System.out.print((char)Integer.parseInt(str)); 2、ASCII 字符 转数字...
  • JavaASCII码转String的方法~ 如下传入要转化的ASCII码数组即可; public static String AsciiToString(byte[] result2) { StringBuilder sbu = new StringBuilder(); for (byte b : result2) { if (0 == b)...
  • Java| Java中字节Byte和位Bit的关系

    千次阅读 2017-12-15 22:36:36
    Java中字节容量关系 1TB=1024GB TB是千千兆 1GB=1024MB GB是千兆 1MB=1024KB MB是兆 1KB=1024Byte KB是千字节 注意:Byte的缩写是B也就是字节 Byte(缩写B)月Bit(缩写b)的关系Byte:1B=8b 也就是说1字节等于8个...
  • java字符与对应Ascii码互转

    千次阅读 2017-10-10 16:05:59
    图题 代码如下: ...[java] view ... * Java中将一个字符与对应Ascii码互转   * 1 byte = 8bit 可以表示 0-127   */  public class GetCharAscii {     /*0-9对应Ascii 
  • javabyte转int 需要 &ff的原因。
  • 我们都知道,javabyte占用一个字节,short、char占用两个字节,但是byte、short、char在java底层中存储实际上32位的补码,只不过在定义变量的时候默认加上了一个强制类型转换来限制它的大小。 证明: 代码: ...
  • 分别保存前一个byte中的16进制两位的内容的ascii码。 事例 : byte[] a = {0x24,0xBD}; byte[] b = new byte[4]; 想得到的结果: b[0] == 0x32; b[1] == 0x34; b[2] == 0x42; b[3] == 0x44;
  • JAVAbyte转换为char存储

    万次阅读 2010-08-03 10:59:00
    从文件读取流中获取的数据为byte数组,其中部分值为大于127的ascii值,这样在向char数组中转换时符号位会出错,解决方法:如果该值大于127(也就是小于0),那么为该值加256,从而校正符号位。示例代码如下:  ...
  • byteASCII byte&amp;0xff的作用 int强转换为byte 二进制的原码、反码和补码 原码就是二进制定点表示法,即最高位为符号位,“0”表示正,“1”表示负,其余位表示数值的大小。 反码表示法规定:正数的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 48,050
精华内容 19,220
关键字:

byte比较ascii比较java

java 订阅