旋转改变位置_指定位翻转

目录：

• 1、什么是二进制
• 2、位运算符的C语言的六种位运算符
• 3、JAVA中四个二进制位从操作符即（&按位与、|按位货、^按位异或、~按位取反）
• 4、JAVA计算器长整数实现

什么是二进制

二进制就是计算技术中被广泛采用的一种数制。

二进制的特点

1、它由两个数码0，1组成，二进制数运算规律是逢二进一。

2、二进制数的书写通常在数的右下方注上基数2，或加后面加B表示。

二进制的优点

1、二进制数中只有两个数码0和1，可用具有两个不同稳定状态的元器件来表示一位数码。例如，电路中某一通路的电流的有无，某一节点电压的高低，晶体管的导通和截止等。

2、二进制数运算简单，大大简化了计算中运算部件的结构。

3、二进制天然兼容逻辑运算。

二进制的缺点：二进制计数在日常使用上位数往往很长，读写不便。

扩展资料：

二进制位基础运算

1. 按位与（）

位运算实质是将参与运算的数字转换为二进制，而后逐位对应进行运算。

按位与运算为：两位全为1，结果为1，即11=1，10=0，01=0，00=0。

例如51 5 - 00110011 00000101 = 00000001 - 51 5 = 1

特殊用法：

（1）与0相与可清零。

（2）与1相与可保留原值，可从一个数中取某些位。例如需要取10101110中的低四位，10101110 00001111 = 00001110，即得到所需结果。

2. 按位或（|）

两位只要有一位为1，结果则为1，即1|1=1，1|0=1，0|1=1，0|0=0。

特殊用法：

（1）与0相或可保留原值。

（2）与1相或可将对应位置1。例如，将X=10100000的低四位置1，使X | 00001111 = 10101111即可。

3. 异或运算（^）

两位为“异”，即一位为1一位为0，则结果为1，否则为0。即1^1=1，1^0=0，0^1=0，0^0=1。

特殊用法：

（1）使指定位翻转：找一个数，对应X要翻转的各位为1，其余为0，使其与X进行异或运算即可。例如，X=10101110，使低四位翻转，X ^ 00001111 = 10100001。

（2）与0相异或保留原值。例如X ^ 00000000 = 10101110。

（3）交换两变量的值。（比借助容器法、加减法效率高）原理：一个数对同一个数连续两次进行异或运算，结果与这个数相等。

因此，交换方法为：A = A ^ B，B = A ^ B，A = A ^ B。

4. 取反（~）

将一个数按位取反，即~ 0 = 1，~ 1 = 0。

5. 左移（）

将一个数左移x位，即左边丢弃x位，右边用0补x位。例：11100111 2 = 10011100。

若左移时舍弃的高位全为0，则每左移1位，相当于该数十进制时乘一次2。

例：11(1011) 2 = 44（11表示为1011时实际上不完整，若计算机中规定整型的大小为32bit，则11的完整二进制形式为00000000 00000000 0000000 00001011）

6. 右移（）

将一个数右移若干位，右边舍弃，正数左边补0，负数左边补1。每右移一位，相当于除以一次2。

例：4 2 = 1，-14 2 = -4。

7. 无符号右移（）

将一个数右移若干位，左边补0，右边舍弃。

参考资料来源：

百度百科-二进制

位运算符的C语言的六种位运算符

按位与|按位或^按位异或~取反左移右移 按位与运算符是双目运算符。 其功能是参与运算的两数各对应的二进位相与。只有对应的两个二进位均为1时，结果位才为1 ，否则为0。参与运算的数以补码方式出现。

例如：95可写算式如下： 00001001 (9的二进制补码)00000101 (5的二进制补码) 00000001 (1的二进制补码)可见95=1。 按位与运算通常用来对某些位清0或保留某些位。例如把a 的高八位清 0 ， 保留低八位， 可作 a255 运算 ( 255 的二进制数为11111111)。 main(){    inta=9,b=5,c;    c=ab;    printf(a=%d\nb=%d\nc=%d\n,a,b,c);} 按位或运算符“|”是双目运算符。 其功能是参与运算的两数各对应的二进位相或。只要对应的二个二进位有一个为1时，结果位就为1。参与运算的两个数均以补码出现。

