一、理解位运算

要学会位运算,首先要清楚什么是位运算?程序中的所有内容在计算机内存中都是以二进制的形式储存的(即:0或1),位运算就是直接对在内存中的二进制数的每位进行运算操作

二、理解数字进制

上面提到了二进制,除了二进制,我们还有很多的进制,下面列举一些常见的进制

10进制数:0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20 (每位满10进1,同时低位补0)
2进制数:00000,00001,00010,00011,00100,00101,00110,00111,01000,01001,01010,01011,01100,01101,01110,01111,10000,10001,10010,10011,10100 (每位满2进1,同时低位补0)
8进制数:00,01,02,03,04,05,06,07,10,11,12,13,14,15,16,17,20,21,22,23,24 (每位满8进1,同时低位补0)
16进制数:0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14 (每位满16进1,10~15由A~F字母表示,同时低位补0)

2进制、8进制、16进制、32进制、64进制等转换成10进制计算方法我得出一个公式:(^表示次方,如:2^2,即2的2次方,8^5即8的5次方)

每位数字转换成10进制时=进制数^(次方)数字索引位(从0开始计算)*数字

计算示例:(注意黑粗体字)

2进制数:10100=2^0*0+2^1*0+2^2*1+2^3*0+2^4*1=0+0+4+0+16=20

8进制数:24=8^0*4+8^1*2=4+16=20

16进制数:0x14(注意0x是用来表示16进制数的意思,不是数字本身的内容)=16^0*4+16^1*1=4+16=20

至于各进制之间的转换,比如:2进制转换成16进制,如果想自己手算,一般都是先转成10进制,然后将数字进行与进制数相除,直到得出余数小于或等于进制数(或0),当然作为程序员的我们,应该使用现有的方法,如下:

Convert.ToString(数字,进制数)

如:Convert.ToString(10,2)=01010,Convert.ToString(10,8)=12 ,Convert.ToString(13,16)=0x0d

综合示例如下:

1
2
3
4
5
6
7
8
9
10
int i10 = 68;
int i16 = 0x2A;
Console.WriteLine("示例一:");
Console.Write("10进制【68】转成2、8、16进制结果:{0}、{1}、{2}\n",
            Convert.ToString(i10, 2), Convert.ToString(i10, 8), Convert.ToString(i10, 16));
Console.Write("16进制【0x2A】转成2、8、10进制结果:{0}、{1}、{2}\n",
Convert.ToString(i16, 2), Convert.ToString(i16, 8), Convert.ToString(i16, 10));

输出结果:

10进制【68】转成2、8、16进制结果:1000100、104、44
16进制【0x2A】转成2、8、10进制结果:101010、52、42

三、初识位运算(位与与位或运算)

本文一开始就说明了,位运算就是二进制每位数字的运算操作,下面通过代码示例来初识位运算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
    Console.WriteLine("示例二:");
    int b0 = 0, b1 = 1, b2 = 2, b3 = 4, b4 = 8, b5 = 16;
    FormatWrite("b0""b1", b0, b1, "&");
    FormatWrite("b0""b1", b0, b1, "|");
    Console.WriteLine();
    FormatWrite("b2""b3", b2, b3, "&");
    FormatWrite("b2""b3", b2, b3, "|");
    Console.WriteLine();
    FormatWrite("b4""b5", b4, b5, "&");
    FormatWrite("b4""b5", b4, b5, "|");
static void FormatWrite(string n1, string n2, int d1, int d2, string opt)
{
    string writeMsg = string.Format("{0} {1} {2}", n1, opt, n2);
    writeMsg += string.Format(" = {0} {1} {2}", d1, opt, d2);
    string d1str = Convert.ToString(d1, 2), d2str = Convert.ToString(d2, 2);
    int maxLen = Math.Max(d1str.Length, d2str.Length);
    writeMsg += string.Format(" = {0} {1} {2}", d1str.PadLeft(maxLen, '0'), opt, d2str.PadLeft(maxLen, '0'));
    switch (opt)
    {
        case "&":
            {
                writeMsg += string.Format(" = 10进制:{0} 或 2进制:{1}", Convert.ToString(d1 & d2, 10), Convert.ToString(d1 & d2, 2).PadLeft(maxLen, '0'));
                break;
            }
        case "|":
            {
                writeMsg += string.Format(" = 10进制:{0} 或 2进制:{1}", Convert.ToString(d1 | d2, 10), Convert.ToString(d1 | d2, 2).PadLeft(maxLen, '0'));
                break;
            }
    }
    Console.WriteLine(writeMsg);
}

输出结果:

b0 & b1 = 0 & 1 = 0 & 1 = 10进制:0 或 2进制:0
b0 | b1 = 0 | 1 = 0 | 1 = 10进制:1 或 2进制:1

