前提

位运算符中 ，操作数只能为整型和字符型数据

运算符号

按位与（&）：同1则1 → true&&true

操作数1 0 0 1 1
操作数2 0 1 0 1
按位与 0 0 0 1

按位或（|）：有1则1 → true||false、false||true

操作数1 0 0 1 1
操作数2 0 1 0 1
按位或 0 1 1 1

按位取反（~）：取反 → !true、!false

操作数 0 1
按位非 1 0

按位异或（^）：异为1同为0 → 可以理解为找测试结果里的异常数据

操作数1 0 0 1 1
操作数2 0 1 0 1
按位异或 0 1 1 0

异或，英文为exclusive OR，缩写成xor
异或也叫半加运算：二进制下用1表示真，0表示假，则异或的运算法则为：0⊕0=0，1⊕0=1，0⊕1=1，1⊕1=0，这些法则与加法是相同的，只是不带进位，所以异或常被认作不进位加法。

1. 归零律：a^a=0
2. 恒等律：a^0=a、0^a=a
3. 交换律：a^b = b^a
4. 结合律：a^b^c = (a^b)^c = a^(b^c)
5. 自反律：a^b^a = b
6.  a^b^c^d=0a=b^c^db=c^d^ac=d^a^bd=a^b^c

左位移（<<）

溢出截断，低位补0；

右位移（>>）

溢出截断，高位补符号位；

无符号右移（>>>）

溢出截断，高位补0；

中间过程理解

10进制     输入数:142进制    -1补码:111111111111111111111111111111112进制    14补码:000000000000000000000000000011102进制   -14补码:111111111111111111111111111100102进制    ~14 ☞      14(原码/反码/补码)按位取反: 11111111111111111111111111110001 ☞ -14补码2进制  14^-1 ☞      14(原码/反码/补码)按位取反: 11111111111111111111111111110001 ☞ -14补码2进制  -14-1 ☞      14(原码/反码/补码)按位取反: 11111111111111111111111111110001 ☞ -14补码
------------------------------------------------
10进制     输入数:-142进制    -1补码:111111111111111111111111111111112进制   -14补码:111111111111111111111111111100102进制    14补码:000000000000000000000000000011102进制   ~-14 ☞     -14(补码)按位取反: 00000000000000000000000000001101 ☞ 14(原码/反码/补码)2进制 -14^-1 ☞     -14(补码)按位取反: 00000000000000000000000000001101 ☞ 14(原码/反码/补码)2进制 --14-1 ☞     -14(补码)按位取反: 00000000000000000000000000001101 ☞ 14(原码/反码/补码)
  • 不分正负时：当 n + x = 2^N - 1 时，可以得到 n 和 x 互为按位取反的关系。
  • 如分正负时：当 n + x = -1 时，可以得到 n 和 x 互为按位取反的关系。
  • 负数绝对值 和 负数反码 互为按位取反的关系。
  • 负数绝对值 + 负数反码 + 1 = Mod(2^N)。
  • 负数绝对值 + 负数补码 = Mod(2^N)。
  • 负数补码 = 负数反码 + 1。
  • 二进制里 减一取反 和 取反加一 等价。
  • 负数绝对值(原码/反码/补码)减一取反 ☞ 负数补码。
  • 负数绝对值(原码/反码/补码)取反加一 ☞ 负数补码。
private static void test(int num) {System.out.println("10进制 " + proFillSpace("输入数:") + num);System.out.println(" 2进制 " + proFillSpace("-1补码:") + Integer.toBinaryString(-1));System.out.println(" 2进制 " + proFillSpace(num + "补码:") + proFillZero(Integer.toBinaryString(num)));System.out.println(" 2进制 " + proFillSpace(-num + "补码:") + proFillZero(Integer.toBinaryString(-num)));System.out.println(" 2进制 " + proFillSpace("~" + num + " ☞") + proFillSpace(num) + "按位取反: " + proFillZero(Integer.toBinaryString(~num)));System.out.println(" 2进制 " + proFillSpace(num + "^-1 ☞") + proFillSpace(num) + "按位取反: " + proFillZero(Integer.toBinaryString(num ^ -1)));System.out.println(" 2进制 " + proFillSpace("-" + num + "-1 ☞") + proFillSpace(num) + "按位取反: " + proFillZero(Integer.toBinaryString(-num - 1)));
}
private static String proFillZero(String str) {if (str.length() >= 32) {return str;}return proFillZero("0" + str);
}
private static String proFillSpace(Object i) {String str = String.valueOf(i);return proFillSpace2(str);
}
private static String proFillSpace2(String str) {if (str.length() >= 8) {return str;}return proFillSpace2(" " + str);
}