例如： 9|5可写算式如下：  00001001 | 00000101=00001101(十进制为13)可见9|5=13 main(){    inta=9,b=5,c;    c=a|b;    printf(a=%d\nb=%d\nc=%d\n,a,b,c);} 按位异或运算符“^”是双目运算符。 其功能是参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。

参与运算数仍以补码出现。

例如 9^5可写成算式如下：  00001001 ^ 00000101=00001100(十进制为12) main(){    inta=9;    a=a^15;    printf(a=%d\n,a);} 求反运算符～为单目运算符，具有右结合性。 其功能是对参与运算的数的各二进位按位求反。

例如 ~9的求反运算为： ~(1001)结果为： 0110 左移运算符“”是双目运算符。左移n位就是乘以2的n次方。 其功能把“”左边的运算数的各二进位全部左移若干位，由“”右边的数指定移动的位数，高位丢弃，低位补0。

1）例： a4 指把a的各二进位向左移动4位。如a=00000011(十进制3)，左移4位后为00110000(十进制48)。

2）例： int i = 1; i = i 2; //把i里的值左移2位 也就是说,1的2进制是000...0001(这里1前面0的个数和int的位数有关,32位机器,gcc里有31个0),左移2位之后变成 000...0100,也就是10进制的4,所以说左移1位相当于乘以2,那么左移n位就是乘以2的n次方了(有符号数不完全适用,因为左移有可能导致符号变化,下面解释原因)

需要注意的一个问题是：int类型最左端的符号位和移位移出去的情况. 我们知道,int是有符号的整形数,最左端的1位是符号位,即0正1负,那么移位的时候就会出现溢出, 例如: int i = 0x40000000; //16进制的40000000,为2进制的01000000...0000 i = i 1; 那么,i在左移1位之后就会变成0x80000000,也就是2进制的100000...0000,符号位被置1,其他位全是0,变成了int类型所能表示的最小值,32位的int这个值是,溢出.如果再接着把i左移1位会出现什么情况呢?

在C语言中采用了丢弃最高位的处理方法,丢弃了1之后,i的值变成了0. 左移里一个比较特殊的情况是当左移的位数超过该数值类型的最大位数时,编译器会用左移的位数去模类型的最大位数,然后按余数进行移位,如: int i = 1, j = 0x80000000; //设int为32位 i = i 33; // 33 % 32 = 1 左移1位,i变成2 j = j 33; // 33 % 32 = 1 左移1位,j变成0,最高位被丢弃 在用gcc编译这段程序的时候编译器会给出一个warning,说左移位数=类型长度.那么实际上i,j移动的就是1位,也就是33%32后的余数.在gcc下是这个规则,不同编译器可能会不完全相同.

总之左移就是: 丢弃最高位,0补最低位 右移运算符“”是双目运算符。右移n位就是除以2的n次方

其功能是把“”左边的运算数的各二进位全部右移若干位，“”右边的数指定移动的位数。

例如：设 a=15，a2 表示把00001111右移为00000011(十进制3)。 应该说明的是，对于有符号数，在右移时，符号位将随同移动。当为正数时， 最高位补0，而为负数时，符号位为1，最高位是补0或是补1 取决于编译系统的规定。Turbo C和很多系统规定为补1。

右移对符号位的处理和左移不同： 对于有符号整数来说,比如int类型,右移会保持符号位不变,