b2 & b3 = 2 & 4 = 010 & 100 = 10进制:0 或 2进制:000
b2 | b3 = 2 | 4 = 010 | 100 = 10进制:6 或 2进制:110

b4 & b5 = 8 & 16 = 01000 & 10000 = 10进制:0 或 2进制:00000
b4 | b5 = 8 | 16 = 01000 | 10000 = 10进制:24 或 2进制:11000

位与运算:

参加运算的两个数字,按二进制进行与运算,如果两个相应的二进位数为1,则该位的结果为 1, 否则为 0 ,即:
0 & 0 = 0;0 & 1 = 0;1 & 0 = 0;1& 1 = 1

也就是只有1 & 1才会得1,否则都为0;

位或运算:

参加运算的两个数字,按二进制进行或运算,如果两个相应的二进位中只要有一个为 1,则该位的结果就为 1,否则为 0 ,即:

0|0=0; 0|1=1; 1|0=1; 1|1=1;

也就是只有0 & 0才会得0,否则都为1;

 四、寻找规律

我们先看一下10进制及2进制0~20的数字

10进制数:0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20 
2进制数:00000,00001,00010,00011,00100,00101,00110,00111,01000,01001,01010,01011,01100,01101,01110,01111,10000,10001,10010,10011,10100

从2进制数0~20中,我们发现只要是2的偶数次方时,则位数发生变化,且多位中只有一个为1,其余位均为0,找出的数字如下:

00000、00001、00010、,00100、01000、10000

对应10进制数:0、1、2、4、8、16

如果对这些数全部进行位或运算,则最终的结果是:11111,即5位会部是1

从这里发现了什么呢?我是看出来了,不知道各位看官是否看出规律,其实很简单,如果我们把每一位都当成一个控制开关或者说是存在不存在,那么0表示关或者不存在,1表示开或者存在,那么我们可以针对这个规律实现复杂的组合控制。

其实微软早就应用了这个规律特性,比如:

typeof(Program).GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.Static);

BindingFlags定义如下:

如上,每一个枚举项都是2的次方,每一项都是上一项的2倍,我们也可以利用这个规律实现类似的处理。

五、实现组合控制

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
    Console.WriteLine("示例四:");
    ButtonStyle userbtnStyle = ButtonStyle.OK | ButtonStyle.Cancel | ButtonStyle.Alert | ButtonStyle.Info;//用户需要显示的ButtonStyle,通过或运算组合在一起,得出2进制值:1111
    string buttonStyleStr = null;
    //进行位逻辑判断,能够准确识别userbtnStyle的组合的内容
    if ((userbtnStyle & ButtonStyle.AlertInfo) == ButtonStyle.AlertInfo)
    {
        buttonStyleStr += "+" + Enum.GetName(typeof(ButtonStyle), ButtonStyle.AlertInfo);
    }
    else if ((userbtnStyle & ButtonStyle.Alert) == ButtonStyle.Alert)
    {
        buttonStyleStr += "+" + Enum.GetName(typeof(ButtonStyle), ButtonStyle.Alert);
    }
    else if ((userbtnStyle & ButtonStyle.Info) == ButtonStyle.Info)
    {
        buttonStyleStr += "+" + Enum.GetName(typeof(ButtonStyle), ButtonStyle.Info);
    }
    if ((userbtnStyle & ButtonStyle.OKCancel) == ButtonStyle.OKCancel)
    {
        buttonStyleStr += "+" + Enum.GetName(typeof(ButtonStyle), ButtonStyle.OKCancel);
    }
    else if ((userbtnStyle & ButtonStyle.OK) == ButtonStyle.OK)
    {
        buttonStyleStr += "+" + Enum.GetName(typeof(ButtonStyle), ButtonStyle.OK);
    }
    else if ((userbtnStyle & ButtonStyle.Cancel) == ButtonStyle.Cancel)
    {
        buttonStyleStr += "+" + Enum.GetName(typeof(ButtonStyle), ButtonStyle.Cancel);
    }
    Console.WriteLine("需要显示的按钮有:" + buttonStyleStr.Substring(1));
enum ButtonStyle
{
    None = 0x00,
    OK = 0x01,
    Cancel = 0x02,
    Alert = 0x04,
    Info = 0x08,
    OKCancel = 0x01 | 0x02,
    AlertInfo = 0x04 | 0x08
}

输出结果:

需要显示的按钮有:AlertInfo+OKCancel

如果改变userbtnStyle的组合,得到的结果也会不同

