byte数据的常用操作函数

最新推荐文章于 2024-04-28 08:34:32 发布
最新推荐文章于 2024-04-28 08:34:32 发布
阅读量1.2w 收藏 9
点赞数 1
分类专栏： C#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuekunge/article/details/8285703
版权 
/// <summary>
/// 本类提供了对byte数据的常用操作函数
/// </summary>
public class ByteUtil
{
private static char[] HEX_CHARS = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
private static byte[] BITS = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};


/// <summary>
/// 将字节数组转换为HEX形式的字符串, 使用指定的间隔符
/// </summary>
public static string ByteToHex(byte[] buf, string separator)
{
System.Text.StringBuilder sb = new System.Text.StringBuilder();
for(int i = 0;i < buf.Length;i++)
{
if (i > 0)
{
sb.Append(separator);
}
sb.Append(HEX_CHARS[buf[i] >> 4]).Append(HEX_CHARS[buf[i] & 0x0F]);
}
return sb.ToString();
}




/// <summary>
/// 将字节数组转换为HEX形式的字符串, 使用指定的间隔符
/// </summary>
public static string ByteToHex(byte[] buf, char c)
{
System.Text.StringBuilder sb = new System.Text.StringBuilder();
for(int i = 0;i < buf.Length;i++)
{
if (i > 0)
{
sb.Append(c);
}
sb.Append(HEX_CHARS[buf[i] >> 4]).Append(HEX_CHARS[buf[i] & 0x0F]);
}
return sb.ToString();
}


        /// <summary>
        /// 判断字节数组前几位是否符合一定规则
        /// </summary>
        /// <param name="data">需要判断的字节数组</param>
        /// <param name="pattern">匹配规则</param>
        /// <returns>如果匹配返回true</returns>
        public static bool IsMatch(byte[] data, params byte[] pattern)
        {
            if (data == null || data.Length < pattern.Length)
                return false;


            for(int i = 0;i < pattern.Length;i++)
            {
                if (data[i] != pattern[i])
                    return false;
            }
            return true;
        }


        /// <summary>
        /// 判断指定字节是否为列举的某个值
        /// </summary>
        /// <param name="value">需要判断的值</param>
        /// <param name="choice">可能值</param>
        /// <returns>如果与任一个可能值相等则返回true</returns>
        public static bool IsMatch(byte value, params byte[] choice)
        {
            if (choice == null || choice.Length == 0)
                return false;


            foreach(byte item in choice)
            {
                if (item == value)
                    return true;
            }
            return false;
        }




        /// <summary>
        /// 将字节数组转换为HEX形式的字符串, 没有间隔符
        /// </summary>
        public static string ByteToHex(byte[] buf)
{
return ByteToHex(buf, string.Empty);
}




/// <summary>
/// 将字节数组转换为HEX形式的字符串
/// 转换后的字符串长度为字节数组长度的两倍
/// 如: 1, 2 转换为 0102
/// </summary>
public static string ByteToHex(byte b)
{
return string.Empty + HEX_CHARS[b >> 4] + HEX_CHARS[b & 0x0F];
}




/// <summary>
/// 将字节流信息转换为HEX字符串
/// </summary>
public static string DumpBytes(byte[] bytes)
{
return DumpBytes(bytes, 0, bytes.Length);
}


/// <summary>
        /// 将字节流信息转换为HEX字符串
/// </summary>
public static string DumpBytes(byte[] bytes, int offset, int len)
{
   StringBuilder buf = new StringBuilder();
for(int i = 0;i < len;i++)
{
if (i == 0 || i % 16 == 0)
                    buf.AppendLine();
   
buf.Append(ByteToHex(bytes[i + offset]));
                buf.Append(' ');
}
            buf.AppendLine();
            return buf.ToString();
}




/// <summary>
/// 计算字节块的模256校验和
/// </summary>
public static byte SumBytes(byte[] bytes, int offset, int len)
{
int sum = 0;
for(int i = 0;i < len;i++)
{
sum += bytes[i + offset];
if (sum >= 256)
{
sum = sum % 256;
}
}
return (byte)sum;
}


