Java 操作符小记

　　"在最底层，Java中的数据是通过使用操作符来操作的" (Thinking in Java)

1 算术操作符

　　Java 中的基本算术操作符和其他大多数程序设计语言是相同的。其中包括加（+）、减（-）、乘（*）、除（/）和取模操作符（%，求余数）。整数除法会直接去掉结果的小数位，而不是进行四舍五入计算结果。除了这四种基本算术操作符，还有一种同时进行运算和赋值的运算符（在基本算术操作符后面紧跟一个等号来表示：+=、-=、*=、/=）。下面这个例子展示各种算术操作符的用法：

 1 /**
 2  * 算术操作符用法
 3  */
 4 public class ArithmeticOperation {
 5     public static void main(String[] args) {
 6         // 创建一个随机数对象，数字 47 是随机数种子（经过多次试验得到，由47做种后，产生的随机数更加体现了随机性）
 7         Random random = new Random(47);
 8         int i, j, k;
 9         // 产生 1~100的随机数
10         i = random.nextInt(100) + 1;
11         j = random.nextInt(100) + 1;
12
13         System.out.println("i : " + i + "\nj : " + j);
14
15         k = i + j;
16         System.out.println("i+j : " + k);
17         k = i - j;
18         System.out.println("i-j : " + k);
19         k = i * j;
20         System.out.println("i*j : " + k);
21         k = i / j;
22         System.out.println("i/j : "  + k);
23         k = i % j;
24         System.out.println("i%j : " + k);
25         i %= j;
26         System.out.println("i %= j : " + i);
27
28         float u, v, w;
29         u = random.nextFloat();
30         v = random.nextFloat();
31         System.out.println("u : " + u + "\nv : " + v);
32         w = u + v;
33         System.out.println("u + v : " + w);
34         w = u - v;
35         System.out.println("u + v : " + w);
36         w = u * v;
37         System.out.println("u + v : " + w);
38         w = u / v;
39         System.out.println("u + v : " + w);
40
41         w += u;
42         System.out.println("w += u : " + w);
43         w -= u;
44         System.out.println("w -= u : " + w);
45         w *= u;
46         System.out.println("w *= u : " + w);
47         w /= u;
48         System.out.println("w /= u : " + w);
49
50         /**
51          * output:
52          * i : 59
53          * j : 56
54          * i+j : 115
55          * i-j : 3
56          * i*j : 3304
57          * i/j : 1
58          * i%j : 3
59          * i %= j : 3
60          * u : 0.5309454
61          * v : 0.0534122
62          * u + v : 0.5843576
63          * u + v : 0.47753322
64          * u + v : 0.028358962
65          * u + v : 9.940527
66          * w += u : 10.471473
67          * w -= u : 9.940527
68          * w *= u : 5.2778773
69          * w /= u : 9.940527
70          */
71     }
72 } 

2 自动递增和递减

　　递增操作符为  “++”，意为 “增加一个单位”；递减操作符为  “--”，意为 “减少一个单位”。这两个操作符各有两种使用方式，通常称为  “前缀式”  和  “后缀式”。若  “++” 位于变量或表达式前面即为前缀递增，后面即为后缀递增；若  “--” 位于变量或者表达式后面即为后缀递减，前面即为前缀递减。对于前缀递增或递减（如 ++a 或 --a），会先进行计算，再赋值。而对于后缀递增或递减（如 a++ 或 a--）,会先赋值，再进行计算。

例子如下：

 1 /**
 2  * 自动递增或递减运算
 3  */
 4 public class AutoTest {
 5
 6     public static void main(String[] args) {
 7         int a = 1;
 8         System.out.println("a : " + a);
 9         // 先计算将 a 加 1 变为 2，再输出
10         System.out.println("++a : " + ++a);
11         // 先输出 a , 再计算将 a 加 1
12         System.out.println("a++ : " + a++);
13         System.out.println("a : " + a);
14
15         System.out.println("--a : " + --a);
16         System.out.println("a-- : " + a--);
17         System.out.println("final a : " + a);
18         /**
19          * output:
20          * a : 1
21          * ++a : 2
22          * a++ : 2
23          * a : 3
24          * --a : 2
25          * a-- : 2
26          * final a : 1
27          */
28     }
29
30 }