用途

与运算的用途：

① 清零 → a & 0 = 0

一个数与一个各位都为零的数值相与，结果为零

举例：0000 0101 1010
&  0000 0000 0000
---------------------0000 0000 0000

int[] arr = {1, 2, 3, 4, 5, 6, 8};
for (int i = 0; i < arr.length; i++) {int res = arr[i] & 0;System.out.print(res);
}
// 0000000

② 值不变 → a & -1 = a

举例：0000 0101 1010
&  1111 1111 1111
---------------------0000 0101 1010

③ 根据第①条 + 第②条 ☞ 获取某个二进制数的指定位 → 10101110 & 00001111 = 00001110

③ 根据第①条 + 第②条 ☞ 把某个二进制数的指定位重置为0 → 10101110 & 00001111 = 00001110

比如取数 X=1010 1110 的低4位，只需要与Y=0000 1111 进行按位与运算（X&Y=0000 1110）即可获取X的后4位，也可以看成把前4位置为0

举例：0000 0101 1010
&  0000 1111 0000
---------------------0000 0101 0000

④ 判断奇偶 → (a & 1) == 1 ? "奇数" : "偶数"

Integer.toBinaryString(0)
Integer.toBinaryString(1)
Integer.toBinaryString(2)
Integer.toBinaryString(3)
Integer.toBinaryString(4)0000
0001
0010
0011
0100

二进制未位为0就是偶数，为1就是奇数。可以用if ((a & 1) == 0) 代替 if (a % 2 == 0) 来判断a是不是偶数

System.out.println((5 & 1) == 1 ? "奇数" : "偶数"); // 奇数
System.out.println((6 & 1) == 1 ? "奇数" : "偶数"); // 偶数
System.out.println((0 & 1) == 1 ? "奇数" : "偶数"); // 偶数
System.out.println((-1 & 1) == 1 ? "奇数" : "偶数"); // 奇数
System.out.println((-2 & 1) == 1 ? "奇数" : "偶数"); // 偶数

⑤ 用一条语句判断一个整数是否为2的整数次方 → (num & (num-1)) == 0