/// <summary>
/// 计算字节块的模256双字节校验和(低位在前)
/// </summary>
public static byte[] Sum2Bytes(byte[] bytes, int offset, int len)
{
int sum = 0;
for(int i = 0;i < len;i++)
sum += bytes[i + offset];
            return new byte[] { (byte)(sum % 256), (byte)(sum / 256) };
}


/// <summary>
/// 计算字节块的异或校验和
/// </summary>
public static byte XorSumBytes(byte[] bytes, int offset, int len)
{
byte sum = bytes[0 + offset];
for(int i = 1;i < len;i++)
{
sum = (byte)(sum ^ bytes[i + offset]);
}
return sum;
}




/// <summary>
/// 计算字节块的异或校验和
/// </summary>
public static byte XorSumBytes(byte[] bytes)
{
return XorSumBytes(bytes, 0, bytes.Length);
}




/// <summary>
/// 比较两个字节块是否相等。相等返回true否则false
/// </summary>
public static bool CompareBytes(byte[] bytes1, int offset1, byte[] bytes2, int offset2, int len)
{
for(int i = 0;i < len;i++)
{
if (bytes1[i + offset1] != bytes2[i + offset2])
{
return false;
}
}
return true;
}


/// <summary>
/// 将两个字符的hex转换为byte
/// </summary>
public static byte HexToByte(char[] hex, int offset)
{
byte result = 0;
for(int i = 0;i < 2;i++)
{
char c = hex[i + offset];
byte b = 0;
switch (c)
{
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
b = (byte)(c - '0');
break;
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
b = (byte)(10 + c - 'A');
break;
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
b = (byte)(10 + c - 'a');
break;
}
if (i == 0)
{
b = (byte)(b * 16);
}
result += b;
}


return result;
}


/// <summary>
/// 将两个字符的hex转换为byte
/// </summary>
public static byte HexToByte(byte[] hex, int offset)
{
char[] chars = {(char)hex[offset], (char)hex[offset + 1]};
return HexToByte(chars, 0);
}


        /// <summary>
        /// 转换16进制字符串为字节数组
        /// <param name="hex">有分隔或无分隔的16进制字符串，如“AB CD EF 12 34...”或“ABCDEF1234...”</param>
        /// <param name="dot">任意分隔字符，但不能是16进制字符</param>
        /// <returns>字节数组</returns>
        /// </summary>
        public static byte[] HexToByte(string hex, params char[] dot) {
            char[] ca = new char[2];
            List<byte> list = new List<byte>();
            for (int i = 0, n = 0; i < hex.Length; i++) {
                if (Array.IndexOf<char>(dot, hex[i]) >= 0) {
                    continue;
                }


                switch (++n) {
                    case 1:
                        ca[0] = hex[i];
                        break;


                    case 2:
                        ca[1] = hex[i];
                        list.Add(ByteUtil.HexToByte(ca, 0));
                        n = 0;
                        break;
                }
            }


            return list.ToArray();
        }


/// <summary>
/// 将uint变量分解为四个字节。高位在前。
/// </summary>
public static void UintToBytes(uint i, byte[] bytes, int offset)
{
bytes[offset] = (byte)((i & 0xFF000000) >> 24);
bytes[offset + 1] = (byte)((i & 0x00FF0000) >> 16);
bytes[offset + 2] = (byte)((i & 0x0000FF00) >> 8);
bytes[offset + 3] = (byte)(i & 0x000000FF);
}


        /// <summary>
        /// 将uint变量分解为四个字节。高位在前。
        /// </summary>
        public static byte[] UintToBytes(uint i)
        {
            byte[] bytes = new byte[4];
            bytes[0] = (byte)((i & 0xFF000000) >> 24);
            bytes[1] = (byte)((i & 0x00FF0000) >> 16);
            bytes[2] = (byte)((i & 0x0000FF00) >> 8);
            bytes[3] = (byte)(i & 0x000000FF);
            return bytes;
        }


        /// <summary>
        /// 将int变量分解为四个字节。高位在前。
        /// </summary>
        public static byte[] IntToBytes(int i)
        {
            byte[] data = BitConverter.GetBytes(i);
            Array.Reverse(data);
            return data;


            //byte[] bytes = new byte[4];
            //bytes[0] = (byte)((i & 0xFF000000) >> 24);
            //bytes[1] = (byte)((i & 0x00FF0000) >> 16);
            //bytes[2] = (byte)((i & 0x0000FF00) >> 8);
            //bytes[3] = (byte)(i & 0x000000FF);
            //return bytes;
        }


