关键词Byte相关知识与实用类的深入理解（流操作，加密处理，图像处理等的基础准备）

关键词Byte相关知识与实用类的深入理解（流操作，加密处理，图像处理等的基础准备）

Byte,long,int,short,char,

( 1 )Byte的解说：

byte 关键字代表一种整型，该类型按下表所示存储值：

类型 范围 大小 .NET Framework 类型

byte

0 到 255

无符号 8 位整数

System.Byte

标识符

可如下例所示声明并初始化 byte 类型的变量：

byte myByte = 255;

在以上声明中，整数 255 从 int 隐式转换为 byte。如果整数超出了 byte 的范围，将产生编译错误。

转换

存在从 byte 到 short、ushort、int、uint、long、ulong、float、double 或 decimal 的预定义隐式转换。

不能将更大存储大小的非文本数值类型隐式转换为 byte。有关整型的存储大小的更多信息，请参见整型表（C# 参考）。例如，请看以下两个 byte 变量 x 和 y：

byte x = 10, y = 20; (会出错，因为该非文本数值类型存储大小大于byte)

以下赋值语句将产生一个编译错误，原因是赋值运算符右侧的算术表达式在默认情况下的计算结果为 int 类型。

// Error: conversion from int to byte:

byte z = x + y;

若要解决此问题，请使用强制转换：

// OK: explicit conversion:

byte z = (byte)(x + y);

但是，在目标变量具有相同或更大的存储大小时，使用下列语句是可能的：

int x = 10, y = 20;

int m = x + y; (正确，因为int类型存储大小大于int)

long n = x + y; (正确，因为long类型存储大小大于int)

同样，不存在从浮点型到 byte 类型的隐式转换。例如，除非使用显式强制转换，否则以下语句将生成一个编译器错误：

// Error: no implicit conversion from double:

byte x = 3.0;

// OK: explicit conversion:

byte y = (byte)3.0;

调用重载方法时，必须使用显式转换。以下面使用 byte 和 int 参数的重载方法为例：

public static void SampleMethod(int i) {}

public static void SampleMethod(byte b) {}

使用 byte 强制转换可保证调用正确的类型，例如：

// Calling the method with the int parameter:

SampleMethod(5);

// Calling the method with the byte parameter:

SampleMethod((byte)5);

( 2 )byte的实例

1.

把char类型转换成两个byte，第一个比特存unicode的第一个字节，第二个存unicode的第二个字节:

char a='a12335';
string s=Convert.ToString(a);
byte[] b=System.Text.Encoding.Unicode.GetBytes(s);//转为byte数组

2.

怎样把byte转换为char*类型的:

CString tt;
BYTE buf[100];
tt.Format(_T("%s"),buf);
char * kk=tt.GetBuffer(tt.GetLength());
上面是可以的
或者你也可以用strcpy.

3.

byte相关的处理类

一个处理BYTE和其它类型转换的类：

public class Tools{
//16进制
private static String HexCode[] = {
"0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
"a", "b", "c", "d", "e", "f"
};

private Tools(){
}

//将byte类型转换为16进制字符串
public static String byteToHexString(byte b){
int n = b;
if(n < 0)
n = 256 + n;
int d1 = n / 16;
int d2 = n % 16;
return HexCode[d1]+HexCode[d2];
}

//将byte数组转换为16进制字符串
public static String byteArrayToHexString(byte b[]){
String result = "";
for(int i = 0; i < b.length; i++)
result = result+byteToHexString(b[i]); ( 字符串并，注：不同于算术加 )
return result;
}

//将byte数组第offset个元素起的4个字节转换为int值
public 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;
}
//将byte数组转换为int值
public static int byte2int(byte b[])
{
return b[3] & 0xff | (b[2] & 0xff) << 8 | (b[1] & 0xff) << 16 | (b[0] & 0xff) << 24; ( << 位左移;假如传入1234式中可以看出 b[0] 为1, b[1] 为2, b[2] 为3, b[3] 为4, 返回的目标结果为:1234 ;从类byte2int，byte2long可以看出int为4个byte的长度, long为8个byte的长度, short为2个byte的长度)
}

//将byte数组转为long值
public static long byte2long(byte b[])
{
return (long)b[7] & (long)255 | ((long)b[6] & (long)255) << 8 | ((long)b[5] & (long)255) << 16 | ((long)b[4] & (long)255) << 24 | ((long)b[3] & (long)255) << 32 | ((long)b[2] & (long)255) << 40 | ((long)b[1] & (long)255) << 48 | (long)b[0] << 56;
}

//将byte数组第offset个元素起的8个字节转为long值
public static long byte2long(byte b[], int offset)
{
return (long)b[offset + 7] & (long)255 | ((long)b[offset + 6] & (long)255) << 8 | ((long)b[offset + 5] & (long)255) << 16 | ((long)b[offset + 4] & (long)255) << 24 | ((long)b[offset + 3] & (long)255) << 32 | ((long)b[offset + 2] & (long)255) << 40 | ((long)b[offset + 1] & (long)255) << 48 | (long)b[offset] << 56;
}

//将int类型转为byte数组
public 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;
}

/**
*n 为待转数据，buf[]为转换后的数据，offset为buf[]中转换的起始点
* 转换后数据从低到高位
*/
public 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;
}

public static byte[] short2byte(int n)
{
byte b[] = new byte[2];
b[0] = (byte)(n >> 8);
b[1] = (byte)n;
return b;
}

public static void short2byte(int n, byte buf[], int offset)
{
buf[offset] = (byte)(n >> 8);
buf[offset + 1] = (byte)n;
}

public static byte[] long2byte(long n)
{
byte b[] = new byte[8];
b[0] = (byte)(int)(n >> 56);
b[1] = (byte)(int)(n >> 48);
b[2] = (byte)(int)(n >> 40);
b[3] = (byte)(int)(n >> 32);
b[4] = (byte)(int)(n >> 24);
b[5] = (byte)(int)(n >> 16);
b[6] = (byte)(int)(n >> 8);
b[7] = (byte)(int)n;
return b;
}

public static void long2byte(long n, byte buf[], int offset)
{
buf[offset] = (byte)(int)(n >> 56);
buf[offset + 1] = (byte)(int)(n >> 48);
buf[offset + 2] = (byte)(int)(n >> 40);
buf[offset + 3] = (byte)(int)(n >> 32);
buf[offset + 4] = (byte)(int)(n >> 24);
buf[offset + 5] = (byte)(int)(n >> 16);
buf[offset + 6] = (byte)(int)(n >> 8);
buf[offset + 7] = (byte)(int)n;
}

}

*************************************************************************************

byte[] b = {00,00,00,00};
int i = ((b[0] << 24) + (b[1] << 16) + (b[2] << 8) + (b[3] << 0));
System.out.println(i);

System.out.println(Integer.parseInt(new String(b,0,4)));

结果：
都是由BYTE[]转换为INT，但
第一条打印语句得到结果:0
第二条出错，因为new String(b,0,4)为" "

原因如下：

（1）每四个byte可转换成一个int，因为int=4 byte

取出4个byte
int i = (int)b[0] | ((int)b[1] << 8) | ((int)b[2] << 16) | ((int)b[3] << 24);

上面用的是+
（2）0转换为字符串是\0，把二进制零转不成字符串的，因为\0是不可见的