例如: int i = 0x80000000; i = i 1; //i的值不会变成0x40000000,而会变成0xc0000000 就是说,对于有符号数， 符号位向右移动后,正数的话补0,负数补1, 对于有符号数，在右移时，符号位将随同移动： 当为正数时， 最高位补0， 而为负数时，符号位为1， 也就是汇编语言中的算术右移.同样当移动的位数超过类型的长度时,会取余数,然后移动余数个位. 最高位是补0或是补1 取决于编译系统的规定。Turbo C和很多系统规定为补1。 负数10100110 5(假设字长为8位)，则得到的是 11111101 总之,在C中,左移是逻辑/算术左移(两者完全相同),右移是算术右移,会保持符号位不变.实际应用中可以根据情况用左/右移做快速的乘/除运算,这样会比循环效

率高很多. x1;//相当于x/=2x1;//相当于x*=2x2;//x/=4x2;//x*=4x3;//x/=8x3;//x*=8以此类推. 无符号： main()　{　unsigneda,b;　printf(inputanumber:);　scanf(%d,a);　b=a5;　b=b15;　printf(a=%d\tb=%d\n,a,b);　}　请再看一例! main(){    chara='a',b='b';    intp,c,d;    p=a;    p=(p8)|b;    d=p0xff;    c=(p0xff00)8;    printf(a=%d\nb=%d\nc=%d\nd=%d\n,a,b,c,d);} 1. 使特定位翻转 要使哪几位翻转就将与其进行∧运算的该几位置为1即可。

2 与0相∧，保留原值.

3.交换两个值，不用临时变量. 我们可以在不用引入其他变量就可以实现变量值的交换 用异或操作可以实现： a = a^b; //

(1) b = a^b; //

(2) a = a^b; //

(3) 异或操作满足结合律和交换律，且由异或操作的性质知道，对于任意一个整数a^a=0； 证：(第(2)步中的a) a = a^b =(将第(1)步中的b代入b) a^(a^b) = b; (第(3)步中的b)b =a^b = (将第(1)步中的b代入b，将第(2)步中的a代入a) a^b^a^a^b = a^a^a^b^b = a; 清零 A数中为1的位，B中相应位为0。然后使二者进行运算，即可达到对A清零目的。

取一个数中某些指定位 取数A的某些位，把数B的某些位置1，就把数A的某些位与1按位与即可。

保留一位的方法 数A与数B进行运算，数B在数A要保留的位1，其余位为零。

判断奇偶性 将变量 a的奇偶性。a与1做位与运算，若结果是1，则 a是奇数；将 a与1做位与运算，若结果是0，则 a是偶数。 判断int型变量a是奇数还是偶数 a1 = 0 偶数 a1 = 1 奇数

取int型变量a的第k位 (k=0,1,2……sizeof(int))，即ak1

将int型变量a的第k位清0，即a=a~(1k)

将int型变量a的第k位置1， 即a=a|(1k)

int型变量循环左移k次，即a=ak|a16-k (设sizeof(int)=16)

int型变量a循环右移k次，即a=ak|a16-k (设sizeof(int)=16)

整数的平均值

对于两个整数x,y，如果用 (x+y)/2 求平均值，会产生溢出，因为 x+y 可能会大于INT_MAX，但是我们知道它们的平均值是肯定不会绯龅模?颐怯萌缦滤惴ǎ?/DIV int average(int x, int y) //返回X,Y 的平均值 { return (xy)+((x^y)1); }

判断一个整数是不是2的幂,对于一个数 x = 0，判断他是不是2的幂 boolean power2(int x) { return ((x(x-1))==0)(x!=0)； }

不用temp交换两个整数 void swap(int x , int y) { x ^= y; y ^= x; x ^= y; } php: $a ='dd'; $b = 'bb'; $a = $a ^ $b; $b = $a ^ $b;