/// <summary>
/// 将四个字节合成为一个int
/// </summary>
public static uint BytesToUint(byte[] bytes, int offset)
{
uint a = ((uint)bytes[offset]) << 24;
uint b = ((uint)bytes[offset + 1]) << 16;
uint c = ((uint)bytes[offset + 2]) << 8;
uint d = bytes[offset + 3];
return a + b + c + d;
}


        /// <summary>
        /// 将ulong变量分解为八个字节。高位在前。
        /// </summary>
        public static byte[] UlongToBytes(ulong i)
        {
            byte[] bytes = new byte[8];
            bytes[0] = (byte)((i & 0xFF00000000000000) >> 56);
            bytes[1] = (byte)((i & 0x00FF000000000000) >> 48);
            bytes[2] = (byte)((i & 0x0000FF0000000000) >> 40);
            bytes[3] = (byte)((i & 0x000000FF00000000) >> 32);
            bytes[4] = (byte)((i & 0x00000000FF000000) >> 24);
            bytes[5] = (byte)((i & 0x0000000000FF0000) >> 16);
            bytes[6] = (byte)((i & 0x000000000000FF00) >> 8);
            bytes[7] = (byte)(i & 0x00000000000000FF);
            return bytes;
        }


        /// <summary>
        /// 将八个字节合成为一个ulong
        /// </summary>
        public static ulong BytesToUlong(byte[] bytes, int offset)
        {
            ulong a = ((ulong)bytes[offset]) << 56;
            ulong b = ((ulong)bytes[offset + 1]) << 48;
            ulong c = ((ulong)bytes[offset + 2]) << 40;
            ulong d = ((ulong)bytes[offset + 3]) << 32;
            ulong e = ((ulong)bytes[offset + 4]) << 24;
            ulong f = ((ulong)bytes[offset + 5]) << 16;
            ulong g = ((ulong)bytes[offset + 6]) << 8;
            ulong h = bytes[offset + 7];
            return a + b + c + d + e + f + g + h;
        }




/// <summary>
/// 设置某个字节的指定位
/// </summary>
/// <param name="b">需要设置的字节</param>
/// <param name="pos">1-8, 1表示最低位, 8表示最高位</param>
/// <param name="on">true表示设置1, false表示设置0</param>
public static void ByteSetBit(ref byte b, int pos, bool on)
{
int temp = BITS[pos - 1];


if (!on)
{
//取反
temp = temp ^ 0xFF;
}


b = (byte)(on?(b | temp):(b & temp));
}


/// <summary>
/// 判断某个byte的某个位是否为1
/// </summary>
        /// <param name="pos">第几位，大于等于1</param>
public static bool ByteGetBit(byte b, int pos)
{
int temp = BITS[pos - 1];
return (b & temp) != 0;
}




/// <summary>
/// 设置双比特值
/// </summary>
/// <param name="b">需要设置的字节</param>
/// <param name="low">低位, 1-7</param>
/// <param name="val">值，0-3</param>
/// <returns></returns>
public static void ByteSetBitPair(ref byte b, int low, int val)
{
if (low < 1 || low > 7)
{
throw new ArgumentException(string.Format("无效的low值:{0}", low));
}


switch(val)
{
case 0:
{
ByteUtil.ByteSetBit(ref b, low, false);
ByteUtil.ByteSetBit(ref b, low + 1, false);
break;
}
case 1:
{
ByteUtil.ByteSetBit(ref b, low, true);
ByteUtil.ByteSetBit(ref b, low + 1, false);
break;
}
case 2:
{
ByteUtil.ByteSetBit(ref b, low, false);
ByteUtil.ByteSetBit(ref b, low + 1, true);
break;
}
case 3:
{
ByteUtil.ByteSetBit(ref b, low, true);
ByteUtil.ByteSetBit(ref b, low + 1, true);
break;
}
default:
{
throw new ArgumentException(string.Format("无效的val值:{0}", val));
}
}
}




