byte类型在java中用1个字节存储，有8个比特数，有符号位范围是-2的（8-1）次方到2的（8-1）次方减1，即-128~127（由于有一个比特数用于存放符号）；所以无符号的话，8位比特数全用来表示数值范围，最低值为00000000（二进制数），即为0；最高值11111111即1+2+4+8+16+32+64+128（2的8次方减1）=255。
java中的位运算子及其用法。
位逻辑运算子有“与”（AND）、“或”（OR）、“异或（XOR）”、“非（NOT）”，分别用“&”、“|”、“^”、“~”表示。
下面的例子说明了位逻辑运算子：
Demonstrate the biise 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;
Systemoutprintln(" a = " + binary[a]);
Systemoutprintln(" b = " + binary[b]);
Systemoutprintln(" a|b = " + binary[c]);
Systemoutprintln(" a&b = " + binary[d]);
Systemoutprintln(" a^b = " + binary[e]);
Systemoutprintln("~a&b|a&~b = " + binary[f]);
Systemoutprintln(" ~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对应的元素来表示。该程式的输出如下：
a = 0011
b = 0110
a|b = 0111
a&b = 0010
a^b = 0101
~a&b|a&~b = 0101
~a = 1100
左移运算子
左移运算子<<使指定值的所有位都左移规定的次数。它的通用格式如下所示：
value << num
这里，num指定要移位值value移动的位数。也就是，左移运算子<<使指定值的所有位都左移num位。每左移一个位，高阶位都被移出（并且丢弃），并用0填充右边。这意味着当左移的运算数是int型别时，每移动1位它的第31位就要被移出并且丢弃；当左移的运算数是long型别时，每移动1位它的第63位就要被移出并且丢弃。
在对byte和short型别的值进行移位运算时，你必须小心。因为你知道Java在对表达式求值时，将自动把这些型别扩大为 int型，而且，表示式的值也是int型 。对byte和short型别的值进行移位运算的结果是int型，而且如果左移不超过31位，原来对应各位的值也不会丢弃。但是，如果你对一个负的byte或者short型别的值进行移位运算，它被扩大为int型后，它的符号也被扩充套件。这样，整数值结果的高位就会被1填充。因此，为了得到正确的结果，你就要舍弃得到结果的高位。这样做的最简单办法是将结果转换为byte型。下面的程式说明了这一点：
Left shifting a byte value
class ByteShift {
public static void main(String args[]) {
byte a = 64, b;
int i;
i = a << 2;
b = (byte) (a << 2);
Systemoutprintln("Original value of a: " + a);
Systemoutprintln("i and b: " + i + " " + b);
}
}
该程式产生的输出下所示：
Original value of a: 64
i and b: 256 0
因变数a在赋值表示式中，故被扩大为int型，64（0100 0000）被左移两次生成值256（10000 0000）被赋给变数i。然而，经过左移后，变数b中惟一的1被移出，低位全部成了0，因此b的值也变成了0。
既然每次左移都可以使原来的运算元翻倍，程式设计师们经常使用这个办法来进行快速的2的乘法。但是你要小心，如果你将1移进高阶位（31或63位），那么该值将变为负值。下面的程式说明了这一点：
Left shifting as a quick way to multiply by 2
class MultByTwo {
public static void main(String args[]) {
int i;
int num = 0xFFFFFFE;
for(i=0; i<4; i++) {
num = num << 1;
Systemoutprintln(num);
}
}
}
该程式的输出如下所示：
536870908
1073741816
2147483632
-32
初值经过仔细选择，以便在左移 4 位后，它会产生-32。正如你看到的，当1被移进31位时，数字被解释为负值。
右移运算子
右移运算子>>使指定值的所有位都右移规定的次数。它的通用格式如下所示：
value >> num
这里，num指定要移位值value移动的位数。也就是，右移运算子>>使指定值的所有位都右移num位。
下面的程式片段将值32右移2次，将结果8赋给变数a:
int a = 32;
a = a >> 2; a now contains 8
当值中的某些位被“移出”时，这些位的值将丢弃。例如，下面的程式片段将35右移2次，它的2个低位被移出丢弃，也将结果8赋给变数a:
int a = 35;
a = a >> 2; a still contains 8
用二进位制表示该过程可以更清楚地看到程式的执行过程：
00100011 35
>> 2
00001000 8
将值每右移一次，就相当于将该值除以2并且舍弃了余数。你可以利用这个特点将一个整数进行快速的2的除法。当然，你一定要确保你不会将该数原有的任何一位移出。
右移时，被移走的最高位（最左边的位）由原来最高位的数字补充。例如，如果要移走的值为负数，每一次右移都在左边补1，如果要移走的值为正数，每一次右移都在左边补0，这叫做符号位扩充套件（保留符号位）（sign extension），在进行右移 *** 作时用来保持负数的符号。例如，–8 >> 1 是–4，用二进位制表示如下：
11111000 –8
>>1
11111100 –4
一个要注意的有趣问题是，由于符号位扩充套件（保留符号位）每次都会在高位补1，因此-1右移的结果总是–1。有时你不希望在右移时保留符号。例如，下面的例子将一个byte型的值转换为用十六进位制表示。注意右移后的值与0x0f进行按位与运算，这样可以舍弃任何的符号位扩充套件，以便得到的值可以作为定义阵列的下标，从而得到对应阵列元素代表的十六进位制字元。
Masking sign extension
class HexByte {
static public void main(String args[]) {
char hex[] = {
'0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'a', 'b', 'c', 'd', 'e', 'f''
};
byte b = (byte) 0xf1;
Systemoutprintln("b = 0x" + hex[(b >> 4) & 0x0f] + hex[b & 0x0f]);
}
}
该程式的输出如下：
b = 0xf1
无符号右移
正如上面刚刚看到的，每一次右移，>>运算子总是自动地用它的先前最高位的内容补它的最高位。这样做保留了原值的符号。但有时这并不是我们想要的。例如，如果你进行移位 *** 作的运算数不是数字值，你就不希望进行符号位扩充套件（保留符号位）。当你处理画素值或图形时，这种情况是相当普遍的。在这种情况下，不管运算数的初值是什么，你希望移位后总是在高位（最左边）补0。这就是人们所说的无符号移动（unsigned shift）。这时你可以使用Java的无符号右移运算子>>>，它总是在左边补0。下面的程式段说明了无符号右移运算子>>>。在本例中，变数a被赋值为-1，用二进位制表示就是32位全是1。这个值然后被无符号右移24位，当然它忽略了符号位扩充套件，在它的左边总是补0。这样得到的值255被赋给变数a。
int a = -1;
a = a >>> 24;
下面用二进位制形式进一步说明该 *** 作：
11111111 11111111 11111111 11111111 int型- 1的二进位制程式码
>>> 24 无符号右移24位
00000000 00000000 00000000 11111111 int型255的二进位制程式码由于无符号右移运算子>>>只是对32位和64位的值有意义，所以它并不像你想象的那样有用。因为你要记住，在表示式中过小的值总是被自动扩大为int型。这意味着符号位扩充套件和移动总是发生在32位而不是8位或16位。这样，对第7位以0开始的byte型的值进行无符号移动是不可能的，因为在实际移动运算时，是对扩大后的32位值进行 *** 作。下面的例子说明了这一点：
Unsigned shifting a byte value
class ByteUShift {
static public void main(String args[]) {
char hex[] = {
'0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
};
byte b = (byte) 0xf1;
byte c = (byte) (b >> 4);
byte d = (byte) (b >>> 4);
byte e = (byte) ((b & 0xff) >> 4);
Systemoutprintln(" b = 0x"
+ hex[(b >> 4) & 0x0f] + hex[b & 0x0f]);
Systemoutprintln(" b >> 4 = 0x"
+ hex[(c >> 4) & 0x0f] + hex[c & 0x0f]);
Systemoutprintln(" b >>> 4 = 0x"
+ hex[(d >> 4) & 0x0f] + hex[d & 0x0f]);
Systemoutprintln("( b & 0xff) >> 4 = 0x"
+ hex[(e >> 4) & 0x0f] + hex[e & 0x0f]);
}
}
该程式的输出显示了无符号右移运算子>>>对byte型值处理时，实际上不是对byte型值直接 *** 作，而是将其扩大到int型后再处理。在本例中变数b被赋为任意的负byte型值。对变数b右移4位后转换为byte型，将得到的值赋给变数c，因为有符号位扩充套件，所以该值为0xff。对变数b进行无符号右移4位 *** 作后转换为byte型，将得到的值赋给变数d，你可能期望该值是0x0f，但实际上它是0xff，因为在移动之前变数b就被扩充套件为int型，已经有符号扩充套件位。最后一个表示式将变数b的值通过按位与运算将其变为8位，然后右移4位，然后将得到的值赋给变数e，这次得到了预想的结果0x0f。由于对变数d（它的值已经是0xff）进行按位与运算后的符号位的状态已经明了，所以注意，对变数d再没有进行无符号右移运算。
B = 0xf1
b >> 4 = 0xff
b >>> 4 = 0xff
(b & 0xff) >> 4 = 0x0f
位运算子赋值
所有的二进位制位运算子都有一种将赋值与位运算组合在一起的简写形式。例如，下面两个语句都是将变数a右移4位后赋给a：
a = a >> 4;
a >>= 4;
同样，下面两个语句都是将表示式a OR b运算后的结果赋给a：
a = a | b;
a |= b;
下面的程式定义了几个int型变数，然后运用位赋值简写的形式将运算后的值赋给相应的变数：
class OpBitEquals {
public static void main(String args[]) {
int a = 1;
int b = 2;
int c = 3;
a |= 4;
b >>= 1;
c <<= 1;
a ^= c;
Systemoutprintln("a = " + a);
Systemoutprintln("b = " + b);
Systemoutprintln("c = " + c);
}
}
该程式的输出如下所示：
a = 3
b = 1
c = 6
java中的按位运算子与
0&&0 =0
1&&0 =0
0&&1 =0
1&&1 =1
或
0||0 =0
1||0 =1
0||1 =1
1||1 =1
异或是
1^0=1
0^1=1
0^0=0
1^1=0
例子
11001010 与
00011011
按位与 按位或 按位异或
00001010 11011011 11010001
什么是Java的位运算子？位运算子用来对二进位制位进行 *** 作,位 运 算 符 (＞＞,＜＜,＞＞＞,&,|,^,～ ) ,位运 算 符 中 ,除 ～ 以 外 ,其余 均 为 二 元 运 算 符 。 *** 作 数 只 能 为 整 型 和字 符 型 数 据 。
比如‘>>’ 这个就相当于乘以2
c++中的位运算子号C++位运算子有以下两类：
1 位逻辑运算子：&（位“与”）、^（位“异或”）、|（位“或”）和~（位“取反”）
2 移位运算子：<<（左移）和>>(右移)
位“与”、位“或”和位“异或”运算子都是双目运算子，其结合性都是从左向右的，优先顺序高于逻辑运算子，低于比较运算子，且从高到低依次为&、^、|
c++中按位运算子的用法这个是C++中的基础，你可以看看人家的部落格。
:mblogcsdn/article/detailsid=52196039
java中位运算子详解
运算子那多了去了
算术运算子 + - / % 分别是加减乘除求余
在这里要特别注意有个晋升现象是指低于int的三种类型(byte short char)进行算术运算后会自动提升成int型别列如
byte a=20;
byte b=30;
byte c=a+b;这就错了应该写成byte c=(byte)(a+b);或者 int c =a+b;
比较运算子
即< ,> ,<=, >= ,==, !=分别是小于, 大于, 小于等于,大于等于,不等于
它的结果是一个Boolean 型别
逻辑运算子
或(||) 与(&&) 非(!) or and not
赋值运算子
最简单的是"="用来为常量或者变数指定值注意不能为运算式赋值
还有其他赋值运算子如下
+= 加等 把变数加上右侧的值然后再赋值给自身
-= 减等 把变数减去右侧的值然后再赋值给自身
= 乘等 把变数乘以右侧的值然后再赋值给自身
/= 除等 把变数除以右侧的值然后再赋值给自身
%= 取余等 把变数和右侧的值取余然后再赋值给自身
还有二进位制运算子
位运算子
移位运算子
++ 递增
-- 递减
条件值1:值2 条件运算子
java中的逻辑符号，运算子（位运算子）个代表什么算数运算子，+-/(+=，-=，=，、/) ps 1/0 => NaN 无穷大。逻辑运算子，略转义序列符（例举），\b 退格, \t 制表, \n 换行（制图、一般println）, \r 回车, \" 双引号, \' 单引号ps 取决于os，并不常用。递增/减 ++, --赋值 =比较 >=，<=, ==位移 <<，>>, >>>ps 图形用到注释， 行注释，/ /段注释型别转换， a = (int)b; 括号。条件， if() == a true : false 三目运算。正则表示式， 应用类，用到这再说。
LZ是学Java的新手吧。嗯，慢慢学
java都有哪些运算子及其用法Java的运算子可分为4类：算术运算子、关系运算符、逻辑运算子和位运算子。
1算术运算子
Java的算术运算子分为一元运算子和二元运算子。一元运算子只有一个运算元；二元运算子有两个运算元，运算子位于两个运算元之间。算术运算子的运算元必须是数值型别。
(1)一元运算子：
一元运算子有：正（+）、负（－）、加1（++）和减1（－－）4个。
加1、减1运算子只允许用于数值型别的变数，不允许用于表示式中。加1、减1运算子既可放在变数之前（如＋＋i），也可放在变数之后（如i＋＋），两者的差别是：如果放在变数之前（如＋＋i），则变数值先加1或减1，然后进行其他相应的 *** 作（主要是赋值 *** 作）；如果放在变数之后（如i＋＋），则先进行其他相应的 *** 作，然后再进行变数值加1或减1。
例如：
int i=6，j，k，m，n;
j = +i; 取原值，即j=6
k = -i; 取负值，即k=-6
m = i++; 先m=i,再i=i+1，即m=6，i=7
m = ++i; 先i=i+1,再m=i，即i=7，m=7
n = j--; 先n=j,再j=j-1，即n=6，j=5
n = --j; 先j=j-1,再n=j，即j=5，n=5
在书写时还要注意的是：一元运算子与其前后的运算元之间不允许有空格，否则编译时会出错。
(2)二元运算子
二元运算子有：加（+）、减（－）、乘（）、除（／）、取余（%）。其中+、－、、／完成加、减、乘、除四则运算，%是求两个运算元相除后的余数。
%求余 *** 作举例：
a % b = a － (a / b) b
取余运算子既可用于两个运算元都是整数的情况，也可用于两个运算元都是浮点数（或一个运算元是浮点数）的情况。当两个运算元都是浮点数时，例如76 % 29时，计算结果为：76 － 2 29 = 18。
当两个运算元都是int型别数时，a%b的计算公式为：
a % b = a － （int）(a / b) b
当两个运算元都是long型别（或其他整数型别）数时，a%b的计算公式可以类推。
当参加二元运算的两个运算元的资料型别不同时，所得结果的资料型别与精度较高（或位数更长）的那种资料型别一致。
例如：
7 / 3 整除，运算结果为2
70 / 3 除法，运算结果为233333,即结果与精度较高的型别一致
7 % 3 取余，运算结果为1
70 % 3 取余，运算结果为10
-7 % 3 取余，运算结果为-1，即运算结果的符号与左运算元相同
7 % -3 取余，运算结果为1，即运算结果的符号与左运算元相同
2关系运算符
关系运算符用于比较两个数值之间的大小，其运算结果为一个逻辑型别的数值。关系运算符有六个：等于（==）、不等于（!=）、大于（>）、大于等于（>=）、小于（<）、小于等于（<=）。
例如：
9 <= 8 运算结果为false
99 >= 88 运算结果为true
'A' < 'a' 运算结果为true，因字元'A'的Unicode编码值小于字元'a'的
要说明的是，对于大于等于（或小于等于）关系运算符来说，只有大于和等于两种关系运算都不成立时其结果值才为false，只要有一种（大于或等于）关系运算成立其结果值即为true。例如，对于9 <= 8，9既不小于8也不等于8，所以9 <= 8 的运算结果为false。对于9 >= 9，因9等于9，所以9 >= 9的运算结果为true。
3逻辑运算子
逻辑运算子要求运算元的资料型别为逻辑型，其运算结果也是逻辑型值。逻辑运算子有：逻辑与（&&）、逻辑或（||）、逻辑非（!）、逻辑异或（^）、逻辑与（&）、逻辑或（|）。
真值表是表示逻辑运算功能的一种直观方法，其具体方法是把逻辑运算的所有可能值用表格形式全部罗列出来。Java语言逻辑运算子的真值表如下：
逻辑运算子的真值表
A B A&&B A||B !A A^B A&B A|B
false false false false true false false false
true false false true false true false true
false true false true true true false true
true true true true false false true true
前两列是参与逻辑运算的两个逻辑变数，共有4种可能，所以表25共有4行。后6列分别是6个逻辑运算子在逻辑变数A和逻辑变数B取不同数值时的运算结果值。
要说明的是，两种逻辑与（&&和&）的运算规则基本相同，两种逻辑或（||和|）的运算规则也基本相同。其区别是：&和|运算是把逻辑表示式全部计算完，而&&和||运算具有短路计算功能。所谓短路计算，是指系统从左至右进行逻辑表示式的计算，一旦出现计算结果已经确定的情况，则计算过程即被终止。对于&&运算来说，只要运算子左端的值为false，则因无论运算子右端的值为true或为false，其最终结果都为false。所以，系统一旦判断出&&运算子左端的值为false，则系统将终止其后的计算过程；对于 || 运算来说，只要运算子左端的值为true，则因无论运算子右端的值为true或为false，其最终结果都为true。所以，系统一旦判断出|| 运算子左端的值为true，则系统将终止其后的计算过程。
例如，有如下逻辑表示式：
(i>=1) && (i<=100)
此时，若i等于0，则系统判断出i>=1的计算结果为false后，系统马上得出该逻辑表示式的最终计算结果为false，因此，系统不继续判断i<=100的值。短路计算功能可以提高程式的执行速度。
作者建议读者：在程式设计时使用&&和||运算子，不使用&和|运算子。
用逻辑与（&&）、逻辑或（||）和逻辑非（!）可以组合出各种可能的逻辑表示式。逻辑表示式主要用在 if、while等语句的条件组合上。
例如：
int i = 1;
while(i>=1) && (i<=100) i++; 回圈过程
上述程式段的回圈过程将i++语句回圈执行100次。
4位运算子
位运算是以二进位制位为单位进行的运算，其运算元和运算结果都是整型值。
位运算子共有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。
5其他运算子
（1）赋值运算子与其他运算子的简捷使用方式
赋值运算子可以与二元算术运算子、逻辑运算子和位运算子组合成简捷运算子，从而可以简化一些常用表示式的书写。
赋值运算子与其他运算子的简捷使用方式
运算子 用法 等价于 说明
+= s+=i s=s+i s，i是数值型
-= s-=i s=s-i s，i是数值型
= s=i s=si s，i是数值型
/= s/=i s=s/i s，i是数值型
%= s%=i s=s%i s，i是数值型
&= a&=b a=a&b a，b是逻辑型或整型
|= a|=b a=a|b a，b是逻辑型或整型
^= A^=b a=a^b a，b是逻辑型或整型
<<= s<<=i s=s<<i s，i是整型
>>= s>>=i s=s>>i s，i是整型
>>>= s>>>=i s=s>>>i s，i是整型
（2）方括号[]和圆括号（）运算子
方括号[]是阵列运算子，方括号[]中的数值是阵列的下标，整个表示式就代表阵列中该下标所在位置的元素值。
圆括号（）运算子用于改变表示式中运算子的优先顺序。
（3）字串加（+）运算子
当运算元是字串时，加（+）运算子用来合并两个字串；当加（+）运算子的一边是字串，另一边是数值时，机器将自动将数值转换为字串，这种情况在输出语句中很常见。如对于如下程式段：
int max = 100;
Systemoutprintln（"max = "+max）;
计算机萤幕的输出结果为：max = 100，即此时是把变数max中的整数值100转换成字串100输出的。
（4）条件运算子（？：）
条件运算子（？：）的语法形式为：
<表示式1> ？<表示式2> : <表示式3>
条件运算子的运算方法是：先计算<表示式1>的值，当<表示式1>的值为true时，则将<表示式2>的值作为整个表示式的值；当<表示式1>的值为false时，则将<表示式3>的值作为整个表示式的值。如：
int a=1，b=2，max;
max = a>b？a：b; max等于2
（5）强制型别转换符
强制型别转换符能将一个表示式的型别强制转换为某一指定资料型别，其语法形式为：
(<型别>)<表示式>
（6）物件运算子instanceof
物件运算子instanceof用来测试一个指定物件是否是指定类（或它的子类）的例项，若是则返回true，否则返回false。
（7）点运算子
点运算子“”的功能有两个：一是引用类中成员，二是指示包的层次等级。
6运算子的优先顺序
以下按优先顺序从高到低的次序列出Java语言中的所有运算子，表中结合性一列中的“左右”表示其运算次序为从左向右，“右左”表示其运算次序为从右向左。
优先顺序 运算子 结合性
1 [] () ; ,
2 ++ ―― += ! ~ +(一元) -(一元) 右左
3 / % 左右
4 +(二元) -(二元) 左右
5 << >> >>> 左右
6 < > <= >= instanceof 左右
7 = = != 左右
8 & 左右
9 ^ 左右
10 | 左右
11 && 左右
12 || 左右
13 ： 右左
14 = = /= %= += －= <<= >>= >>>= &= ^= |= 右左
--感谢原作者。
如何理解vba中逻辑运算子的位运算子位运算子并不是逻辑运算子，逻辑运算子包括或、与、非、异或。
位 *** 作符（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:URShiftjava
// Test of unsigned right shift
import combruceeckelsimpletest;
public class URShift {
static Test monitor = new Test();
public static void main(String[] args) {
int i = -1;
Systemoutprintln(i >>>= 10);
long l = -1;
Systemoutprintln(l >>>= 10);
short s = -1;
Systemoutprintln(s >>>= 10);
byte b = -1;
Systemoutprintln(b >>>= 10);
b = -1;
Systemoutprintln(b>>>10);
monitorexpect(new String[] {
"4194303",
"18014398509481983",
"-1",
"-1",
"4194303"
});
}
} ///:~
在最后一个移位运算中，结果没有赋回给b，而是直接打印出来，所以其结果是正确的。
下面这个例子向大家阐示了如何应用涉及“按位” *** 作的所有 *** 作符：
//: c03:BitManipulationjava
// Using the bitwise operators
import combruceeckelsimpletest;
import javautil;
public class BitManipulation {
static Test monitor = new Test();
public static void main(String[] args) {
Random rand = new Random();
int i = randnextInt();
int j = randnextInt();
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 = randnextLong();
long m = randnextLong();
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);
monitorexpect("BitManipulationout");
}
static void printBinaryInt(String s, int i) {
Systemoutprintln(
s + ", int: " + i + ", binary: ");
Systemoutprint(" ");
for(int j = 31; j >= 0; j--)
if(((1 << j) & i) != 0)
Systemoutprint("1");
else
Systemoutprint("0");
Systemoutprintln();
}
static void printBinaryLong(String s, long l) {
Systemoutprintln(
s + ", long: " + l + ", binary: ");
Systemoutprint(" ");
for(int i = 63; i >= 0; i--)
if(((1L << i) & l) != 0)
Systemoutprint("1");
else
Systemoutprint("0");
Systemoutprintln();
}
} ///:~
程序末尾调用了两个方法：printBinaryInt()和printBinaryLong()。它们分别接受
一个 int 或 long 值的参数，并用二进制格式输出，同时附有简要的说明文字。你可以暂
时忽略它们具体是如何实现的。
请注意这里是用 Systemoutprint()，而不是 Systemoutprintln()。print()方法不自动换行，所
以我们能在同一行里输出多个信息。
上面的例子中，expect() 以一个文件名作参数，它会从这个文件中读取预期的行（其中
可以有，也可以没有正则表达式）。对于那些太长，不适宜列在书里的输出，这种做法很有
用。这个文件的扩展名是“out”，是所发布的代码的一部分，可以从>
转换成二进制, 更清楚点
0xffffffff, 即 -1
1111,1111,1111,1111,1111,1111,1111,1111
无符号右移2位
0011,1111,1111,1111,1111,1111,1111,1111
这个显然是个正数2的30次方 -1
指令码
助记符
说明
0x00
nop
什么都不做
0x01
aconst_null
将null推送至栈顶
0x02
iconst_m1
将int型-1推送至栈顶
0x03
iconst_0
将int型0推送至栈顶
0x04
iconst_1
将int型1推送至栈顶
0x05
iconst_2
将int型2推送至栈顶
0x06
iconst_3
将int型3推送至栈顶
0x07
iconst_4
将int型4推送至栈顶
0x08
iconst_5
将int型5推送至栈顶
0x09
lconst_0
将long型0推送至栈顶
0
lconst_1
将long型1推送至栈顶
0x0b
fconst_0
将float型0推送至栈顶
0x0c
fconst_1
将float型1推送至栈顶
0x0d
fconst_2
将float型2推送至栈顶
0x0e
dconst_0
将double型0推送至栈顶
0x0f
dconst_1
将double型1推送至栈顶
0x10
bipush
将单字节的常量值(-128~127)推送至栈顶
0x11
sipush
将一个短整型常量值(-32768~32767)推送至栈顶
0x12
ldc
将int, float或String型常量值从常量池中推送至栈顶
0x13
ldc_w
将int, float或String型常量值从常量池中推送至栈顶（宽索引）
0x14
ldc2_w
将long或double型常量值从常量池中推送至栈顶（宽索引）
0x15
iload
将指定的int型本地变量推送至栈顶
0x16
lload
将指定的long型本地变量推送至栈顶
0x17
fload
将指定的float型本地变量推送至栈顶
0x18
dload
将指定的double型本地变量推送至栈顶
0x19
aload
将指定的引用类型本地变量推送至栈顶
0x1a
iload_0
将第一个int型本地变量推送至栈顶
0x1b
iload_1
将第二个int型本地变量推送至栈顶
0x1c
iload_2
将第三个int型本地变量推送至栈顶
0x1d
iload_3
将第四个int型本地变量推送至栈顶
0x1e
lload_0
将第一个long型本地变量推送至栈顶
0x1f
lload_1
将第二个long型本地变量推送至栈顶
0x20
lload_2
将第三个long型本地变量推送至栈顶
0x21
lload_3
将第四个long型本地变量推送至栈顶
0x22
fload_0
将第一个float型本地变量推送至栈顶
0x23
fload_1
将第二个float型本地变量推送至栈顶
0x24
fload_2
将第三个float型本地变量推送至栈顶
0x25
fload_3
将第四个float型本地变量推送至栈顶
0x26
dload_0
将第一个double型本地变量推送至栈顶
0x27
dload_1
将第二个double型本地变量推送至栈顶
0x28
dload_2
将第三个double型本地变量推送至栈顶
0x29
dload_3
将第四个double型本地变量推送至栈顶
0x2a
aload_0
将第一个引用类型本地变量推送至栈顶
0x2b
aload_1
将第二个引用类型本地变量推送至栈顶
0x2c
aload_2
将第三个引用类型本地变量推送至栈顶
0x2d
aload_3
将第四个引用类型本地变量推送至栈顶
0x2e
iaload
将int型数组指定索引的值推送至栈顶
0x2f
laload
将long型数组指定索引的值推送至栈顶
0x30
faload
将float型数组指定索引的值推送至栈顶
0x31
daload
将double型数组指定索引的值推送至栈顶
0x32
aaload
将引用型数组指定索引的值推送至栈顶
0x33
baload
将boolean或byte型数组指定索引的值推送至栈顶
0x34
caload
将char型数组指定索引的值推送至栈顶
0x35
saload
将short型数组指定索引的值推送至栈顶
0x36
istore
将栈顶int型数值存入指定本地变量
0x37
lstore
将栈顶long型数值存入指定本地变量
0x38
fstore
将栈顶float型数值存入指定本地变量
0x39
dstore
将栈顶double型数值存入指定本地变量
0x3a
astore
将栈顶引用型数值存入指定本地变量
0x3b
istore_0
将栈顶int型数值存入第一个本地变量
0x3c
istore_1
将栈顶int型数值存入第二个本地变量
0x3d
istore_2
将栈顶int型数值存入第三个本地变量
0x3e
istore_3
将栈顶int型数值存入第四个本地变量
0x3f
lstore_0
将栈顶long型数值存入第一个本地变量
0x40
lstore_1
将栈顶long型数值存入第二个本地变量
0x41
lstore_2
将栈顶long型数值存入第三个本地变量
0x42
lstore_3
将栈顶long型数值存入第四个本地变量
0x43
fstore_0
将栈顶float型数值存入第一个本地变量
0x44
fstore_1
将栈顶float型数值存入第二个本地变量
0x45
fstore_2
将栈顶float型数值存入第三个本地变量
0x46
fstore_3
将栈顶float型数值存入第四个本地变量
0x47
dstore_0
将栈顶double型数值存入第一个本地变量
0x48
dstore_1
将栈顶double型数值存入第二个本地变量
0x49
dstore_2
将栈顶double型数值存入第三个本地变量
0x4a
dstore_3
将栈顶double型数值存入第四个本地变量
0x4b
astore_0
将栈顶引用型数值存入第一个本地变量
0x4c
astore_1
将栈顶引用型数值存入第二个本地变量
0x4d
astore_2
将栈顶引用型数值存入第三个本地变量
0x4e
astore_3
将栈顶引用型数值存入第四个本地变量
0x4f
iastore
将栈顶int型数值存入指定数组的指定索引位置
0x50
lastore
将栈顶long型数值存入指定数组的指定索引位置
0x51
fastore
将栈顶float型数值存入指定数组的指定索引位置
0x52
dastore
将栈顶double型数值存入指定数组的指定索引位置
0x53
aastore
将栈顶引用型数值存入指定数组的指定索引位置
0x54
bastore
将栈顶boolean或byte型数值存入指定数组的指定索引位置
0x55
castore
将栈顶char型数值存入指定数组的指定索引位置
0x56
sastore
将栈顶short型数值存入指定数组的指定索引位置
0x57
pop
将栈顶数值d出 (数值不能是long或double类型的)
0x58
pop2
将栈顶的一个（long或double类型的)或两个数值d出（其它）
0x59
dup
复制栈顶数值并将复制值压入栈顶
0x5a
dup_x1
复制栈顶数值并将两个复制值压入栈顶
0x5b
dup_x2
复制栈顶数值并将三个（或两个）复制值压入栈顶
0x5c
dup2
复制栈顶一个（long或double类型的)或两个（其它）数值并将复制值压入栈顶
0x5d
dup2_x1
<待补充>
0x5e
dup2_x2
<待补充>
0x5f
swap
将栈最顶端的两个数值互换(数值不能是long或double类型的)
0x60
iadd
将栈顶两int型数值相加并将结果压入栈顶
0x61
ladd
将栈顶两long型数值相加并将结果压入栈顶
0x62
fadd
将栈顶两float型数值相加并将结果压入栈顶
0x63
dadd
将栈顶两double型数值相加并将结果压入栈顶
0x64
isub
将栈顶两int型数值相减并将结果压入栈顶
0x65
lsub
将栈顶两long型数值相减并将结果压入栈顶
0x66
fsub
将栈顶两float型数值相减并将结果压入栈顶
0x67
dsub
将栈顶两double型数值相减并将结果压入栈顶
0x68
imul
将栈顶两int型数值相乘并将结果压入栈顶
0x69
lmul
将栈顶两long型数值相乘并将结果压入栈顶
0x6a
fmul
将栈顶两float型数值相乘并将结果压入栈顶
0x6b
dmul
将栈顶两double型数值相乘并将结果压入栈顶
0x6c
idiv
将栈顶两int型数值相除并将结果压入栈顶
0x6d
ldiv
将栈顶两long型数值相除并将结果压入栈顶
0x6e
fdiv
将栈顶两float型数值相除并将结果压入栈顶
0x6f
ddiv
将栈顶两double型数值相除并将结果压入栈顶
0x70
irem
将栈顶两int型数值作取模运算并将结果压入栈顶
0x71
lrem
将栈顶两long型数值作取模运算并将结果压入栈顶
0x72
frem
将栈顶两float型数值作取模运算并将结果压入栈顶
0x73
drem
将栈顶两double型数值作取模运算并将结果压入栈顶
0x74
ineg
将栈顶int型数值取负并将结果压入栈顶
0x75
lneg
将栈顶long型数值取负并将结果压入栈顶
0x76
fneg
将栈顶float型数值取负并将结果压入栈顶
0x77
dneg
将栈顶double型数值取负并将结果压入栈顶
0x78
ishl
将int型数值左移位指定位数并将结果压入栈顶
0x79
lshl
将long型数值左移位指定位数并将结果压入栈顶
0x7a
ishr
将int型数值右（符号）移位指定位数并将结果压入栈顶
0x7b
lshr
将long型数值右（符号）移位指定位数并将结果压入栈顶
0x7c
iushr
将int型数值右（无符号）移位指定位数并将结果压入栈顶
0x7d
lushr
将long型数值右（无符号）移位指定位数并将结果压入栈顶
0x7e
iand
将栈顶两int型数值作“按位与”并将结果压入栈顶
0x7f
land
将栈顶两long型数值作“按位与”并将结果压入栈顶
0x80
ior
将栈顶两int型数值作“按位或”并将结果压入栈顶
0x81
lor
将栈顶两long型数值作“按位或”并将结果压入栈顶
0x82
ixor
将栈顶两int型数值作“按位异或”并将结果压入栈顶
0x83
lxor
将栈顶两long型数值作“按位异或”并将结果压入栈顶
0x84
iinc
将指定int型变量增加指定值（i++, i--, i+=2）
0x85
i2l
将栈顶int型数值强制转换成long型数值并将结果压入栈顶
0x86
i2f
将栈顶int型数值强制转换成float型数值并将结果压入栈顶
0x87
i2d
将栈顶int型数值强制转换成double型数值并将结果压入栈顶
0x88
l2i
将栈顶long型数值强制转换成int型数值并将结果压入栈顶
0x89
l2f
将栈顶long型数值强制转换成float型数值并将结果压入栈顶
0x8a
l2d
将栈顶long型数值强制转换成double型数值并将结果压入栈顶
0x8b
f2i
将栈顶float型数值强制转换成int型数值并将结果压入栈顶
0x8c
f2l
将栈顶float型数值强制转换成long型数值并将结果压入栈顶
0x8d
f2d
将栈顶float型数值强制转换成double型数值并将结果压入栈顶
0x8e
d2i
将栈顶double型数值强制转换成int型数值并将结果压入栈顶
0x8f
d2l
将栈顶double型数值强制转换成long型数值并将结果压入栈顶
0x90
d2f
将栈顶double型数值强制转换成float型数值并将结果压入栈顶
0x91
i2b
将栈顶int型数值强制转换成byte型数值并将结果压入栈顶
0x92
i2c
将栈顶int型数值强制转换成char型数值并将结果压入栈顶
0x93
i2s
将栈顶int型数值强制转换成short型数值并将结果压入栈顶
0x94
lcmp
比较栈顶两long型数值大小，并将结果（1，0，-1）压入栈顶
0x95
fcmpl
比较栈顶两float型数值大小，并将结果（1，0，-1）压入栈顶；当其中一个数值为NaN时，将-1压入栈顶
0x96
fcmpg
比较栈顶两float型数值大小，并将结果（1，0，-1）压入栈顶；当其中一个数值为NaN时，将1压入栈顶
0x97
dcmpl
比较栈顶两double型数值大小，并将结果（1，0，-1）压入栈顶；当其中一个数值为NaN时，将-1压入栈顶
0x98
dcmpg
比较栈顶两double型数值大小，并将结果（1，0，-1）压入栈顶；当其中一个数值为NaN时，将1压入栈顶
0x99
ifeq
当栈顶int型数值等于0时跳转
0x9a
ifne
当栈顶int型数值不等于0时跳转
0x9b
iflt
当栈顶int型数值小于0时跳转
0x9c
ifge
当栈顶int型数值大于等于0时跳转
0x9d
ifgt
当栈顶int型数值大于0时跳转
0x9e
ifle
当栈顶int型数值小于等于0时跳转
0x9f
if_icmpeq
比较栈顶两int型数值大小，当结果等于0时跳转
0xa0
if_icmpne
比较栈顶两int型数值大小，当结果不等于0时跳转
0xa1
if_icmplt
比较栈顶两int型数值大小，当结果小于0时跳转
0xa2
if_icmpge
比较栈顶两int型数值大小，当结果大于等于0时跳转
0xa3
if_icmpgt
比较栈顶两int型数值大小，当结果大于0时跳转
0xa4
if_icmple
比较栈顶两int型数值大小，当结果小于等于0时跳转
0xa5
if_acmpeq
比较栈顶两引用型数值，当结果相等时跳转
0xa6
if_acmpne
比较栈顶两引用型数值，当结果不相等时跳转
0xa7
goto
无条件跳转
0xa8
jsr
跳转至指定16位offset位置，并将jsr下一条指令地址压入栈顶
0xa9
ret
返回至本地变量指定的index的指令位置（一般与jsr, jsr_w联合使用）
0xaa
tableswitch
用于switch条件跳转，case值连续（可变长度指令）
0xab
lookupswitch
用于switch条件跳转，case值不连续（可变长度指令）
0xac
ireturn
从当前方法返回int
0xad
lreturn
从当前方法返回long
0xae
freturn
从当前方法返回float
0xaf
dreturn
从当前方法返回double
0xb0
areturn
从当前方法返回对象引用
0xb1
return
从当前方法返回void
0xb2
getstatic
获取指定类的静态域，并将其值压入栈顶
0xb3
putstatic
为指定的类的静态域赋值
0xb4
getfield
获取指定类的实例域，并将其值压入栈顶
0xb5
putfield
为指定的类的实例域赋值
0xb6
invokevirtual
调用实例方法
0xb7
invokespecial
调用超类构造方法，实例初始化方法，私有方法
0xb8
invokestatic
调用静态方法
0xb9
invokeinterface
调用接口方法
0xba
--
0xbb
new
创建一个对象，并将其引用值压入栈顶
0xbc
newarray
创建一个指定原始类型（如int, float, char…）的数组，并将其引用值压入栈顶
0xbd
anewarray
创建一个引用型（如类，接口，数组）的数组，并将其引用值压入栈顶
0xbe
arraylength
获得数组的长度值并压入栈顶
0xbf
athrow
将栈顶的异常抛出
0xc0
checkcast
检验类型转换，检验未通过将抛出ClassCastException
0xc1
instanceof
检验对象是否是指定的类的实例，如果是将1压入栈顶，否则将0压入栈顶
0xc2
monitorenter
获得对象的锁，用于同步方法或同步块
0xc3
monitorexit
释放对象的锁，用于同步方法或同步块
0xc4
wide
<待补充>
0xc5
multianewarray
创建指定类型和指定维度的多维数组（执行该指令时， *** 作栈中必须包含各维度的长度值），并将其引用值压入栈顶
0xc6
ifnull
为null时跳转
0xc7
ifnonnull
不为null时跳转
0xc8
goto_w
无条件跳转（宽索引）
0xc9
jsr_w
跳转至指定32位offset位置，并将jsr_w下一条指令地址压入栈顶
Java的设计者感到无符号整数是不必要的。具体地说，他们感到无符号（unsigned）概念主要被用来指定高位（high-orderbit）状态，它定义了当int表示一个数字时的符号。你将在第4章中看到，Java对高位含义的管理是不同的，它通过增加一个专门的“无符号右移”运算符来管理高位。这样，就不需要无符号整数了。
所以JAVA是没有无符号类型的
我写的 Java 程序如下：（程序功能：列出 200000 内的所有质数）
//计算质数
public class PrimeNumber {
public static void main(String args[]) {
long startTime = SystemcurrentTimeMillis();
int count = 2;
Systemoutprint("2,3,");
boolean isPN = true;
int max = 1000200;
for(int i=4;i<max+1;i++) {
isPN = true;
int n = (int)(i/2)+1;
for(int j=2;j<n;j++) {
if(i%j == 0) {
isPN = false;
break;
}
}
if(isPN) {
Systemoutprint(i+",");
count++;
}
}
long endTime = SystemcurrentTimeMillis();
Systemoutprintln ("");
Systemoutprintln ("共用时间:"+(endTime-startTime)+"毫秒");
Systemoutprintln ("共找到:"+count+"个质数");
}
}
我朋友写的C＃程序如下：
using System;
class test
{
static void Main() {
DateTime t1 = DateTimeNow;
cal(200000);
DateTime t2 = DateTimeNow;
TimeSpan t = t2-t1;
ConsoleWriteLine("时间为：{0} 毫秒\n",tTotalMillisecondsToString());
ConsoleReadLine();
}
static void cal(uint x)
{
ConsoleWrite("2,");
uint sum=1;
for(uint a=3;a<x+1;a++)
{
bool flag=true;
uint n = (uint)(a/2)+1;
for(uint b=2;b<n;b++)
{
if(a%b!=0) continue;
flag=false;
break;
}
if(flag)
{
ConsoleWrite(a+",");
sum++;
}
}
ConsoleWriteLine("\n {0} 以内共有 {1} 个质数\n",x,sum);
}
}
在我自己的机器上测试（机器配置：P424B+512M+WIN2003）
Java 为 JDK142_05
C# 为 WIN2003 自带的 net 11
比较结果真令人沮丧：
Java 程序使用了： 13M 内存 ＋ 22 秒的时间
C＃ 程序使用了： 8M 内存 ＋ 12 秒的时间
“不会吧，SUN 怎么也是做了快10年的虚拟机了，怎么会比 MS 的 net 虚拟机慢这么多呢？”
我不相信。于是我把自己的 Java 程序改成了 C＃程序，代码如下：
//计算质数
using System;
class PrimeNumber {
static void Main() {
DateTime t1 = DateTimeNow;
int count = 2;
ConsoleWrite("2,3,");
bool isPN = true;
int max = 1000200;
for(int i=4;i<max+1;i++) {
isPN = true;
int n = (int)(i/2)+1;
for(int j=2;j<n;j++) {
if(i%j == 0) {
isPN = false;
break;
}
}
if(isPN) {
ConsoleWrite(i+",");
count++;
}
}
DateTime t2 = DateTimeNow;
TimeSpan t = t2-t1;
ConsoleWriteLine ("");
ConsoleWriteLine ("共用时间:"+tTotalMillisecondsToString()+"毫秒");
ConsoleWriteLine ("共找到:"+count+"个质数");
ConsoleReadLine();
}
}
这次这个程序的执行结果为： 8M 内存 ＋ 22 秒的时间
除了内存使用多一点（这可以理解，这里使用的内存只是 JVM 使用的内存，不代表程序实际使用的内存），
在时间上 C＃程序 和 Java程序 没有什么差别了。
难道是我朋友写的程序的算法好，可我怎么看，也看不出它好在哪里啊！
于是我改了一下我朋友写的程序：（只是把 uint 改成了 int 型数据）具体代码如下：
using System;
class test
{
static void Main() {
DateTime t1 = DateTimeNow;
cal(200000);
DateTime t2 = DateTimeNow;
TimeSpan t = t2-t1;
ConsoleWriteLine("时间为：{0} 毫秒\n",tTotalMillisecondsToString());
ConsoleReadLine();
}
static void cal(int x)
{
ConsoleWrite("2,");
int sum=1;
for(int a=3;a<x+1;a++)
{
bool flag=true;
int n = (int)(a/2)+1;
for(int b=2;b<n;b++)
{
if(a%b!=0) continue;
flag=false;
break;
}
if(flag)
{
ConsoleWrite(a+",");
sum++;
}
}
ConsoleWriteLine("\n {0} 以内共有 {1} 个质数\n",x,sum);
}
}
执行结果还是： 8M 内存 ＋ 22 秒的时间
这进一步说明，Java 和 net 虚拟机在执行效率上基本没有差别。
最开始的两个程序产生差别的唯一原因就是：
C＃内置支持无符号数
Java 则只有有符号数
在只需要正数的环境下，Java 的效率下去了！
Java 为什么不内置支持 “无符号基本数据类型”呢？？
这让我们在写网络程序时， byte 是有符号数，让我们不得不小心的处理，以免出现错误。
强烈建议 Java 内置支持 无符号基本数据类型！
以上就是关于为什么java 中byte不考虑无符号位范围是0-255全部的内容，包括:为什么java 中byte不考虑无符号位范围是0-255、java中的位运算子及其用法。、JAVA位运算符等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）