① 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的补码”。
② Java中的运算符有哪些
1.算术运算符
Java的算术运算符分为一元运算符回和二元运算答符。一元运算符只有一个操作数；二元运算符有两个操作数，运算符位于两个操作数之间。算术运算符的操作数必须是数值类型。
(1)一元运算符：
一元运算符有：正（+）、负（－）、加1（++）和减1（－－）4个。
加1、减1运算符只允许用于数值类型的变量，不允许用于表达式中。加1、减1运算符既可放在变量之前（如＋＋i），也可放在变量之后（如i＋＋），两者的差别是：如果放在变量之前（如＋＋i），则变量值先加1或减1，然后进行其他相应的操作（主要是赋值操作）；如果放在变量之后（如i＋＋），则先进行其他相应的操作，然后再进行变量值加1或减1。
③ Java中，位运算符>>,右移时左边何时补0，何时补1
右移动运算符：
把操作数向右移动，移动的位个数同样由右操作数指定。注意：面对带正负号的数，会采用符号扩展，如果原值是正数，则高位补上0；如果原值是负数，高位补1。
④ 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;
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对应的元素来表示。燃返该程式的输出如下：
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);
System.out.println("Original value of a: " + a);
System.out.println("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;
System.out.println(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[] = {
Ɔ', Ƈ', ƈ', Ɖ', Ɗ', Ƌ', ƌ', ƍ',
Ǝ', Ə', 'a', 'b', 'c', 'd', 'e', 'f''
};
byte b = (byte) 0xf1;
System.out.println("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[] = {
Ɔ', Ƈ', ƈ', Ɖ', Ɗ', Ƌ', ƌ', ƍ',
Ǝ', Ə', '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);
System.out.println(" b = 0x"
+ hex[(b >> 4) & 0x0f] + hex[b & 0x0f]);
System.out.println(" b >> 4 = 0x"
+ hex[(c >> 4) & 0x0f] + hex[c & 0x0f]);
System.out.println(" b >>> 4 = 0x"
+ hex[(d >> 4) & 0x0f] + hex[d & 0x0f]);
System.out.println("( 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;
System.out.println("a = " + a);
System.out.println("b = " + b);
System.out.println("c = " + c);
}
}
该程式的输出如下所示：
a = 3
b = 1
c = 6
与
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
位运算子用来对二进位制位进行操作,位 运 算 符 (＞＞,＜＜,＞＞＞,&,|,^,～ ) ,位运 算 符 中 ,除 ～ 以 外 ,其余 均 为 二 元 运 算 符 。 操 作 数 只 能 为 整 型 和字 符 型 数 据 。
比如‘>>’ 这个就相当于乘以2.
C++位运算子有以下两类：
1 位逻辑运算子：&（位“与”）、^（位“异或”）、|（位“或”）和~（位“取反”）
2 移位运算子：<<（左移）和>>(右移).
位“与”、位“或”和位“异或”运算子都是双目运算子，其结合性都是从左向右的，优先顺序高于逻辑运算子，低于比较运算子，且从高到低依次为&、^、|
这个是C++中的基础，你可以看看人家的部落格。
:m.blog.csdn./article/details?id=52196039
运算子那多了去了
算术运算子 + - * / % 分别是加减乘除求余
在这里要特别注意有个晋升现象.是指低于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 条件运算子
算数运算子，+-*/(+=，-=，*=，、/*) p.s. 1/0 => NaN 无穷大。逻辑运算子，略转义序列符（例举）， 退格, 制表,
换行（制图、一般println）,
回车, " 双引号, ' 单引号p.s. 取决于os，并不常用。递增/减 ++, --赋值 =比较 >=，<=, ==位移 <<，>>, >>>p.s. 图形用到注释， 行注释，/* */段注释型别转换， a = (int)b; 括号。条件， if()... == a ? true : false 三目运算。正则表示式， 应用类，用到这再说。
LZ是学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
取余运算子既可用于两个运算元都是整数的情况，也可用于两个运算元都是浮点数（或一个运算元是浮点数）的情况。当两个运算元都是浮点数时，例如7.6 % 2.9时，计算结果为：7.6 － 2 * 2.9 = 1.8。
当两个运算元都是int型别数时，a%b的计算公式为：
a % b = a － （int）(a / b) * b
当两个运算元都是long型别（或其他整数型别）数时，a%b的计算公式可以类推。
当参加二元运算的两个运算元的资料型别不同时，所得结果的资料型别与精度较高（或位数更长）的那种资料型别一致。
例如：
7 / 3 整除，运算结果为2
7.0 / 3 除法，运算结果为2.33333,即结果与精度较高的型别一致
7 % 3 取余，运算结果为1
7.0 % 3 取余，运算结果为1.0
-7 % 3 取余，运算结果为-1，即运算结果的符号与左运算元相同
7 % -3 取余，运算结果为1，即运算结果的符号与左运算元相同
2.关系运算符
关系运算符用于比较两个数值之间的大小，其运算结果为一个逻辑型别的数值。关系运算符有六个：等于（==）、不等于（!=）、大于（>）、大于等于（>=）、小于（<）、小于等于（<=）。
例如：
9 <= 8 运算结果为false
9.9 >= 8.8 运算结果为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种可能，所以表2.5共有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=s*i 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;
System.out.println（"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 = *= /= %= += －= <<= >>= >>>= &= ^= |= 右左
--感谢原作者。
位运算子并不是逻辑运算子，逻辑运算子包括或、与、非、异或。