/// <summary>
/// 读取双比特值
/// </summary>
/// <param name="b">需要读取的字节</param>
/// <param name="low">低位, 0-6</param>
/// <returns>0-3</returns>
public static byte ByteGetBitPair(byte b, int low)
{
if (low < 0 || low > 7)
{
throw new ArgumentException(string.Format("无效的low值:{0}", low));
}


int x = 0;
x += ByteUtil.ByteGetBit(b, low)?1:0;
x += ByteUtil.ByteGetBit(b, low + 1)?2:0;


return (byte)x;
}


/// <summary>
/// 将short转换为两个字节
/// </summary>
/// <param name="s"></param>
/// <returns></returns>
public static byte[] ShortToByte(short s)
{
return UshortToByte((ushort)s);
}


/// <summary>
/// 将ushort转换为两个字节
/// </summary>
public static byte[] UshortToByte(ushort u)
{
return new byte[]{
(byte)(u >> 8),
(byte)(u & 0x00FF)
};
}


/// <summary>
/// 将两个字节转换为一个short
/// </summary>
public static short BytesToShort(byte[] data, int offset)
{
short a = data[offset], b = data[offset + 1];
return (short)((a << 8) + b);
}


        /// <summary>
        /// 将两个字节转换为一个short
        /// </summary>
        public static ushort BytesToUshort(byte[] data, int offset)
        {
            ushort a = data[offset], b = data[offset + 1];
            return (ushort)((a << 8) + b);
        }
   
   /// <summary>
   /// 将四个字节转换为int
   /// </summary>
   /// <param name="data"></param>
   /// <param name="offset"></param>
   /// <returns></returns>
   public static int BytesToInt(byte[] data, int offset)
   {
            return (data[offset] << 24) + (data[offset + 1] << 16) + (data[offset + 2] << 8) + data[offset + 3];
   }


        /// <summary>
        /// 将guid字符串转换为等价的16维字节数组
        /// </summary>
        public static byte[] GuidToBytes(string s)
        {
            byte[] guid = new byte[16];
            char[] hex = s.Replace("-", string.Empty).Replace(" ", string.Empty).ToCharArray();
            for (int i = 0; i < 32; i += 2)
            {
                guid[i / 2] = ByteUtil.HexToByte(hex, i);
            }
            return guid;
        }


        /// <summary>
        /// CRC16校验表
        /// </summary>
        static ushort[] wCRCTalbeAbs = {0x0000, 0xCC01, 0xD801, 0x1400, 0xF001, 0x3C00, 0x2800, 0xE401, 0xA001, 0x6C00, 0x7800, 0xB401, 0x5000, 0x9C01, 0x8801, 0x4400};


        /// <summary>
        /// 计数字节块的CRC16校验值
        /// </summary>
        public static int CRC16Bytes(byte[] bytes, int offset, int len)
        {
                int wCRC = 0xFFFF;
                byte chChar;


                for (int i = offset; i < len; i++)
                {
                        chChar = bytes[i];
                        wCRC = wCRCTalbeAbs[(chChar ^ wCRC) & 15] ^ (wCRC >> 4);
                        wCRC = wCRCTalbeAbs[((chChar >> 4) ^ wCRC) & 15] ^ (wCRC >> 4);
                }


                return wCRC;
        }


        /// <summary>
        /// 字节格式化，将字节转换为字节、KB、MB、GB显示
        /// </summary>
        /// <param name="bytes">字节数</param>
        /// <returns>格式化后的字符串</returns>
        public static string ByteFormater(long bytes)
        {
            const long KB = 1024;
            const long MB = 1024 * 1024;
            const long GB = 1024 * 1024 * 1024;


            if (bytes >= GB)
            {
                double result = bytes * 1.0 / GB;
                return result.ToString("#,##0.0") + "GB";
            }
            if (bytes >= MB)
            {
                double result = bytes * 1.0 / MB;
                return result.ToString("#,##0.0") + "MB";
            }
            if (bytes >= KB)
            {
                double result = bytes * 1.0 / KB;
                return result.ToString("#,##0.0") + "KB";
            }
            return bytes.ToString("#,##0") + "字节";
        }
    }