$a = $a ^ $b; echo $a,' ', $b; 10 计算绝对值 int abs( int x ) { int y ; y = x 31 ; return (x^y)-y ; //or: (x+y)^y }

取模运算转化成位运算 (在不产生溢出的情况下) a % (2^n) 等价于 a (2^n - 1) 12 乘法运算转化成位运算 (在不产生溢出的情况下) a * (2^n) 等价于 a n 13. 除法运算转化成位运算 (在不产生溢出的情况下) a / (2^n) 等价于 a n 例: 12/8 == 123 14 . a % 2 等价于 a 1 15 if (x == a) x= b; else x= a; 等价于 x= a ^ b ^ x;

16 x 的 相反数 表示为 (~x+1)abc

JAVA中四个二进制位从操作符即（&按位与、|按位货、^按位异或、~按位取反）

首先回答你问的问题：

按位与运算符（）

参加运算的两个数据，按二进制位进行“与”运算。

运算规则：00=0; 01=0; 10=0; 11=1;

即：两位同时为“1”，结果才为“1”，否则为0

例如：35 即 0000 0011 0000 0101 = 0000 0001 因此，35的值得1。

另，负数按补码形式参加按位与运算。

“与运算”的特殊用途：

（1）清零。如果想将一个单元清零，即使其全部二进制位为0，只要与一个各位都为零的数值相与，结果为零。

（2）取一个数中指定位

方法：找一个数，对应X要取的位，该数的对应位为1，其余位为零，此数与X进行“与运算”可以得到X中的指定位。

例：设X=10101110，

取X的低4位，用 X 0000 1111 = 0000 1110 即可得到；

还可用来取X的2、4、6位。

按位或运算符（|）

参加运算的两个对象，按二进制位进行“或”运算。

运算规则：0|0=0； 0|1=1； 1|0=1； 1|1=1；

即 ：参加运算的两个对象只要有一个为1，其值为1。

例如:3|5 即 0000 0011 | 0000 0101 = 0000 0111 因此，3|5的值得7。

另，负数按补码形式参加按位或运算。

“或运算”特殊作用：

（1）常用来对一个数据的某些位置1。

方法：找到一个数，对应X要置1的位，该数的对应位为1，其余位为零。此数与X相或可使X中的某些位置1。

例：将X=10100000的低4位置1 ，用 X | 0000 1111 = 1010 1111即可得到。

异或运算符（^）

参加运算的两个数据，按二进制位进行“异或”运算。

运算规则：0^0=0； 0^1=1； 1^0=1； 1^1=0；

即：参加运算的两个对象，如果两个相应位为“异”（值不同），则该位结果为1，否则为0。

“异或运算”的特殊作用：

（1）使特定位翻转找一个数，对应X要翻转的各位，该数的对应位为1，其余位为零，此数与X对应位异或即可。

例：X=10101110，使X低4位翻转，用X ^ 0000 1111 = 1010 0001即可得到。

（2）与0相异或，保留原值 ，X ^ 0000 0000 = 1010 1110。

从上面的例题可以清楚的看到这一点。

取反运算符（~）

参加运算的一个数据，按二进制位进行“取反”运算。

运算规则：~1=0； ~0=1；

即：对一个二进制数按位取反，即将0变1，1变0。

使一个数的最低位为零，可以表示为：a~1。

~1的值为1111111111111110，再按“与”运算，最低位一定为0。因为“~”运算符的优先级比算术运算符、关系运算符、逻辑运算符和其他运算符都高。

然后在附送你两个为运算符的解释：

左移运算符（）

将一个运算对象的各二进制位全部左移若干位（左边的二进制位丢弃，右边补0）。

例：a = a 2 将a的二进制位左移2位，右补0，

左移1位后a = a * 2;

若左移时舍弃的高位不包含1，则每左移一位，相当于该数乘以2。

右移运算符（）

将一个数的各二进制位全部右移若干位，正数左补0，负数左补1，右边丢弃。

操作数每右移一位，相当于该数除以2。

例如：a = a 2 将a的二进制位右移2位，

左补0 or 补1 得看被移数是正还是负。

如果还有什么疑问，可以参考一下参考资料

希望我的回答对您有帮助，别忘了采纳答案哦~

JAVA计算器长整数实现

public class BigIntegerextends Numberimplements ComparableBigInteger不可变的任意精度的整数。所有操作中，都以二进制补码形式表示 BigInteger（如 Java 的基本整数类型）。BigInteger 提供所有 Java 的基本整数操作符的对应物，并提供 java.lang.Math 的所有相关方法。另外，BigInteger 还提供以下运算：模算术、GCD 计算、质数测试、素数生成、位操作以及一些其他操作。

算术运算的语义完全模仿 Java 整数算术运算符的语义，如 The Java Language Specification 中所定义的。例如，以零作为除数的除法抛出 ArithmeticException，而负数除以正数的除法则产生一个负（或零）的余数。Spec 中关于溢出的细节都被忽略了，因为 BigIntegers 所设置的实际大小能适应操作结果的需要。

位移操作的语义扩展了 Java 的位移操作符的语义以允许产生负位移距离。带有负位移距离的右移操作会导致左移操作，反之亦然。忽略无符号的右位移运算符（），因为该操作与由此类提供的“无穷大的词大小”抽象结合使用时毫无意义。

逐位逻辑运算的语义完全模仿 Java 的逐位整数运算符的语义。在执行操作之前，二进制运算符（and、or、xor）对两个操作数中的较短操作数隐式执行符号扩展。

比较操作执行有符号的整数比较，类似于 Java 的关系运算符和相等性运算符执行的比较。

提供的模算术操作用来计算余数、求幂和乘法可逆元。这些方法始终返回非负结果，范围在 0 和 (modulus - 1)（包括）之间。

位操作对其操作数的二进制补码表示形式的单个位进行操作。如有必要，操作数会通过扩展符号来包含指定的位。单一位操作不能产生与正在被操作的 BigInteger 符号不同的 BigInteger，因为它们仅仅影响单个位，并且此类提供的“无穷大词大小”抽象可保证在每个 BigInteger 前存在无穷多的“虚拟符号位”数。

为了简洁明了，在整个 BigInteger 方法的描述中都使用了伪代码。伪代码表达式 (i + j) 是“其值为 BigInteger i 加 BigInteger j 的 BigInteger”的简写。伪代码表达式 (i == j) 是“当且仅当 BigInteger i 表示与 BigInteger j 相同的值时，才为 true”的简写。可以类似地解释其他伪代码表达式。

当为任何输入参数传递 null 对象引用时，此类中的所有方法和构造方法都将抛出 NullPointerException。

从以下版本开始：

JDK1.1

另请参见：

BigDecimal, 序列化表格

--------------------------------------------------------------------------------

字段摘要

static BigInteger ONE

BigInteger 的常量 1。

static BigInteger TEN

BigInteger 的常量 10。

static BigInteger ZERO

BigInteger 的常量 0。

构造方法摘要

BigInteger(byte[] val)

将包含 BigInteger 的二进制补码表示形式的 byte 数组转换为 BigInteger。

BigInteger(int signum, byte[] magnitude)

将 BigInteger 的符号-数量表示形式转换为 BigInteger。

BigInteger(int bitLength, int certainty, Random rnd)

构造一个随机生成的正 BigInteger，它可能是一个具有指定 bitLength 的素数。

BigInteger(int numBits, Random rnd)

构造一个随机生成的 BigInteger，它是在 0 到 (2numBits - 1)（包括）范围内均匀分布的值。

BigInteger(String val)

将 BigInteger 的十进制字符串表示形式转换为 BigInteger。

BigInteger(String val, int radix)

将指定基数的 BigInteger 的字符串表示形式转换为 BigInteger。

方法摘要

BigInteger abs()

返回其值是此 BigInteger 的绝对值的 BigInteger。

BigInteger add(BigInteger val)

返回其值为 (this + val) 的 BigInteger。

BigInteger and(BigInteger val)

返回其值为 (this val) 的 BigInteger。

BigInteger andNot(BigInteger val)

返回其值为 (this ~val) 的 BigInteger。

int bitCount()

返回此 BigInteger 的二进制补码表示形式中与符号不同的位的数量。

int bitLength()

返回此 BigInteger 的最小的二进制补码表示形式的位数，不包括 符号位。

BigInteger clearBit(int n)

返回其值与清除了指定位的此 BigInteger 等效的 BigInteger。

int compareTo(BigInteger val)

将此 BigInteger 与指定的 BigInteger 进行比较。

BigInteger divide(BigInteger val)

返回其值为 (this / val) 的 BigInteger。

BigInteger[] divideAndRemainder(BigInteger val)

返回包含 (this / val) 后跟 (this % val) 的两个 BigInteger 的数组。

double doubleValue()

将此 BigInteger 转换为 double。

boolean equals(Object x)

比较此 BigInteger 与指定的 Object 的相等性。

BigInteger flipBit(int n)

返回其值与对此 BigInteger 进行指定位翻转后的值等效的 BigInteger。

float floatValue()

将此 BigInteger 转换为 float。

BigInteger gcd(BigInteger val)

返回一个 BigInteger，其值是 abs(this) 和 abs(val) 的最大公约数。

int getLowestSetBit()

返回此 BigInteger 最右端（最低位）1 比特的索引（即从此字节的右端开始到本字节中最右端 1 比特之间的 0 比特的位数）。

int hashCode()

返回此 BigInteger 的哈希码。

int intValue()

将此 BigInteger 转换为 int。

boolean isProbablePrime(int certainty)

如果此 BigInteger 可能为素数，则返回 true，如果它一定为合数，则返回 false。

long longValue()

将此 BigInteger 转换为 long。

BigInteger max(BigInteger val)

返回此 BigInteger 和 val 的最大值。

BigInteger min(BigInteger val)

返回此 BigInteger 和 val 的最小值。

BigInteger mod(BigInteger m)

返回其值为 (this mod m) 的 BigInteger。

BigInteger modInverse(BigInteger m)

返回其值为 (this-1 mod m) 的 BigInteger。

BigInteger modPow(BigInteger exponent, BigInteger m)

返回其值为 (thisexponent mod m) 的 BigInteger。

BigInteger multiply(BigInteger val)

返回其值为 (this * val) 的 BigInteger。

BigInteger negate()

返回其值是 (-this) 的 BigInteger。

BigInteger nextProbablePrime()

返回大于此 BigInteger 的可能为素数的第一个整数。

BigInteger not()

返回其值为 (~this) 的 BigInteger。

BigInteger or(BigInteger val)

返回其值为 (this | val) 的 BigInteger。

BigInteger pow(int exponent)

返回其值为 (thisexponent) 的 BigInteger。

static BigInteger probablePrime(int bitLength, Random rnd)

返回有可能是素数的、具有指定长度的正 BigInteger。

BigInteger remainder(BigInteger val)

返回其值为 (this % val) 的 BigInteger。

BigInteger setBit(int n)

返回其值与设置了指定位的此 BigInteger 等效的 BigInteger。

BigInteger shiftLeft(int n)

返回其值为 (this n) 的 BigInteger。

BigInteger shiftRight(int n)

返回其值为 (this n) 的 BigInteger。

int signum()

返回此 BigInteger 的正负号函数。

BigInteger subtract(BigInteger val)

返回其值为 (this - val) 的 BigInteger。

boolean testBit(int n)

当且仅当设置了指定的位时，返回 true。

byte[] toByteArray()

返回一个 byte 数组，该数组包含此 BigInteger 的二进制补码表示形式。

String toString()

返回此 BigInteger 的十进制字符串表示形式。

String toString(int radix)

返回此 BigInteger 的给定基数的字符串表示形式。

static BigInteger valueOf(long val)

返回其值等于指定 long 的值的 BigInteger。

BigInteger xor(BigInteger val)

返回其值为 (this ^ val) 的 BigInteger。

从类 java.lang.Number 继承的方法

byteValue, shortValue

从类 java.lang.Object 继承的方法

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

标签：指定位翻转