3 关系操作符

　　关系操作符执行结果为boolean (布尔) 值，若为真即为 true (真) ，反之即为 false (假)。关系操作符包括小于（<）、大于（>）、小于或等于（<=）、大于或等于、等于（==）以及不等于（!=）。等于和不等于适用于所有的基本数据类型（byte,short,int,long,float,double,boolean,char），而其他比较符不适用于boolean类型。因为boolean 只有true和false两种值，“大于” 和 “小于” 没有实际意义。

3.1 测试对象的等价性

　　==  和  != 也适用于任何对象，但是他们比较的是对象的引用（也就是引用所指向的内存地址）。若要比较两个对象的实际内容，必须使用所有对象都实用的 equals() 方法，但是这个方法不适用于基本数据类型，基本数据类型直接使用 == 或 != 即可。

例子如下：

 1 /**
 2  * 相等测试
 3  */
 4 public class EquivalenceTest {
 5     public static void main(String[] args) {
 6         Integer integer0 = new Integer(27);
 7         Integer integer1 = new Integer(27);
 8
 9         System.out.println(integer0 == integer1);
10         System.out.println(integer0 != integer1);
11         /**
12          * output:
13          * false
14          * true
15          */
16     }
17 }

此外，对于这种为包装类直接赋值的比较

Integer a = 355;
Integer b = 455;

阿里Java开发规范建议：

所有的包装类对象之间值的比较，全部使用equals方法比较。
说明：对于Integer var=?在-128至127之间的赋值，Integer对象是在IntegerCache.cachec产生，会复用已有对象，这个区间内的值可以直接使用==进行判断，但是这个区间以外的所有数据，都会在堆上产生，并不会复用已有对象，这是一个大坑，推荐使用
equals方法进行判断。
if(a.equals(b)){
// code
}

4 逻辑操作符

　　逻辑操作符 “与”（&）、“或”（|）、“非”（!）、“短路与”（&&）和  “短路或”（||）。这里就解释下  &&  和 || 。“与” 表示为两个布尔值都为true时方为true，操作符两边的表达式都会执行。而&& 表示“短路与”，即一种短路现象，若第一个表达式的值为false，则不会去执行第二个表达式的boolean值。短路或也是同样的道理，若第一个表达式的值为true，则不会执行操作符右边的表达式，因为 “或” 只要有一个为true即为true。

示例如下：

 1 public class Bool {
 2     public static void main(String[] args) {
 3         int i=1, j = 2;
 4         // & 两边表达式都会执行
 5         System.out.println((i > 0) & (j < 0));
 6         //短路与 第一个表达式为 false ,第二个表达式不会执行
 7         System.out.println((i < 0) && (j < 0));
 8         // | 两边表达式都会执行
 9         System.out.println((i > 0) | (j < 0));
10         //短路或 第一个表达式为 true ,第二个表达式不会执行
11         System.out.println((i > 0) || (j < 0));
12         // boolean 转String
13         System.out.println("boolean 转 String : " + (i > 0));
14         /**
15          * output:
16          * false
17          * false
18          * true
19          * true
20          * boolean 转 String : true
21          */
22     }
23 }

5 按位操作符

　　按位操作符用来操作整数基本数据类型（byte,short,int,long）中的单个“比特”（bit），即二进制位。按位操作符会对两个参数中对应的位执行布尔代数运算，并最终生成一个结果。按位操作符与逻辑操作符使用了相同的符号，但是按位操作符没有“短路”。若两个输入位都为1，则按位“与”（&）输出1，反之输出0；若两个输入位里只要有一个为1，则按位“或”（|）输出1，反之输出0；若两个输入位不全为1或不全为0，则按位异或（^）输出1，反之输出0。按位“非”（~），生成与输入位相反的值，即若输入1，则输出0；若输入0，则输出1。

　　按位操作符可以与等号（=）联合使用，以便合并运算和赋值：&=，|=，^= 都是合法的，由于“非”（~）是一元操作符，所以不可与“等号”（=）联合使用。

