关于java中byte

简单介绍：

a,1字节==8比特，在计算机中，一个字节，是用8个‘1’和‘0’比特表示的；

b,byte的数值范围是从-128~127，即“1000 0000” ~ “0111 1111”；

c,正数的比特值（二进制表示）可以用2的多少次幂算出来，但是，负数的不行；

d,负数的二进制表示，是通过，负数的绝对值的二进制取反加一获得，即-10—>10—>0000 1010—>1111 0101 + 0000 0001—>1111 0110（即-10在计算机中存储的形式就是1111 0110）；

方法介绍：

以下是一个类，介绍byte数组与java类型直接的转换。

package com.xg.bytest;

import java.nio.charset.Charset;

public class ByteUtil {
	public static byte[] getBytes(short data) {
		byte[] bytes = new byte[2];
		bytes[0] = (byte) (data & 0xff);
		bytes[1] = (byte) ((data & 0xff00) >> 8);
		return bytes;
	}

	public static byte[] getBytes(char data) {
		byte[] bytes = new byte[2];
		bytes[0] = (byte) (data);
		bytes[1] = (byte) (data >> 8);
		return bytes;
	}

	public static byte[] getBytes(int data) {
		byte[] bytes = new byte[4];
		bytes[0] = (byte) (data & 0xff);
		bytes[1] = (byte) ((data & 0xff00) >> 8);
		bytes[2] = (byte) ((data & 0xff0000) >> 16);
		bytes[3] = (byte) ((data & 0xff000000) >> 24);
		return bytes;
	}

	public static byte[] getBytes(long data) {
		byte[] bytes = new byte[8];
		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);
		return bytes;
	}

	public static byte[] getBytes(float data) {
		int intBits = Float.floatToIntBits(data);
		return getBytes(intBits);
	}

	public static byte[] getBytes(double data) {
		long intBits = Double.doubleToLongBits(data);
		return getBytes(intBits);
	}

	public static byte[] getBytes(String data, String charsetName) {
		Charset charset = Charset.forName(charsetName);
		return data.getBytes(charset);
	}

	public static byte[] getBytes(String data) {
		return getBytes(data, "GBK");
	}

	public static short getShort(byte[] bytes) {
		return (short) ((0xff & bytes[0]) | (0xff00 & (bytes[1] << 8)));
	}

	public static char getChar(byte[] bytes) {
		return (char) ((0xff & bytes[0]) | (0xff00 & (bytes[1] << 8)));
	}

	public static int getInt(byte[] bytes) {
		return (0xff & bytes[0]) | (0xff00 & (bytes[1] << 8)) | (0xff0000 & (bytes[2] << 16))
				| (0xff000000 & (bytes[3] << 24));
	}

	public static long getLong(byte[] bytes) {
		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));
	}

	public static float getFloat(byte[] bytes) {
		return Float.intBitsToFloat(getInt(bytes));
	}

	public static double getDouble(byte[] bytes) {
		long l = getLong(bytes);
		System.out.println(l);
		return Double.longBitsToDouble(l);
	}

	public static String getString(byte[] bytes, String charsetName) {
		return new String(bytes, Charset.forName(charsetName));
	}

	public static String getString(byte[] bytes) {
		return getString(bytes, "GBK");
	}

	/*
	 *  将byte[]转化十六进制的字符串
	 *  使用b[i]&0xFF的原因
	 *  1,byte的大小为8bits而int的大小为32bits
	 *  2,如果换成b[i]&0xFFFF，则会造成误差，具体是怎样的误差，还不清楚。
	 *  0xff默认是整形，但ff只有8位，所以前面的24位全为0，
	 *  一个byte跟0xff(相当于0x000000ff)相与会先将那个byte转化成整形运算，
	 *  这样，结果中的高的24个比特就总会被清0，于是结果总是我们想要的。
	 *  如果是0xffff，则只有16位被清零
	 */	
	public static String bytes2HexString(byte[] b) {
		String ret = "";
		for (int i = 0; i < b.length; i++) {
			String hex = Integer.toHexString(b[i] & 0xFF);
//			System.out.println(i + "--" + hex);
			if (hex.length() == 1) {
				hex = '0' + hex;
			}
			ret += hex.toUpperCase();
		}
		return ret;
	}

	public static void main(String[] args) {
		short s = 123;
		int i = 123;
		long l = 123456789;

		char c = 'a';

		float f = 123.456f;
		double d = 122.22;

		System.out.println(bytes2HexString(getBytes("abcdsstring")));
		String string = "第一次测试byte";
		System.out.println(getString(getBytes(string)));
		 System.out.println(s);
		 System.out.println(i);
		 System.out.println(l);
		 System.out.println(c);
		 System.out.println(f);
		 System.out.println(d);
		 System.out.println(string);
		
		 System.out.println("**************");
		
		 System.out.println(getShort(getBytes(s)));
		 System.out.println(getInt(getBytes(i)));
		 System.out.println(getLong(getBytes(l)));
		 System.out.println(getChar(getBytes(c)));
		 System.out.println(getFloat(getBytes(f)));
		 System.out.println(getDouble(getBytes(d)));
		 System.out.println(getString(getBytes(string)));

		byte b = -10;
		System.out.println("toBinaryString--->" + Integer.toBinaryString(b));
		System.out.println("toBinaryString--->" + Integer.toBinaryString(0xffff));
		System.out.println("toBinaryString--->" + Integer.toBinaryString(b & 0xff));
		System.out.println("toOctalString--->" + Integer.toOctalString(b));
		// System.out.println(Integer.parseInt("11110110"));
		// System.out.println(Byte.valueOf("11110110", 2));
		// System.out.println(Integer.valueOf("11110110", 2));

	}
}

整型与byte类型之间转换的一些方法介绍

//		十进制转成十六进制： 
		Integer.toHexString(int i) 
//		十进制转成八进制 
		Integer.toOctalString(int i) 
//		十进制转成二进制 
		Integer.toBinaryString(int i) 
//		十六进制转成十进制 
		Integer.valueOf("FFFF",16).toString() 
//		八进制转成十进制 
		Integer.valueOf("876",8).toString() 
//		二进制转十进制 
		Integer.valueOf("0101",2).toString() 

//		有什么方法可以直接将2,8,16进制直接转换为10进制的吗? 
		java.lang.Integer类 
		parseInt(String s, int radix) 
//		使用第二个参数指定的基数，将字符串参数解析为有符号的整数。 
		examples from jdk: 
		parseInt("0", 10) returns 0 
		parseInt("473", 10) returns 473 
		parseInt("-0", 10) returns 0 
		parseInt("-FF", 16) returns -255 
		parseInt("1100110", 2) returns 102 
		parseInt("2147483647", 10) returns 2147483647 
		parseInt("-2147483648", 10) returns -2147483648

还有些需要琢磨的，现在想不起来，等以后遇到再记录吧。