java位运算或
㈠ 求：java中常用位运算符及其用法详解
位运算符
位运算是以二进制位为单位进行的运算，其操作数和运算结果都是整型值。
位运算符共有7个，分别是：位与（&）、位或（|）、位非（~）、位异或（^）、右移（>>）、左移（<<）、0填充的右移（>>>）。
位运算的位与（&）、位或（|）、位非（~）、位异或（^）与逻辑运算的相应操作的真值表完全相同，其差别只是位运算操作的操作数和运算结果都是二进制整数，而逻辑运算相应操作的操作数和运算结果都是逻辑值。
位运算示例
运算符 名称 示例 说明
& 位与 x&y 把x和y按位求与
| 位或 x|y 把x和y按位求或
~ 位非 ~x 把x按位求非
^ 位异或 x^y 把x和y按位求异或
>> 右移 x>>y 把x的各位右移y位
<< 左移 x<<y 把x的各位左移y位
>>> 右移 x>>>y 把x的各位右移y位，左边填0
举例说明：
（1）有如下程序段：
int x = 64; //x等于二进制数的01000000
int y = 70; //y等于二进制数的01000110
int z = x&y //z等于二进制数的01000000
即运算结果为z等于二进制数01000000。位或、位非、位异或的运算方法类同。
（2）右移是将一个二进制数按指定移动的位数向右移位，移掉的被丢弃，左边移进的部分或者补0（当该数为正时），或者补1（当该数为负时）。这是因为整数在机器内部采用补码表示法，正数的符号位为0，负数的符号位为1。例如，对于如下程序段：
int x = 70; //x等于二进制数的01000110
int y = 2;
int z = x>>y //z等于二进制数的00010001
即运算结果为z等于二进制数00010001，即z等于十进制数17。
对于如下程序段：
int x = -70; //x等于二进制数的11000110
int y = 2;
int z = x>>y //z等于二进制数的11101110
即运算结果为z等于二进制数11101110，即z等于十进制数-18。要透彻理解右移和左移操作，读者需要掌握整数机器数的补码表示法。
（3）0填充的右移（>>>）是不论被移动数是正数还是负数，左边移进的部分一律补0。
㈡ Java中位运算符的具体应用是什么，在实际编程中有什么作用
位逻辑运算符有“与”（AND）、“或”（OR）、“异或（XOR）”、“非（NOT）”，分别用“&”、“|”、“^”、“~”表示。
下面的例子说明了位逻辑运算符：
//
Demonstrate
the
bitwise
logical
operators.
class
BitLogic
{
public
static
void
main(String
args[])
{
String
binary[]
=
{
"0000",
"0001",
"0010",
"0011",
"0100",
"0101",
"0110",
"0111",
"1000",
"1001",
"1010",
"1011",
"1100",
"1101",
"1110",
"1111"
};
int
a
=
3;
//
0
+
2
+
1
or
0011
in
binary
int
b
=
6;
//
4
+
2
+
0
or
0110
in
binary
int
c
=
a
|
b;
int
d
=
a
&
b;
int
e
=
a
^
b;
int
f
=
(~a
&
b)
|
(a
&
~b);
int
g
=
~a
&
0x0f;
System.out.println("
a
=
"
+
binary[a]);
System.out.println("
b
=
"
+
binary[b]);
System.out.println("
a|b
=
"
+
binary[c]);
System.out.println("
a&b
=
"
+
binary[d]);
System.out.println("
a^b
=
"
+
binary[e]);
System.out.println("~a&b|a&~b
=
"
+
binary[f]);
System.out.println("
~a
=
"
+
binary[g]);
}
}
在本例中，变量a与b对应位的组合代表了二进制数所有的
4
种组合模式：0-0，0-1，1-0，和1-1。“|”运算符和“&”运算符分别对变量a与b各个对应位的运算得到了变量c和变量d的值。对变量e和f的赋值说明了“^”运算符的功能。字符串数组binary代表了0到15对应的二进制的值。在本例中，数组各元素的排列顺序显示了变量对应值的二进制代码。数组之所以这样构造是因为变量的值n对应的二进制代码可以被正确的存储在数组对应元素binary[n]中。例如变量a的值为3，则它的二进制代码对应地存储在数组元素binary[3]中。~a的值与数字0x0f
（对应二进制为0000
1111）进行按位与运算的目的是减小~a的值，保证变量g的结果小于16。因此该程序的运行结果可以用数组binary对应的元素来表示。
㈢ JAVA位运算符
运算符含义示例
~按位非（NOT）b=~a
&按位与（AND）c=a&b
|按位或（OR）c=a|b
^按位异或（XOR）c=a^b
>>右移b=a>>2
>>>右移，左边空出的位以0填充b=a>>>2
<<左移b=a<<1
当然同样有&=，|=，^=，>>=，>>>=，<<=。
有关这些操作的细节可以参看
http://www.pcvc.net/category/content.asp?sendid=247
位运算
前面介绍的各种运算都是以字节作为最基本位进行的。但在很多系统程序中常要求在位(bit)一级进行运算或处理。C语言提供了位运算的功能，这使得C语言也能像汇编语言一样用来编写系统程序。
一、位运算符C语言提供了六种位运算符：
&按位与
|按位或
^按位异或
~取反
<<左移
>>右移
1.按位与运算按位与运算符"&"是双目运算符。其功能是参与运算的两数各对应的二进位相与。只有对应的两个二进位均为1时，结果位才为1，否则为0。参与运算的数以补码方式出现。
例如：9&5可写算式如下：00001001(9的二进制补码)&00000101(5的二进制补码)00000001(1的二进制补码)可见9&5=1。
按位与运算通常用来对某些位清0或保留某些位。例如把a的高八位清0，保留低八位，可作a&255运算(255的二进制数为0000000011111111)。
main(){
inta=9,b=5,c;
c=a&b;
printf("a=%d b=%d c=%d ",a,b,c);
}
2.按位或运算按位或运算符“|”是双目运算符。其功能是参与运算的两数各对应的二进位相或。只要对应的二个二进位有一个为1时，结果位就为1。参与运算的两个数均以补码出现。
例如：9|5可写算式如下：00001001|00000101
00001101(十进制为13)可见9|5=13
main(){
inta=9,b=5,c;
c=a|b;
printf("a=%d b=%d c=%d ",a,b,c);
}
3.按位异或运算按位异或运算符“^”是双目运算符。其功能是参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。参与运算数仍以补码出现，例如9^5可写成算式如下：00001001^0000010100001100(十进制为12)
main(){
inta=9;
a=a^15;
printf("a=%d ",a);
}
4.求反运算求反运算符～为单目运算符，具有右结合性。其功能是对参与运算的数的各二进位按位求反。例如～9的运算为：~(0000000000001001)结果为：1111111111110110
5.左移运算左移运算符“<<”是双目运算符。其功能把“<<”左边的运算数的各二进位全部左移若干位，由“<<”右边的数指定移动的位数，
高位丢弃，低位补0。例如：a<<4指把a的各二进位向左移动4位。如a=00000011(十进制3)，左移4位后为00110000(十进制48)。6.右移运算右移运算符“>>”是双目运算符。其功能是把“>>”左边的运算数的各二进位全部右移若干位，“>>”右边的数指定移动的位数。
例如：设a=15，a>>2表示把000001111右移为00000011(十进制3)。应该说明的是，对于有符号数，在右移时，符号位将随同移动。当为正数时，最高位补0，而为负数时，符号位为1，最高位是补0或是补1取决于编译系统的规定。TurboC和很多系统规定为补1。
㈣ JAVA位运算符
运算符 含义 示例
~ 按位非（NOT） b = ~a
& 按位与（AND） c = a & b
| 按位或（OR） c = a | b
^ 按位异或（XOR） c = a ^ b
>> 右移 b = a >> 2
>>> 右移，左边空出的位以0填充 b = a >>> 2
<< 左移 b = a << 1
当然同样有 &=，|=，^=，>>=，>>>=，<<=。
有关这些操作的细节可以参看
www.pcvc.net/...id=247
位运算
前面介绍的各种运算都是以字节作为最基本位进行的。 但在很多系统程序中常要求在位(bit)一级进行运算或处理。C语言提供了位运算的功能， 这使得C语言也能像汇编语言一样用来编写系统程序。
一、位运算符C语言提供了六种位运算符：
& 按位与
| 按位或
^ 按位异或
~ 取反
<< 左移
>> 右移
1. 按位与运算 按位与运算符"&"是双目运算符。其功能是参与运算的两数各对应的二进位相与。只有对应的两个二进位均为1时，结果位才为1 ，否则为0。参与运算的数以补码方式出现。
例如：9&5可写算式如下： 00001001 (9的二进制补码)&00000101 (5的二进制补码) 00000001 (1的二进制补码)可见9&5=1。
按位与运算通常用来对某些位清0或保留某些位。例如把a 的高八位清 0 ， 保留低八位， 可作 a&255 运算 ( 255 的二进制数为0000000011111111)。
main(){
int a=9,b=5,c;
c=a&b;
printf("a=%d\nb=%d\nc=%d\n",a,b,c);
}
2. 按位或运算 按位或运算符“|”是双目运算符。其功能是参与运算的两数各对应的二进位相或。只要对应的二个二进位有一个为1时，结果位就为1。参与运算的两个数均以补码出现。
例如：9|5可写算式如下： 00001001|00000101
00001101 (十进制为13)可见9|5=13
main(){
int a=9,b=5,c;
c=a|b;
printf("a=%d\nb=%d\nc=%d\n",a,b,c);
}
3. 按位异或运算 按位异或运算符“^”是双目运算符。
㈤ 请教java位运算问题
Java 位运算 Java 位运算[转]一，Java 位运算1.表示方法： 在Java语言中，二进制数使用补码表示，最高位为符号位，正数的符号位为0，负数为1。补码的表示需要满足如下要求。 (l)正数的最高位为0，其余各位代表数值本身(二进制数)。 (2)对于负数，通过对该数绝对值的补码按位取反，再对整个数加1。2.位运算符 位运算表达式由操作数和位运算符组成，实现对整数类型的二进制数进行位运算。位运算符可以分为逻辑运算符(包括~、＆、|和^)及移位运算符(包括>>、>)。1)左移位运算符（）则将运算符左边的运算对象向右移动运算符右侧指定的位数。“有符号”右移位运算符使用了“符号扩展”：若值为正，则在高位插入0；若值为负，则在高位插入1。3)Java也添加了一种“无符号”右移位运算符（>>>），它使用了“零扩展”：无论正负，都在高位插入0。这一运算符是C或C++没有的。
㈥ JAVA位运算符
然后呢？位运算怎么了？
说说位运算常用的几种吧。
首先基本概念:
你要明白 "与" 和 "或" 都代表什么意思,“与”表示同时满足,也称同时为真,然后其结果才能为满足或真,否者一概为不满足或假;"或"表示只需要满足一个,也可以说只要一个为真,然后其结果就为满足或者,除非两个都不满足,其结果才表示不满足。
接下来说常用的4种位运算符:按位与(&)、按位或(|)、带符号左移(<<)、带符号右移(>>)
& 表示按位与,需要按位的意思是,首先将符号两边均换算成二进制，然后按位做 与 操作,没有内容的以0计算。比如，1&7 相当于 001 &111 相当于 0&1 0&1 1&1 最后得到结果 001 也就是1 ;
| 表示按位或,其他内容与&一致,只有换成二进制后做的操作时 按位或,同上例:1|7 相当于 001|111 相当于 0|1 0|1 1|1 最后得到结果 111 也就是 7;
<< 表示左移,举例说明: 7 << 1 首先只将符号左侧内容换算成二进制 111 然后,向左移位,需要移多少位？这时候就用到符号右侧的数字1,即表示移1位,缺失的依旧补0,所以就变成了1110,也就是14
>> 表示右移,和左移一样,比如 7>>1 就表示 111向右移动一位,就变成了11,多余的位会被舍弃.
还有其他的不太常用的 比如 按位 异或 , 无符号移位运算,如果感兴趣，也可以去了解
㈦ java 按位运算
你的这个设计有问题。
位运算来进行逻辑判断，其实就是用数字的二进制各位来做标志。通过位运算，进行权限的组合和拆分。
这样有个基础：就是每个权限的值正好要是二进制位的对应值。
权限可以取的数就是二进制的进度值。如：1,2,4,8,16,32……(不超过数字表达范围）。
看你的题目: 3是发帖，4是删帖。要用二进制来做掩码计算。设计不科学。
两个方法：
1 建议使用1，2，4，8……来定义的你的权限。
如果改成：4是发帖，8是删帖
long power=4|8;
判断是否有发帖权限：power&4 >0
2 如果一定要用1，2，3，4来定义，那么要做进制操作。
long power=(1<<(3-1))|(1<<(4-1));
判断是否有发帖权限：(power&(1<<(3-1))) > 0
注：如果上面都不减去1，也行，就浪费一个位置。
㈧ JAVA位运算符
位操作符（bitwise operator）
位操作符允许我们操作一个基本数据类型中的整数型值的单个“比特（bit）”，即二进制位。
位操作符会对两个参数对应的位执行布尔代数运算，并最终生成一个结果。
位操作符来源于 C 语言面向底层的操作，那时我们经常需要直接操纵硬件，设置硬件寄存
器内的二进制位。Java的设计初衷是嵌入电视机顶盒内，所以这种低级操作仍被保留了下来。
但是，我们可能不会过多地使用到位运算符。
如果两个输入位都是 1，则按位“与”操作符（&）生成一个输出位 1；否则生成一个输出
位0。如果两个输入位里只要有一个是1，则按位“或”操作符（|）生成一个输出位1；只
有在两个输入位都是0的情况下，它才会生成一个输出位0。如果两个输入位的某一个是1，
但不全都是1，那么“异或”操作（^）生成一个输出位1。按位“非”（~ ，也称为取补运
算，ones compliement operator ）属于一元操作符；它只对一个操作数进行操作（其他位操
作是二元运算）。按位“非”生成与输入位相反的值——若输入0，则输出1；输入1，则输
出0。
位操作符和逻辑操作符都使用了同样的符号。因此，我们能方便地记住它们的含义：由于“位”
是非常“小”的，所以位操作符仅使用了一位符号。
位操作符可与等号（=）联合使用，以便合并运算操作和赋值操作：&=，|=和^=都是合法
的（由于~是一元操作符，所以不可与=联合使用）。
我们将布尔类型（boolean）作为一种“单比特”值对待，所以它多少有些独特的地方。我们
可对它执行按位“与”、“或”和“异或”运算，但不能执行按位“非”（大概是为了避免与
逻辑 NOT 混淆）。对于布尔值，位操作符具有与逻辑操作符相同的效果，只是它们不会中
途“短路”。此外，针对布尔值进行的按位运算为我们新增了一个“异或”逻辑操作符，它并
未包括在“逻辑”操作符的列表中。在移位表达式中，我们被禁止使用布尔运算，原因将在下
面解释。
移位操作符（shift operator）
移位操作符操作的运算对象也是二进制的“位”，但是它们只可以被用来处理整数类型（基本
类型的一种）。左移位操作符（<<）能将操作符左边的运算对象向左移动操作符右侧指定的
位数（在低位补 0）。“有符号”右移位操作符（>>）则将操作符左边的运算对象向右移动操
作符右侧指定的位数。“有符号”右移位操作符使用了“符号扩展”：若符号为正，则在高位插
入0；若符号为负，则在高位插入1。Java中增加了一种“无符号”右移位操作符（>>>），它
使用了“零扩展”：无论正负，都在高位插入0。这一操作符是C或C++没有的。
如果对char、byte或者short类型的数值进行移位处理，那么在移位进行之前，它们会自动
转换为int，并且得到的结果也是一个int类型的值。而右侧操作数，作为真正移位的位数，
只有其二进制表示中的低5位才有用。这样可防止我们移位超过int型值所具有的位数。（译
注：因为2的5次方为32，而int型值只有32位）。若对一个long类型的数值进行处理，
最后得到的结果也是long。此时只会用到右侧操作数的低6位，以防止移位超过long型数
值具有的位数。
移位可与等号（<<=或>>=或>>>=）组合使用。此时，操作符左边的值会移动由右边的值指
定的位数，再将得到的结果赋回左边的变量。但在进行“无符号”右移结合赋值操作时，可能
会遇到一个问题：如果对byte或short值进行这样的移位运算，得到的可能不是正确的结果。
它们会先被转换成int类型，再进行右移操作。然后被截断，赋值给原来的类型，在这种情
况下可能得到-1的结果。下面这个例子演示了这种情况：
//: c03:URShift.java
// Test of unsigned right shift.
import com.bruceeckel.simpletest.*;
public class URShift {
static Test monitor = new Test();
public static void main(String[] args) {
int i = -1;
System.out.println(i >>>= 10);
long l = -1;
System.out.println(l >>>= 10);
short s = -1;
System.out.println(s >>>= 10);
byte b = -1;
System.out.println(b >>>= 10);
b = -1;
System.out.println(b>>>10);
monitor.expect(new String[] {
"4194303",
"18014398509481983",
"-1",
"-1",
"4194303"
});
}
} ///:~
在最后一个移位运算中，结果没有赋回给b，而是直接打印出来，所以其结果是正确的。
下面这个例子向大家阐示了如何应用涉及“按位”操作的所有操作符：
//: c03:BitManipulation.java
// Using the bitwise operators.
import com.bruceeckel.simpletest.*;
import java.util.*;
public class BitManipulation {
static Test monitor = new Test();
public static void main(String[] args) {
Random rand = new Random();
int i = rand.nextInt();
int j = rand.nextInt();
printBinaryInt("-1", -1);
printBinaryInt("+1", +1);
int maxpos = 2147483647;
printBinaryInt("maxpos", maxpos);
int maxneg = -2147483648;
printBinaryInt("maxneg", maxneg);
printBinaryInt("i", i);
printBinaryInt("~i", ~i);
printBinaryInt("-i", -i);
printBinaryInt("j", j);
printBinaryInt("i & j", i & j);
printBinaryInt("i | j", i | j);
printBinaryInt("i ^ j", i ^ j);
printBinaryInt("i << 5", i << 5);
printBinaryInt("i >> 5", i >> 5);
printBinaryInt("(~i) >> 5", (~i) >> 5);
printBinaryInt("i >>> 5", i >>> 5);
printBinaryInt("(~i) >>> 5", (~i) >>> 5);
long l = rand.nextLong();
long m = rand.nextLong();
printBinaryLong("-1L", -1L);
printBinaryLong("+1L", +1L);
long ll = 9223372036854775807L;
printBinaryLong("maxpos", ll);
long lln = -9223372036854775808L;
printBinaryLong("maxneg", lln);
printBinaryLong("l", l);
printBinaryLong("~l", ~l);
printBinaryLong("-l", -l);
printBinaryLong("m", m);
printBinaryLong("l & m", l & m);
printBinaryLong("l | m", l | m);
printBinaryLong("l ^ m", l ^ m);
printBinaryLong("l << 5", l << 5);
printBinaryLong("l >> 5", l >> 5);
printBinaryLong("(~l) >> 5", (~l) >> 5);
printBinaryLong("l >>> 5", l >>> 5);
printBinaryLong("(~l) >>> 5", (~l) >>> 5);
monitor.expect("BitManipulation.out");
}
static void printBinaryInt(String s, int i) {
System.out.println(
s + ", int: " + i + ", binary: ");
System.out.print(" ");
for(int j = 31; j >= 0; j--)
if(((1 << j) & i) != 0)
System.out.print("1");
else
System.out.print("0");
System.out.println();
}
static void printBinaryLong(String s, long l) {
System.out.println(
s + ", long: " + l + ", binary: ");
System.out.print(" ");
for(int i = 63; i >= 0; i--)
if(((1L << i) & l) != 0)
System.out.print("1");
else
System.out.print("0");
System.out.println();
}
} ///:~
程序末尾调用了两个方法：printBinaryInt()和printBinaryLong()。它们分别接受
一个 int 或 long 值的参数，并用二进制格式输出，同时附有简要的说明文字。你可以暂
时忽略它们具体是如何实现的。
请注意这里是用 System.out.print()，而不是 System.out.println()。print()方法不自动换行，所
以我们能在同一行里输出多个信息。
上面的例子中，expect() 以一个文件名作参数，它会从这个文件中读取预期的行（其中
可以有，也可以没有正则表达式）。对于那些太长，不适宜列在书里的输出，这种做法很有
用。这个文件的扩展名是“.out”，是所发布的代码的一部分，可以从www.BruceEckel.com下
载。如果有兴趣的话，可以打开这个文件，看看正确的输出应该是什么（或者你自己直接运
行一下前面这个程序）。
上面的例子展示了对int和long的所有按位运算的效果，还展示了int和long的最小值、最
大值、+1和-1值，以及它们的二进制形式，以使大家了解它们在机器中的具体形式。注意，
最高位表示符号：0为正，1为负。下面列出例子中关于int部分的输出：
-1, int: -1, binary:
+1, int: 1, binary:
maxpos, int: 2147483647, binary:
maxneg, int: -2147483648, binary:
i, int: 59081716, binary:
~i, int: -59081717, binary:
-i, int: -59081716, binary:
j, int: 198850956, binary:
i & j, int: 58720644, binary:
i | j, int: 199212028, binary:
i ^ j, int: 140491384, binary:
i << 5, int: 1890614912, binary:
i >> 5, int: 1846303, binary:
(~i) >> 5, int: -1846304, binary:
i >>> 5, int: 1846303, binary:
(~i) >>> 5, int: 132371424, binary:
数字的二进制表示形式被称为“有符号的2的补码”。