如何将远程传送过来的数据以16进制显示出来

Question

可能标题有点不对，是这样的。正在学习Socket编程，现在是远程的发送一串16进制数据过来如：
FE 68 88 88 88 88 88 88 68 A0 06 33 1D AB 89 67 45 D6 16
这样的形式。我在这边接收到后应该怎么样编程使它显示出来呢？应该用什么类来进行转换？请高手指教。

Answer 1

收到byte[]，每四位拼一个16进制数字显示不就行了么？

Answer 2

原来写过一个这样的程序，有兴趣的话可以执行一下，里面有个 main 方法的：import java.io.UnsupportedEncodingException;public class ByteOutput {    private final static char[] HEX = "0123456789ABCDEF".toCharArray();    private final static int LINE_CHARS = 80;    public static void main(String[] args) throws UnsupportedEncodingException {
        byte[] bys = "1324@!#$!#@QER!$#!asdf".getBytes();
        long t0, t1;
        t0 = System.nanoTime();
        String str = printByte(bys);
        t1 = System.nanoTime();
        System.out.println(str);
        System.out.println(t1 - t0);
    }    public static String printByte(byte[] bys) {
        int page = (bys.length + 16 - 1) / 16;
        char[] chs = init(page);
        System.arraycopy(HEADER, 0, chs, 0, HEADER.length);
        addLineNumber(chs, page);
        addLineSeparator(chs, page);
        addByte(chs, bys, page);
        return new String(chs);
    }    private static char[] init(int page) {
        char[] chs = new char[(page + 2) * LINE_CHARS];
        for(int i = 0; i < chs.length; i++) {
            if(i > LINE_CHARS * 2 && i % LINE_CHARS == LINE_CHARS - 20) {
                chs[i] = '|';
            } else {
                chs[i] = ' ';
            }
        }
        return chs;
    }    private static void addLineNumber(char[] chs, int page) {
        for(int i = 0; i < page; i++) {
            int k = (i + 2) * LINE_CHARS;
            for(int j = 0; j < 7; j++) {
                chs[k++] = HEX[(i >> ((6 - j) * 4)) & 0xf];
            }
            chs[k++] = '0';
            chs[k++] = ' ';
            chs[k++] = ':';
        }
    }    private static void addLineSeparator(char[] chs, int page) {
        int p = page + 2;
        for(int i = 1; i <= p; i++) {
            chs[i * LINE_CHARS - 1] = '\n';
        }
    }    private static void addByte(char[] chs, byte[] bys, int page) {
        for(int i = 0; i < page; i++) {
            int offset = i * 16;
            int c = offset + 16;
            int x = (i + 2) * LINE_CHARS + 11;
            int y = (i + 2) * LINE_CHARS + 63;
            while(offset < c && offset < bys.length) {
                chs[x++] = HEX[(bys[offset] >> 4) & 0xf];
                chs[x++] = HEX[bys[offset] & 0xf];
                chs[x++] = ' ';                chs[y] = (char)bys[offset];
                if(chs[y] < ' ') {
                    chs[y] = '.';
                }
                y++;
                offset++;
            }
        }
    }    private final static char[] HEADER =
        "           00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F  |  0123456789ABCDEF\n------------------------------------------------------------+------------------".toCharArray();
}
           00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F  |  0123456789ABCDEF
------------------------------------------------------------+------------------
00000000 : 61 64 73 66 71 77 65 72 31 33 32 34 20 31 32 31  |  adsfqwer1324 121
00000010 : 32 33 34 31 33 32 34 31 21                       |  23413241!

Answer 3

如果不想这么花里胡哨的话，可以使用这个（也是原来写的，有兴趣的话可以看一下）：/**
 * 字节工具类
 * 
 * @author bao110908
 * @since 2009-02-19
 */
public class ByteUtil {    private final static char[] HEX = "0123456789abcdef".toCharArray();
    