敌敌畏耶
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C语言常用函数归纳.doc
12-03
C语言常用函数归纳 C语言提供了许多库函数，用于实现各种功能，本文将对常用C语言函数进行归纳和总结。 1.absread()函数 absread()函数用于从指定的驱动器磁盘上读取扇区的内容。函数原形为：int absread(int ...
C#常用自定义函数小结
09-04
这个功能在处理数据展示或者数据存储时经常遇到。以下是一个简单的实现： ```csharp /// /// 将数组转成字符串 /// /// 分隔符 /// 要字符串数组 private string Implode(char glue, string[] pieces) { string ...
bytes函数
anglanqiang2798的博客
01-31 227
# source是字符串，则使用str.encode()转换 b = bytes('abc',encoding='utf-8',errors='strict') print(b,b[0]) # bytes对象不可变 try: b[0] = 100 except TypeError as err: print('it is immutable.so...
Python bytes()函数
全村的希望的博客
10-31 7499
描述： 返回一个新的“bytes”对象，它是0<=x<256范围内的不可变整数序列。字节是bytearray的一个不可变的版本，它具有相同的非突变方法和相同的索引和切片行为。 语法： class bytes([source[, encoding[, errors]]]) 参数介绍： 可选的source参数可用于以几种不同的方式初始化数组： 如果它是一个字符串，则还必须提供e...
byte[]处理
最新发布
qq_31532979的博客
04-28 206
可能更为合适，因为它们提供了更灵活的添加、删除元素以及自动调整容量的功能。方法来高效地复制原数组的内容到新数组。然后，我们直接通过索引赋值将新字节添加到新数组的相应位置。表示一个字节数组，它是一个可以存储一串字节（每个字节8位）的容器。如果您需要经常在数组中间插入或删除元素，或者对数组大小的变化无法提前预知，使用。类型是不可变的，所以不能直接在其上添加字节。数组，以容纳原数组中的所有元素以及要添加的新字节。将原数组中的所有元素复制到新数组。使用新数组替换原数组（如果需要）。在新数组的适当位置插入新的。
内置函数bytes()
weixin_30703911的博客
06-24 586
a=b'\x00\x9c@c' print a[3]#99,c的ascii码是99 print a[1]#156 并且byte是无法修改的 c[1]=155 Traceback (most recent call last): File "<pyshell#6>", line 1, in <module> c[1] = 15...
mysql byte函数_mysql常见函数
weixin_33099377的博客
01-21 367
进阶4：常见函数/*概念：类似于java的方法，将一组逻辑语句封装在方法体中，对外暴露方法名好处：1、隐藏了实现细节 2、提高代码的重用性调用：select 函数名(实参列表) 【from 表】;特点：①叫什么(函数名)②干什么(函数功能)分类：1、单行函数如 concat、length、ifnull等2、分组函数功能：做统计使用，又称为统计函数、聚合函数、组函数常见函数：一、单行函数字符函数：...
字节操作函数
weixin_30446197的博客
04-06 185
一、类型 　　（1）以空字符结尾的C字符串是由在<string.h>头文件中定义、名字以str开头的函数处理的； 　　（2）名字以b开头的第一组函数起源于4.2BSD，几乎所有现今支持套接字函数的系统仍然提供它们； 　　（3）名字以men开头的第二组函数起源于ANSI C标准，支持ANSI C函数库的所有系统都提供它们 二、源自Berkeley的函数　 #inc...
SAS软件常用函数 sas数据分析软件常用函数整理总结.pdf
07-02
SAS软件常用函数 SAS软件是一种功能强大且广泛应用于数据分析和商业智能的软件，它提供了许多实用的函数来处理和分析数据。下面是SAS软件常用函数的总结。 数学函数 数学函数是SAS软件中最基本的函数之一，用于...
vb常用函数
02-19
"VB常用函数详解" 本文档将对 VB 中常用的函数进行详细的解释，包括日期和时间函数、数学函数、字符串处理函数、数据类型转换函数、注册表读写函数等。 日期和时间函数 * Time 函数：返回系统时钟的当前时间。 * ...
VB常用函数大全.pdf
10-09
"VB常用函数大全" VB 编程语言提供了丰富的函数库，用于实现各种功能。本文档将对 VB 中常用的函数进行分类和解释，涵盖类型转换函数、日期和时间函数、目录和文件函数、交互式函数、数学函数和颜色函数等六大类。 ...
字节处理函数
liuchao1986105的专栏
05-28 1805
字节处理函数 Socket地址是多字节数据，不是以空字符结尾的，这和C语言中的字符串是不同的。Linux提供了两组函数来处理多字节数据，一组以 b（byte）开头，是和BSD系统兼容的函数，另一组以mem（内存）开头，是ANSI C提供的函数。 以b开头的函数有： （1） void bzero（void * s,int n）：将参数s指定的内存的前n个字节设置为0，通常它用来将套接字地址清0。 （2） void bcopy（const void * src，void * dest，i
字节操纵函数
We_are_family678的博客
05-09 388
bytes.buffer详解
Zerore的博客
05-15 1488
Buffer
图片获取字节数组byte[]data, 将字节数组转换为String,之后再由String转换为byte[]data,会发现不同
马世豪
12-28 1865
servlet访问数据库(MySql)获取一张图片的字节数组byte[]data. 将字节数组转换为String类型, 说一下为什么要转换为String呢? JSON所能够发送的数据类型 1、Number 在JavaScript中的双精度浮点格式  2、String 双引号的反斜杠转义的Unicode  3、Boolean true 或 false  4、Array 值的
byte[]获取实际长度的方法
热门推荐
键盘侠_HUT
05-03 3万+
一般我们的写法是 byte[] byteArray = new byte[128或者256或者1024],但是我们压根用不了这个多,在实际的操作中也比较麻烦,下面的方法可以获取当前的byteArray的有效长度和实际有多少个值./** * 获取byte的实际长度 * @param bytes * @return */public int getValidLength(byte[] byt...
C#调用C++封装的dll返回字符串
cst1234567的博客
09-15 3118
最近在做C#调用c++封装的dll时，我用的qt封装的，由于编码问题（Windows默认GB2312，qt默认UTF-8），所以用ref string和char*交互时，返回的字符串经过编码转换后总有一部分汉字转过来还是乱码，后来经过网上查找，测试，发现了两种返回字符串的方法，记录一下。
byte类型与各种基础类型之间的相互转化函数总结
心若向阳，无谓悲伤的博客
05-26 9502
这几天在做一个通讯协议，需要byte类型与各种类型之间相互转化，为了便于以后用到的时候查看，特此记录。 import java.io.ByteArrayOutputStream; import android.util.Log; /* * 用于各种类型，进制与byte之间的转换 * * */ public class ByteUtils { private static
CRC8算法的解读，以及在E2E通信保护的应用
蚂蚁小兵
06-30 6821
CRC8算法的解读，以及在E2E通信保护的应用
在stm32中书写函数获取温湿度数据
06-01
在STM32中获取温湿度数据通常需要使用传感器，比如常用的DHT11或者DHT22。以下是获取DHT11传感器数据的函数示例： ```c #include "dht11.h" #define DHT11_GPIO_PORT GPIOB #define DHT11_GPIO_PIN GPIO_PIN_12 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值