示例代码如下：

 1 /**
 2  * 按位操作符代码示例
 3  */
 4 public class BitwiseOperatorTest {
 5     public static void main(String[] args) {
 6         // 0b 表示二进制
 7         int x = 0b01;
 8         int y = 0b10;
 9         int z;
10         z = x & y;
11         // toBinaryString 方法转为二进制字符串形式
12         System.out.println(Integer.toBinaryString(z));
13         z = x | y;
14         System.out.println(Integer.toBinaryString(z));
15         z = x ^ y;
16         System.out.println(Integer.toBinaryString(z));
17         x &= y;
18         System.out.println(Integer.toBinaryString(x));
19         x |= y;
20         System.out.println(Integer.toBinaryString(x));
21         x ^= y;
22         System.out.println(Integer.toBinaryString(x));
23         /**
24          * output:
25          * 0
26          * 11
27          * 11
28          * 0
29          * 10
30          * 0
31          */
32     }
33 }

6 移位操作符

　　移位操作符操作的运算对象也是二进制的“位”。移位操作符只可以用来处理整数类型（int和long,其他的类型都会转换为int在进行移位运算）。左移操作符（<<）能按照操作符右侧（如 1<<2）指定的位数将操作符左侧的操作数向左移动（在低位补0，即右侧移动空出来的位数）。右移操作符分为“有符号”右移和“无符号”右移。“有符号”右移操作符（>>）则按照操作符右侧（如 1>>2）指定的位数将操作符左侧的操作数向右移动。“有符号”中，若符号位正，则在高位插入0；若符号为符，则在高位插入1。“无符号”右移操作符（>>>），就是无论正负（相当于取绝对值），都在高位插入0。

　　如果对byte、short、char 类型的数值进行移位运算，那么在移位之前都会被转为int类型，并且得到的结果也是int类型的值。对于int的位移运算，操作符右侧的操作位数，只有低5位才有用（因为：5位二进制数所能表示的最大数为11111，即 2^5-1=31，而在Java中int类型占4个字节，也就是32位），这样可以防止我们位移超过int型值所具有的的位数。若对long类型的数值进行移位运算，最后得到的结果也是long型，此时只有低6位有用（同理，在Java中long类型找8个字节64位）。

　　另外，移位操作符也可以与“等号”（=）结合使用：<<=、>>=、>>>=。

示例代码如下：

 1 /**
 2  * 移位操作符测试代码
 3  */
 4 public class ShiftOperatorTest {
 5     public static void main(String[] args) {
 6         int u = 0b01, v = 0b10, w;
 7         w = u << 2;
 8         System.out.println(Integer.toBinaryString(w));
 9         w = u >> 2;
10         System.out.println(Integer.toBinaryString(w));
11         w = v >> 2;
12         System.out.println(Integer.toBinaryString(w));
13         w = v >>> 2;
14         System.out.println(Integer.toBinaryString(w));
15         u <<= 2;
16         System.out.println(Integer.toBinaryString(u));
17         v >>= 2;
18         System.out.println(Integer.toBinaryString(v));
19         u >>>= 2;
20         System.out.println(Integer.toBinaryString(u));
21         /**
22          * output:
23          * 100
24          * 0
25          * 0
26          * 0
27          * 100
28          * 0
29          * 1
30          */
31     }
32 }

6 三元操作符

三元操作符表达式为：（boolean-expression ？ value0 : value1），当布尔表达式值为true时，计算value0并返回结果，否则计算value1返回（计算）结果。

例如：　　

// 值为 7
int chooseMax = 2 > 7 ? 2 : 7;

　　该表达式不要频繁使用，因为很容易产生可读性极差的代码。

7 知识点

　　在对基本数据类型执行算术运算或者按位运算时，表达式中出现的最大数据类型决定了表达式最终结果的数据类型。如果将一个float值与一个double值相乘，结果为double类型；若将一个int值和一个long值相加，则结果为long。此外，整数的默认类型为int类型，浮点型的默认类型为double型。

　　还有很多细节知识需要多多实践~~

----------------------------end-----------------------------------有时候你不努力一下，都不知道什么叫做绝望。