    public static void xor(byte[] base, byte[] data, int offset) {        
        for(int i = 0; i < base.length; i++) {
            base[i] ^= data[offset + i]; 
        }
    }    /**
     * 将字节数组转成 16 进制的字符串来表示，每个字节采用两个字符表表示，每个字节间采用
     * 一个空格分隔<br />
     * 采用实现较为高效的 bytes2Hex 方法
     * @param bys       需要转换成 16 进制的字节数组
     * @return
     * @deprecated
     */
    public static String bytes2Hex1(byte[] bys) {
        StringBuilder sb = new StringBuilder();
        for(int i = 0; i < bys.length; i++) {
            if(i > 0) {
                sb.append(" ");
            }
            sb.append(HEX[bys[i] >> 4 & 0xf]);
            sb.append(HEX[bys[i] & 0xf]);
        }
        return sb.toString();
    }    /**
     * 将字节数组转成 16 进制的字符串来表示，每个字节采用两个字符表表示，每个字节间采用
     * 一个空格分隔
     * @param bys       需要转换成 16 进制的字节数组
     * @return
     */
    public static String bytes2HexSpace(byte[] bys) {
        char[] chs = new char[bys.length * 2 + bys.length - 1];
        for(int i = 0, offset = 0; i < bys.length; i++) {
            if(i > 0) {
                chs[offset++] = ' ';
            }
            chs[offset++] = HEX[bys[i] >> 4 & 0xf];
            chs[offset++] = HEX[bys[i] & 0xf];
        }
        return new String(chs);
    }    /**
     * 将字节数组转成 16 进制的字符串来表示，每个字节采用两个字符表表示
     *
     * @param bys       需要转换成 16 进制的字节数组
     * @return
     */
    public static String bytes2Hex(byte[] bys) {
        char[] chs = new char[bys.length * 2];
        for(int i = 0, offset = 0; i < bys.length; i++) {
            chs[offset++] = HEX[bys[i] >> 4 & 0xf];
            chs[offset++] = HEX[bys[i] & 0xf];
        }
        return new String(chs);
    }    /**
     * 将字节数组转成 16 进制的字符串来表示，每个字节采用两个字符表表示，字节间没有分隔
     * 符。<br />
     * 采用实现较为高效的 bytes2Hex 方法
     * @param bys       需要转换成 16 进制的字节数组
     * @return
     * @deprecated
     */
    public static String bytes2Hex2(byte[] bys) {
        StringBuilder sb = new StringBuilder();
        for(int i = 0; i < bys.length; i++) {
            sb.append(HEX[bys[i] >> 4 & 0xf]);
            sb.append(HEX[bys[i] & 0xf]);
        }
        return sb.toString();
    }    public static byte[] int2BytesBE(int num) {
        byte[] bys = new byte[Integer.SIZE / Byte.SIZE];
        for(int i = 0, k = bys.length; i < k; i++) {
            bys[i] = (byte)(num >>> ((k - 1 - i) * Byte.SIZE) & 0xff);
        }
        return bys;
    }    public static byte[] int2BytesLE(int num) {
        return int2BytesBE(Integer.reverseBytes(num));
    }    /**
     * 采用 Big-Endian 方式将 long 数据转为 byte 数组
     *
     * @param num
     * @return  转为 Big-Endian 方式的 byte 数组
     */
    public static byte[] long2BytesBE(long num) {
        byte[] bys = new byte[Long.SIZE / Byte.SIZE];
        for(int i = 0, k = bys.length; i < k; i++) {
            bys[i] = (byte)(num >>> ((k - 1 - i) * Byte.SIZE) & 0xff);
        }
        return bys;
    }    /**
     * 采用 Little-Endian 方式将 long 数据转为 byte 数组
     *
     * @param num
     * @return  转为 Little-Endian 方式的 byte 数组
     */
    public static byte[] long2BytesLE(long num) {
        return long2BytesBE(Long.reverseBytes(num));
    }    /**
     * 将 Little-Endian 的字节数组转为 int 类型的数据<br />
     * Little-Endian 表示高位字节在高位索引中
     * @param bys       字节数组
     * @param start     需要转换的开始索引位数
     * @param len       需要转换的字节数量
     * @return  指定开始位置和长度以 LE 方式表示的 int 数值
     */
    public static int bytes2IntLE(byte[] bys, int start, int len) {
        return bytes2Int(bys, start, len, false);
    }    public static int bytes2IntLE(byte[] bys) {
        return bytes2Int(bys, 0, bys.length, false);
    }    /**
     * 将 Big-Endian 的字节数组转为 int 类型的数据<br />
     * Big-Endian 表示高位字节在低位索引中
     * @param bys       字节数组
     * @param start     需要转换的开始索引位数
     * @param len       需要转换的字节数量
     * @return  指定开始位置和长度以 BE 方式表示的 int 数值
     */
    public static int bytes2IntBE(byte[] bys, int start, int len) {
        return bytes2Int(bys, start, len, true);
    }    public static int bytes2IntBE(byte[] bys) {
        return bytes2Int(bys, 0, bys.length, true);
    }    /**
     * 将字节数组转为 Java 中的 int 数值
     * @param bys           字节数组
     * @param start         需要转换的起始索引点
     * @param len           需要转换的字节长度
     * @param isBigEndian   是否是 BE（true -- BE 序，false -- LE 序）
     * @return
     */
    private static int bytes2Int(byte[] bys, int start, int len,
            boolean isBigEndian) {
        int n = 0;
        for(int i = start, k = start + len % (Integer.SIZE / Byte.SIZE + 1); i < k; i++) {
            n |= (bys[i] & 0xff) << ((isBigEndian ? (k - i - 1) : i) * Byte.SIZE);
        }
        return n;
    }    /**
     * 将 Little-Endian 的字节数组转为 long 类型的数据<br />
     * Little-Endian 表示高位字节在高位索引中
     * @param bys       字节数组
     * @param start     需要转换的开始索引位数
     * @param len       需要转换的字节数量
     * @return  指定开始位置和长度以 LE 方式表示的 long 数值
     */
    public static long bytes2LongLE(byte[] bys, int start, int len) {
        return bytes2Long(bys, start, len, false);
    }    public static long bytes2LongLE(byte[] bys) {
        return bytes2Long(bys, 0, bys.length, false);
    }    /**
     * 将 Big-Endian 的字节数组转为 long 类型的数据<br />
     * Big-Endian 表示高位字节在低位索引中
     * @param bys       字节数组
     * @param start     需要转换的开始索引位数
     * @param len       需要转换的字节数量
     * @return  指定开始位置和长度以 BE 方式表示的 long 数值
     */
    public static long bytes2LongBE(byte[] bys, int start, int len) {
        return bytes2Long(bys, start, len, true);
    }    public static long bytes2LongBE(byte[] bys) {
        return bytes2Long(bys, 0, bys.length, true);
    }    private static long bytes2Long(byte[] bys, int start, int len,
            boolean isBigEndian) {
        long n = 0L;
        for(int i = start, k = start + len % (Long.SIZE / Byte.SIZE + 1); i < k; i++) {
            n |= (bys[i] & 0xffL) << ((isBigEndian ? (k - i - 1) : i) * Byte.SIZE);
        }
        return n;
    }
}