private static void findLoca(int num) {boolean noSame;if (num >= 0) {noSame = (num & (num - 1)) == 0;} else {// 正数这个算法才好用，所以负数变成正数noSame = (-num & (-num - 1)) == 0;}System.out.println(noSame);
}System.out.println(proFillZero(Integer.toBinaryString(0)));
System.out.println(proFillZero(Integer.toBinaryString(2)));
System.out.println(proFillZero(Integer.toBinaryString(4)));
System.out.println(proFillZero(Integer.toBinaryString(8)));
System.out.println(proFillZero(Integer.toBinaryString(16)));
System.out.println(proFillZero(Integer.toBinaryString(32)));
System.out.println(proFillZero(Integer.toBinaryString(64)));
System.out.println(proFillZero(Integer.toBinaryString(128)));
System.out.println(proFillZero(Integer.toBinaryString(256)));
System.out.println(proFillZero(Integer.toBinaryString(512)));
System.out.println(proFillZero(Integer.toBinaryString(1024)));
System.out.println(proFillZero(Integer.toBinaryString(2048)));
System.out.println(proFillZero(Integer.toBinaryString(4096)));
System.out.println(proFillZero(Integer.toBinaryString(8192)));
记住2的n次方法的二进制的样子
00000000000000000000000000000000
00000000000000000000000000000010
00000000000000000000000000000100
00000000000000000000000000001000
00000000000000000000000000010000
00000000000000000000000000100000
00000000000000000000000001000000
00000000000000000000000010000000
00000000000000000000000100000000
00000000000000000000001000000000
00000000000000000000010000000000
00000000000000000000100000000000
00000000000000000001000000000000
00000000000000000010000000000000
System.out.println(proFillZero(Integer.toBinaryString(-2)));
System.out.println(proFillZero(Integer.toBinaryString(-4)));
System.out.println(proFillZero(Integer.toBinaryString(-8)));
System.out.println(proFillZero(Integer.toBinaryString(-16)));
System.out.println(proFillZero(Integer.toBinaryString(-32)));
System.out.println(proFillZero(Integer.toBinaryString(-64)));
System.out.println(proFillZero(Integer.toBinaryString(-128)));
System.out.println(proFillZero(Integer.toBinaryString(-256)));
System.out.println(proFillZero(Integer.toBinaryString(-512)));
System.out.println(proFillZero(Integer.toBinaryString(-1024)));
System.out.println(proFillZero(Integer.toBinaryString(-2048)));
System.out.println(proFillZero(Integer.toBinaryString(-4096)));
System.out.println(proFillZero(Integer.toBinaryString(-8192)));
11111111111111111111111111111110
11111111111111111111111111111100
11111111111111111111111111111000
11111111111111111111111111110000
11111111111111111111111111100000
11111111111111111111111111000000
11111111111111111111111110000000
11111111111111111111111100000000
11111111111111111111111000000000
11111111111111111111110000000000
11111111111111111111100000000000
11111111111111111111000000000000
11111111111111111110000000000000System.out.println(proFillZero(Integer.toBinaryString(7)));
System.out.println(proFillZero(Integer.toBinaryString(7 - 1)));
00000000000000000000000000000111
00000000000000000000000000000110System.out.println(proFillZero(Integer.toBinaryString(4)));
System.out.println(proFillZero(Integer.toBinaryString(4 - 1)));
00000000000000000000000000000100
00000000000000000000000000000011这里减1会导致退1位，所以再和原来的取&，肯定为0

⑥ 【useless】不用 for 循环找到二进制最右侧的1 → num & (-num)

已知 num & num取反 = 0，-num = num取反+1，
故num & -num → num & num取反+1 → 最后一个不同的1

private static void findLoca1(int num) {System.out.println(" 2进制   -1         : " + Integer.toBinaryString(-1));System.out.println("10进制  " + num + "       数: " + num);System.out.println(" 2进制  " + num + "    绝对值: " + proFillZero(Integer.toBinaryString(num)));System.out.println(" 2进制  " + num + " 绝对值取反: " + Integer.toBinaryString(-num - 1));System.out.println(" 2进制 " + (-num) + "      补码: " + Integer.toBinaryString(-num));int location = (num & (-num));// -num就是num取反+1得到的,num&num取反=0,num&-num→最后一个不同的1System.out.println(proFillZero(Integer.toBinaryString(location)));
}2进制   -1         : 11111111111111111111111111111111
10进制  500       数: 5002进制  500    绝对值: 000000000000000000000001111101002进制  500 绝对值取反: 111111111111111111111110000010112进制 -500      补码: 11111111111111111111111000001100
00000000000000000000000000000100

⑦ 【useless】将二进制表示的最右侧的1置0 → num & (-num) ^ num

System.out.println("10进制  " + num + "       数: " + num);
System.out.println(" 2进制  " + num + "    绝对值: " + proFillZero(Integer.toBinaryString(num)));
System.out.println(" 2进制  " + num + " 绝对值取反: " + Integer.toBinaryString(-num - 1));
System.out.println(" 2进制 " + (-num) + "      补码: " + Integer.toBinaryString(-num));int location = (num & (-num));
// -num就是num取反+1得到的,num&num取反=0,num&-num→最后一个不同的1
System.out.println(proFillZero(Integer.toBinaryString(location)));int location1 = num & (-num) ^ num;
System.out.println(proFillZero(Integer.toBinaryString(location1)));10进制  500       数: 5002进制  500    绝对值: 0000000000000002进制  500 绝对值取反: 11111111111111112进制 -500      补码: 11111111111111
00000000000000000000000000000100
00000000000000000000000111110000

或运算的用途：

① 值不变 → a | 0 = a

举例：0000 0101 1010
|  0000 0000 0000
---------------------0000 0101 1010

② 值清为 -1 → a | -1 = -1

举例：0000 0101 1010
|  1111 1111 1111
---------------------1111 1111 1111

③ 根据第①条 + 第②条 ☞ 把某个二进制数的指定位重置为1 → 10101110 | 00001111 = 10101111

比如将数 X=1010 1110 的低4位设置为1，只需要与Y=0000 1111 进行按位或运算（X|Y=1010 1111）即可

举例：0000 0101 1010
|  0000 0000 1111
---------------------0000 0000 1111

异或运算的用途：

① 值不变 → a ^ 0 = a ：运算法则的恒等率

举例：0000 0101 1010
^  0000 0000 0000
---------------------0000 0101 1010

② 翻转每一位 → a ^ -1 = 翻转二进制每一位

某个数 ^ -1 = 翻转二进制每一位（即按位取反）
Read More

  • 取反，按位取反(~)，取反码的区别
举例：0000 0101 1010
|  1111 1111 1111
---------------------1111 1010 01011000 0101 1010
|  1111 1111 1111
---------------------0111 1010 0101

System.out.println("素材 -1   : " + proFillZero(Integer.toBinaryString(-1)));System.out.println("素材 13   : " + proFillZero(Integer.toBinaryString(13)));
System.out.println("素材 ~13  : " + proFillZero(Integer.toBinaryString(~13)));
System.out.println("素材 13^-1: " + proFillZero(Integer.toBinaryString(13 ^ -1)));System.out.println("素材-13   : " + proFillZero(Integer.toBinaryString(-13)));
System.out.println("素材~-13  : " + proFillZero(Integer.toBinaryString(~-13)));
System.out.println("素材-13^-1: " + proFillZero(Integer.toBinaryString(-13 ^ -1)));素材 -1   : 11111111111111111111111111111111素材 13   : 00000000000000000000000000001101
素材 ~13  : 11111111111111111111111111110010
素材 13^-1: 11111111111111111111111111110010素材-13   : 11111111111111111111111111110011
素材~-13  : 00000000000000000000000000001100
素材-13^-1: 00000000000000000000000000001100

③ 根据第①条 + 第②条 ☞ 翻转指定位 → 10101110 ^ 00001111 = 10100001

比如将数 X=1010 1110 的低4位进行翻转，只需要与Y=0000 1111 进行异或运算（X^Y=1010 0001）即可

举例：0000 0101 1010
|  0000 0000 1111
---------------------0000 0101 0101

④ 交换两个数

int x = 5;
int y = 6;x = x ^ y;
y = x ^ y; 即: y = x ^ y ^ y → x
x = x ^ y; 即：x = x ^ y → x ^ y ^ y(已经是x了) → ySystem.out.println(x);// 6
System.out.println(y);// 5x = x ^ y; → 5^6→3
y = x ^ y; → 3^6→5
x = x ^ y; → 5^3→6

⑤ 判断整数 m 的二进制需要改变多少位才能变为 n

此场景就是找2个二进制数不同的位，把不同的为改一下就相同了，故统计出不同的地方即可
其实就是计算 m 与 n 的异或的二进制中 1 的个数

private static void coutDiff(int num1, int num2) {System.out.println(proFillZero(Integer.toBinaryString(6)));System.out.println(proFillZero(Integer.toBinaryString(10)));String str = proFillZero(Integer.toBinaryString(num1 ^ num2));System.out.println(str);long count = Arrays.stream(str.split("")).filter("1"::equals).count();System.out.println(count);
}00000000000000000000000000000110
00000000000000000000000000001010
00000000000000000000000000001100
2

左位移的用途：

① m * 2^n = (m << 3)

System.out.println("  2^3=" + (1 << 3));//   2^3=8
System.out.println("1*2^3=" + (1 << 3));// 3*2^3=8
System.out.println("3*2^3=" + (3 << 3));// 3*2^3=24
System.out.println("5*2^3=" + (5 << 3));// 5*2^3=40// 理解过程101            → 5
101000            → 401左挪3位         →（101后面的1相当于1）扩大8倍  →  1*8=8
1左挪3位           →（101前面的1相当于4）扩大8倍  →  4*8=32综上101左挪3位     →  101000就相当于 8+32  →  (1+4)*8  →  5*8  →  5*2的3次方

右位移的用途：

① 正数 >> 31 → 0、负数 >> 31→ -1

4个字节 32位
右移31操作可以取得任何整数的符号位
任何正数右移31后只剩符号位0，最终结果为0
任何负数右移31后也只剩符号位1，溢出的31位截断，空出的31位补符号位1，最终结果为-1

System.out.println(" 13    :" + proFillZero(Integer.toBinaryString(13)));
System.out.println("-13    :" + proFillZero(Integer.toBinaryString(-13)));
System.out.println(" 13>>31:" + proFillZero(Integer.toBinaryString(13 >> 31)) + " →对应10进制: " + (13 >> 31));
System.out.println("-13>>31:" + proFillZero(Integer.toBinaryString(-13 >> 31)) + " →对应10进制: " + (-13 >> 31));13    : 00000000000000000000000000001101
-13    : 1111111111111111111111111111001113>>31: 00000000000000000000000000000000 → 对应10进制: 0
-13>>31: 11111111111111111111111111111111 → 对应10进制: -1

4个字节32位的整数，右移31操作可以取得符号位；------------------------------------
00000000 01010000 10100000 01011000|
------------------------------------
右移31位
------------------------------------0|0000000 01010000 10100000 01011000
------------------------------------
空位补0
------------------------------------
00000000 00000000 00000000 00000000|
------------------------------------
最终结果为 0

------------------------------------
10000000 01010000 10100000 01011000|
------------------------------------
右移31位
------------------------------------1|0000000 01010000 10100000 01011000
------------------------------------
空位补0
------------------------------------
11111111 11111111 11111111 11111111|
------------------------------------
最终结果为 -1

运算符组合运算场景

1）取绝对值 → (a^(a>>31))-(a>>31) / (a+(a>> 31))^(a>>31)

正数
System.out.println((0 ^ (0 >> 31)) - (0 >> 31));// 0
System.out.println((5 ^ (5 >> 31)) - (5 >> 31));// 5
System.out.println((6 ^ (6 >> 31)) - (6 >> 31));// 6
System.out.println((7 ^ (7 >> 31)) - (7 >> 31));// 7负数
System.out.println((-1 ^ (-1 >> 31)) - (-1 >> 31));// -1
System.out.println((-5 ^ (-5 >> 31)) - (-5 >> 31));// -5
System.out.println((-6 ^ (-6 >> 31)) - (-6 >> 31));// -6
System.out.println((-7 ^ (-7 >> 31)) - (-7 >> 31));// -7

右移31操作可以取得任何整数的符号位
任何正数右移31后只剩符号位0，，溢出的31位截断，空出的31位补0，最终结果为0
任何负数右移31后也只剩符号位1，溢出的31位截断，空出的31位补符号位1，最终结果为-1

先整理一下使用位运算取绝对值的思路：
若a为正数，则不变，需要用异或0保持的特点；
若a为负数，则其补码 = 负数绝对值的每一位取反+1，故其绝对值 = (补码-1取反) / (补码取反+1)，而异或-1具有翻转的特点

那么综合上面的步骤，可得到公式。
a>>31取得a的符号
若a为正数，a>>31等于0，a^0=a不变；
若a为负数，a>>31等于-1 ，a^-1翻转每一位；

推导出公式为 → (a^(a>>31))-(a>>31) / (a+ (a>> 31)) ^ (a>> 31)

int[] arr = {-3, -2, -1, 0, 1, 2, 3};
for (int i : arr) {abs1(i);
}
for (int i : arr) {abs2(i);
}3 2 1 0 1 2 3
3 2 1 0 1 2 3 private static void abs1(int num) {// 取反+1int i = (num ^ (num >> 31)) - (num >> 31);System.out.print(i + " ");
}
private static void abs2(int num) {//-1取反int i = (num + (num >> 31)) ^ (num >> 31);System.out.print(i + " ");
}

以上参考：Java位运算原理及使用讲解

2）找出没有重复的数 (使用起来有太多局限，非通用)

public static int find(int[] nums){int tmp = nums[0];for(int i = 1;i < nums.length; i++)tmp ^= arr[i];return tmp;
}

参考：

几种常见的位运算
C语言位运算的妙用你知道多少？
位运算的妙用
位运算用法
位运算详解
https://imageslr.com/2019/12/11/data-lab-2.html

Java位运算，常见的位运算相关推荐

  1. 常见位操作及运算应用举例:1,C语言中位运算符异或“∧”的作用​​​​​​​2,异或运算的作用3,（与运算）、|（或运算）、^（异或运算）

    1 C语言中位运算符异或"∧"的作用: 异或运算符∧也称XOR运算符.它的规则是若参加运算的两个二进位同号,则结果为0(假):异号则为1(真).即0∧0＝0,0∧1＝1,1∧1＝0 ...

  2. java 模拟 减法 进位_位运算实现加减乘除四则运算（Java）

    [本文版权归微信公众号"代码艺术"(ID:onblog)所有,若是转载请务必保留本段原创声明,违者必究.若是文章有不足之处,欢迎关注微信公众号私信与我进行交流!] 本文是继< ...

  3. Java位运算总结：位运算用途广泛

    前天几天研究了下JDK的Collection接口,本来准备接着研究Map接口,可是一查看HashMap类源码傻眼咯,到处是位运算实现,所以我觉得还是有必要先补补位运算知识,不然代码看起来有点费力.今天 ...

  4. java 位与运算_java中位运算和移位运算详解

    一.位运算 (1)按 位 与 & 如果两个相应的二进制形式的对应的位数都为1,则结果为1,记为同1为1,否则为0.首先我们看一下对正数的运算 分别看一下正数和负数的具体运算步骤 正数直接取二进 ...

  5. Python OpenCV 图像处理之 图像运算和图像位运算知识补充

    Python OpenCV 365 天学习计划,与橡皮擦一起进入图像领域吧.本篇博客是这个系列的第 51 篇. 该系列文章导航参考:https://blog.csdn.net/hihell/categ ...

  6. python字符位运算_python 字符串位运算-女性时尚流行美容健康娱乐mv-ida网

    女性时尚流行美容健康娱乐mv-ida网 mvida时尚娱乐网 首页 美容 护肤 化妆技巧 发型 服饰 健康 情感 美体 美食 娱乐 明星八卦 首页  > 高级搜索 [ python ] pyth ...

  7. x86架构下 CF与OF标志位 带符号和无符号运算 详解

    针对能够影响OF和CF标志位的指令,一般来说是涉及到数据运算的指令,这里使用add举例,即不区分有无符号的加法指令,参与运算的数据,从二进制层级去考虑. CF标志位 对于CF,它是carry flag ...

  8. php的位运算,php的位运算详解

    php的运算符有一类是位运算的,本文主要和大家分享php的位运算详解,希望能帮助到大家. 一:& And按位与 $a&$b 将把二进制$a和二进制$b位数都为1的设为1,其他位为0 例 ...

  9. 关于库位“参与MRP运算”与“不参与运算”相互变动的注意事项

        一.现状 因实际业务需求,库存从"不参与MRP运算"调整为"不参与运算",反之亦然. 二.原理 1.库位是否参与MRP运算 设置库位是否参与MRP运算, ...

最新文章

  1. Oracle用户管理
  2. BannerDemo【图片轮播图控件】
  3. word2vec (一) 简介与训练过程概要
  4. js一键批量打印_js批量打印文件夹
  5. 【并查集】打击犯罪（ssl 2342）
  6. EDS之后的block
  7. Nginx常用命令介绍
  8. 【细小碎的oi小知识点总结贴】不定时更新（显然也没人看qwq）
  9. Representation Learning with Contrastive Predictive Coding 论文阅读
  10. Java字符串：getBytes() 方法
  11. HTML绘制七巧板,canvas绘制七巧板
  12. Activiti使用教程
  13. 关于HTML的一些知识
  14. BLMOOC2812恼人的青蛙
  15. 大数据背后的神秘公式：贝叶斯公式
  16. ARM汇编指令MRS和MSR
  17. java 进销存 springmvc SSM crm 项目 系统
  18. e盘服务器被禁用怎么修改,ecs云服务器e盘改d盘
  19. 学习笔记（15):R语言入门基础-增加行或列
  20. mysql增加列耗时_实战-130W表增加字段耗时

热门文章

  1. Schema being registered is incompatible with an earlier schema
  2. 全息投影在博物馆中有哪些作用
  3. iOS原生二维码扫描(一)
  4. 微信小程序账号长时间未登录冻结解封
  5. salesforce学习资源
  6. 寻宝游戏 - 利用iBeacon特性设计的iOS线下寻宝游戏 - 物联网小游戏
  7. unity wsad 鼠标_Unity键盘WASD实现物体移动
  8. css控制文本的行高
  9. 工业自动化控制系统中的PLC模拟量信号数据采集如何实现？
  10. 如何解决win11“无法枚举容器中的对象，访问被拒绝”、“右键新建只有文件夹，没有其他选项”的问题。