另外一个示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
    Console.WriteLine("示例五:");
    AllowType userPermission = AllowType.Add | AllowType.Update | AllowType.Upload | AllowType.Download | AllowType.Select;
    string userPermissionStr = null;
    if ((userPermission & AllowType.Edit) == AllowType.Edit)
    {
        userPermissionStr += "+" + Enum.GetName(typeof(AllowType), AllowType.Edit);
    }
    else
    {
        if ((userPermission & AllowType.Add) == AllowType.Add)
        {
            userPermissionStr += "+" + Enum.GetName(typeof(AllowType), AllowType.Add);
        }
        if ((userPermission & AllowType.Update) == AllowType.Update)
        {
            userPermissionStr += "+" + Enum.GetName(typeof(AllowType), AllowType.Update);
        }
        if ((userPermission & AllowType.Delete) == AllowType.Delete)
        {
            userPermissionStr += "+" + Enum.GetName(typeof(AllowType), AllowType.Delete);
        }
        if ((userPermission & AllowType.Upload) == AllowType.Upload)
        {
            userPermissionStr += "+" + Enum.GetName(typeof(AllowType), AllowType.Upload);
        }
    }
    if ((userPermission & AllowType.Read) == AllowType.Read)
    {
        userPermissionStr += "+" + Enum.GetName(typeof(AllowType), AllowType.Read);
    }
    else
    {
        if ((userPermission & AllowType.Select) == AllowType.Select)
        {
            userPermissionStr += "+" + Enum.GetName(typeof(AllowType), AllowType.Select);
        }
        if ((userPermission & AllowType.Download) == AllowType.Download)
        {
            userPermissionStr += "+" + Enum.GetName(typeof(AllowType), AllowType.Download);
        }
    }
    Console.WriteLine("用户具备的权限有:" + userPermissionStr.Substring(1));
enum AllowType
{
    None = 0,
    Add = 1,
    Update = 2,
    Delete = 4,
    Select = 8,
    Upload = 16,
    Download = 32,
    Edit = Add | Update | Delete | Upload,
    Read = Select | Download
}

输出结果:

用户具备的权限有:Add+Update+Upload+Read

如果改变userPermission的组合,得到的结果也会不同

上述两个例子,就是允分利用位或位与运算,大家可以理解位或是将两者拼在一起,位与是找出组合中是否有包含的部份

六、了解其它位运算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Console.WriteLine("示例六:");
int x1 = 108;
Console.Write("~位非运算:{0} -->> {1} ; {2} -->> {3}\n",
            Convert.ToString(x1, 10), Convert.ToString(~x1, 10),
            Convert.ToString(x1, 2), Convert.ToString(~x1, 2));
Console.Write("<<位左移(移5位)运算:{0} -->> {1} ; {2} -->> {3}\n",//说白了讲:左移N位就是将二进制数后面补N位0
Convert.ToString(x1, 10), Convert.ToString(x1 << 5, 10),
Convert.ToString(x1, 2), Convert.ToString(x1 << 5, 2));
Console.Write(">>位右移(移5位)运算:{0} -->> {1} ; {2} -->> {3}\n",//说白了讲:右移N位就是将二进制数后面删除N位数(不论0或1)
Convert.ToString(x1, 10), Convert.ToString(x1 >> 5, 10),
Convert.ToString(x1, 2), Convert.ToString(x1 >> 5, 2));
Console.Write("^位异或(异或5)运算:{0} ^ {1} -->> {2} ; {3} ^ {4}-->> {5}\n",
Convert.ToString(x1, 10),Convert.ToString(5, 10), Convert.ToString(x1 ^ 5, 10),
Convert.ToString(x1, 2), Convert.ToString(5, 2), Convert.ToString(x1 ^ 5, 2));

输出结果:

~位非运算:108 -->> -109 ; 1101100 -->> 11111111111111111111111110010011
<<位左移(移5位)运算:108 -->> 3456 ; 1101100 -->> 110110000000
>>位右移(移5位)运算:108 -->> 3 ; 1101100 -->> 11
^位异或(异或5)运算:108 ^ 5 -->> 105 ; 1101100 ^ 101-->> 1101001

~非运算:是一个单项运算符,用来对一个二进制按位取反,即将 0 变 1,1变 0。

<<左移:用来对一个数每个二进位全部左移若干位,说白了讲:左移N位就是将二进制数后面补N位0

>>右移:用来对一个数每个二进位全部右移若干位,移到右端的低位被舍弃,对无符号数,高位补 0,说白了讲:右移N位就是将二进制数后面删除N位数(不论0或1)

^异或运算: 也称 XOR 运算符。它的规则是若参加运算的两个二进位同号,则结果为0,异号则为1。即 0^0=0; 0^1=1; 1^0=1;1^1=0;说白了讲:若两个都为0,则为0,否则相同的则为0,不相同的则为1

小技巧说明:

大家在定义枚举时,除了0,1外,其余项只需要确保每一项乘以2得出下一项的值即可,如10进制数的值:0,1,2,4,8,16,32,64,128,256,16进制数的值:0x00,0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80

通过10进制数的值与16进制数的值的对比发现,采用16进制定义枚举值更好,因为我们可以很快速的定义出我们需要的值(都是按照:0,1,2,4,8循环,只是位数上升而矣),比如:

0x00,0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80,0x100,0x200,0x400,0x800,0x1000

对应的10进制数:0,1,2,4,8,16,32,64,128,256,512,1024,2048,4096

明显16进制定义值相对简单一些,我们无需进行*2的计算,当然大家随意选择。

为了便于大家进行各种测试,贴出DEMO代码,供大家学习:

+ View Code

  

本文转自 梦在旅途 博客园博客,原文链接:http://www.cnblogs.com/zuowj/p/5614237.html  ,如需转载请自行联系原作者

http://www.cnblogs.com/zuowj/p/5674615.html相关推荐

  1. 关于Entity Framework自动关联查询与自动关联更新导航属性对应的实体注意事项说明...

    一.首先了解下Entity Framework 自动关联查询: Entity Framework 自动关联查询,有三种方法:Lazy Loading(延迟加载),Eager Loading(预先加载) ...

  2. 为了去重复,写了一个通用的比较容器类,可以用在需要比较的地方,且支持Lamda表达式...

    为了去重复,写了一个通用的比较容器类,可以用在需要比较的地方,且支持Lamda表达式,代码如下: public class DataComparer<T>:IEqualityCompare ...

  3. SQL语句技巧:查询时巧用OR实现逻辑判断

    首先看以下SQL逻辑语句块: DECLARE @fieldname varchar(50) DECLARE @fieldvalue nvarchar(100)SET @fieldname='chass ...

  4. Jquery ajax 返回string类型加result.d原因

    啥叫异步,啥叫Ajax.咱不谈啥XMLHTTPRequest.通俗讲异步就是前台页面javascript能调用后台方法.这样就达到了无刷新.所谓的Ajax.这里我们讲二种方法 方法一:(微软有自带Aj ...

  5. WCF服务创建与使用(双工模式)

    昨天发布了<WCF服务创建与使用(请求应答模式)>,今天继续学习与强化在双工模式下WCF服务创建与使用,步骤与代码如下. 第一步,定义服务契约(Service Contract),注意Se ...

  6. asp.net里导出excel表方法汇总

    1.由dataset生成 public void CreateExcel(DataSet ds,string typeid,string FileName)     {     HttpRespons ...

  7. 分享在winform下实现左右布局多窗口界面

    在web页面上我们可以通过frameset,iframe嵌套框架很容易实现各种导航+内容的布局界面,而在winform.WPF中实现其实也很容易,我这里就分享一个:在winform下实现左右布局多窗口 ...

  8. 总结概括对于大数据、高并发的网站如何进行优化的问题

    对于大数据.高并发的网站,如何进行优化?我这里作出一个概括性的总结,以后慢慢细化与完善,可能存在不全或有误的地方,欢迎大家一起交流,谢谢! 服务器端: 1.采用缓存或分布式缓存技术(cache.mem ...

  9. ASP.NET跨服务器上传文件的相关解决方案

    ASP.NET跨服务器上传文件的相关解决方案 参考文章: (1)ASP.NET跨服务器上传文件的相关解决方案 (2)https://www.cnblogs.com/zuowj/p/3999798.ht ...

最新文章

  1. Python:变量与字符串
  2. 虚幻UE4常见问题最全集合
  3. 03013_JDBC工具类
  4. Flv网络播放器制作全攻略
  5. 本文详解5G是个什么鬼,程序员都准备好了吗?
  6. c++语言socket udp聊天程序,使用C/C++实现Socket聊天程序
  7. markdown知识轻轻来袭
  8. 字典树实现_trie 字典树的实现方法
  9. 中控考勤软件sqlserver数据库建立办法
  10. docker安装ftp
  11. 嵌入式linux快速入门
  12. 飞桨2.0高层api教程——使用BERT实现自动写诗
  13. PS——字体斜阴影效果
  14. V831基础-摄像头使用
  15. 【图片新闻】美海军的下一艘战舰与“祖姆沃尔特”DDG-1000极其相似
  16. Dev-C++5.11游戏创作之简易小炸弹
  17. 熬粥记:煮一碗红豆粥,3次才领悟煮粥大法
  18. sql server 审核
  19. redis:redis-cli使用
  20. matplotlib.plt.subplot()用法

热门文章

  1. A query was run and no Result Maps were found
  2. python数据挖掘主要特点_python数据挖掘(从数据集中抽取特征)
  3. 读书笔记-《增长黑客》-好产品是增长的根本
  4. 数据如何从HBase读到MR
  5. 用存储过程实现数据分页
  6. 企业架构 - 组织角色和技能
  7. 用SERVLET进行用户名和密码验证
  8. Codeforces Round 263(Div. 2)
  9. [并查集][排序] Jzoj P4223 旅游
  10. [转] 在Mac上搭建React Native开发环境