Java运算符
运算符简介
所有程序开发都是一种数字的处理游戏，对于数字的处理一定会有所谓的操作模式，而这些操作模式就称为运算符。
例如：如果要进行加法运算肯定使用的“+”这样的运算符来完成，而对于运算符而言，也是存在有先后的关系，小学的四则运算先乘除后加减的顺序来完成。
首先对于程序开发而言，里面会提供有大量的基础运算符，那么这些运算符也都会提供有各自的优先顺序，可是从正常角度来讲个人不建议去记这些运算符优先级。
1 * 2 + 3 / 4 对程序来讲费神
(1 * 2) + (3 / 4) 简单清晰，一目了然
运算符
上面的运算符不用去记，只有记住：括号的优先级最高
关键性的问题是，对于程序的开发而言，个人不建议编写很复杂的计算。
范例：以一个程序为例
public class JavaDemo {
public static void main(String args[]) {
int x = 10 ;
int y = 20 ;
int result = x -- + y++ * -- y / x / y * ++ x - --y + y ++ ;
System.out.println(result) ;
}
}
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
30
为什么是30不要去弄懂它，鬼才知道
如果你在项目代码里面按照上面的逻辑编写了代码，小心被人骂祖宗二十代。所以对于程序代码而言，实际上已经告别了复杂程序逻辑时代，更多情况下是希望大家去编写一些简单易懂的代码。
数学运算符
在Java中数学运算都提供了标准的支持。包括四则运算都是支持的。
范例：实现一个简单的四则运算
public class JavaDemo {
public static void main(String args[]) {
int result = 890234890 * (2902390 + 100) * 2 ;
System.out.println(result) ;
}
}
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
886891784
在进行变量计算的时候，编程语言一般也都会提供有简化的运算符（+=、*=、-=、/=、%=）支持。
范例：简化运算符
public class JavaDemo {
public static void main(String args[]) {
int num = 10 ;
num = num + 20 ; // num +=20 效果是类似的，但是“+=”操作占用内存会小
System.out.println(num) ;
}
}
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
30
对于以上“num = num + 20” 在内存小的时候就不适合了，所以才提供有一系列的简化运算
public class JavaDemo {
public static void main(String args[]) {
int num = 10 ;
num %= 3 ;
System.out.println(num) ;
}
}
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
1
在数学计算里面最头疼的就是“++”、“--”，因为这两种运算符有两类使用方式：
++ 变量、-- 变量：先进行变量的自增或自减，而后再进行数字计算；
变量 ++、变量 --：先使用变量进行计算，而后再进行自增或自减。
能不这么用是最好了，碰上了就要正常接受。
范例：实现自增与自减
public class JavaDemo {
public static void main(String args[]) {
int x = 10 ;
int y = 20 ;
// 1、++ x：首先x的内容要先自增1，为11；
// 2、y --：先进行计算，使用内容是20，计算完成后自减
int result = ++ x - y -- ;
System.out.println("计算结果：" + result) ; // -9
System.out.println("x = " + x) ; // 11
System.out.println("x = " + y) ; // 19
}
}
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
计算结果：-9
x = 11
x = 19
把上面代码中的 “int result = ++ x - y -- ;” 替换为 如下代码：
++ x ;
int result = x - y ;
y -- ;
两个代码执行结果一致，此代码更加清晰明了。
强烈建议：数学计算关系里面就写类似下面代码这种简单计算操作。
关系运算符
关系运算的主要特征就是进行大小的比较处理，包括：大于（>）、小于（<）、大于等于（>=）、小于等于（<=）、不等于（!=）、相等（==）。所有的关系运算返回的判断结果都是布尔类型的数据。
单等（=）是赋值
双等（==）是逻辑关系比较
范例：做一个大小关系的判断
public class JavaDemo {
public static void main(String args[]) {
int x = 10 ;
int y = 20 ;
boolean flag = x > y ; // false 所有的关系运算返回的判断结果都是布尔类型的数据
System.out.println(flag) ;
}
}
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
false
在进行关系判断的时候特别需要注意的就是相等的判断问题。在Java里面“=”表示的赋值运算、而内容相同的比较是“==”。
范例：判断相等
public class JavaDemo {
public static void main(String args[]) {
int x = 10 ;
int y = 10 ;
boolean flag = x == y ; // true
System.out.println(flag) ;
}
}
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
true
在进行关系运算的时候可以针对于所有的基本数据类型，例如：也可以直接使用字符来处理。
范例：在字符处理上使用关系运算
public class JavaDemo {
public static void main(String args[]) {
char c = '建' ; // 单引号是字符，双引号是字符串（多个字符）
System.out.println((int)c) ;
}
}
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
24314
public class JavaDemo {
public static void main(String args[]) {
char c = '建' ;
boolean flag = 24314 == c ; // true，数据类型之间提供有转型支持
System.out.println(flag) ;
}
}
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
true
数据类型之间提供有转型支持，所以在进行判断的时候字符会自动转为int而后进行数字的比较。
逻辑运算符【三目（赋值）运算符】
在进行程序开发的时候三目运算符使用的非常多，而且合理利用三目运算可以避免一些大范围的程序编写。三目是一种所谓的赋值运算处理。它是需要设置一个逻辑关系的判断之后才可以进行的赋值操作。基本语法如下：
关系运算 ? 关系满足时的内容 : 关系不满足时的内容。
范例：判断两个数字的大小，将最大值保存
public class JavaDemo {
public static void main(String args[]) {
int x = 10 ;
int y = 20 ;
// 判断x与y的大小关系来决定最终max变量的内容
int max = x > y ? x : y ;
System.out.println(max) ;
}
}
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
20
public class JavaDemo {
public static void main(String args[]) {
int x = 10 ;
int y = 20 ;
// 判断x与y的大小关系来决定最终max变量的内容
int max = 0 ;
if (x > y) {
max = x ;
} else {
max = y ;
}
System.out.println(max) ;
}
}
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
20
以上两个代码执行结果一致，但是下方的代码长度更长。
代码越少且能完成相同功能是最好的。
三目运算本身也可以进行嵌套处理，也就是说在赋值语句位置上可以进一步编写三目运算。
范例：三目运算嵌套，将三个数字中的最大值保存下来
public class JavaDemo {
public static void main(String args[]) {
int x = 10 ;
int y = 20 ;
int z = 15 ;
int max = x > y ? (x > z ? x : z) : (y > z ? y : z) ;
System.out.println(max) ;
}
}
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
20
虽然允许进行嵌套处理，但是程序的可读性变的很差，根据实际的情况确定是否使用。
三目是一个赋值运算符，很重要，一定要掌握，以后开发一定会用到。
位运算符
位运算指的是可以直接进行二进制数据的计算处理，主要有：与（&）、或（|）、异或（^）、反码（~）、移位处理。如果要想理解位操作，则一定要清楚十进制与二进制之间的转换处理逻辑：数字除2取余。
13的二进制
13/2 = 6 ...... 1
6/2 = 3 ...... 0
3/2 = 1 ...... 1
1/2 = 0 ...... 1
除到商为0结束，从下到上读：1101
Java中的整型int是32位。所以应该是：13 -> 00000000 00000000 00000000 00001101
简单计算
1 2 4 8
1 0 1 1
1x1 + 0x2 + 1x4 + 1x8 = 13
范例：观察与操作，如果两位都是1结果才是1，有1位是0结果就是0
public class JavaDemo {
public static void main(String args[]) {
int x = 13 ;
int y = 7 ;
System.out.println(x & y) ;
}
}
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
5
13的二进制：00000000 00000000 00000000 00001101
7的二进制： 00000000 00000000 00000000 00000111
根据规则：如果两位都是1结果才是1，有1位是0结果就是0，可以得出如下结果
&计算： 00000000 00000000 00000000 00000101 ——> 5（1x1 + 0x2 + 1x4）
范例：观察或运算，有1位是1结果就是1，2位都是0的时候结果才是0
public class JavaDemo {
public static void main(String args[]) {
int x = 13 ;
int y = 7 ;
System.out.println(x | y) ;
}
}
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
15
13的二进制：00000000 00000000 00000000 00001101
7的二进制： 00000000 00000000 00000000 00000111
根据规则：有1位是1结果就是1，2位都是0的时候结果才是0
或(|)计算： 00000000 00000000 00000000 00001111 ——> 15（1x1 + 1x2 + 1x4 + 1x8）
在进行位运算处理的时候还可以进行移位的计算。例如：以2的3次方为例。
范例：移位处理
public class JavaDemo {
public static void main(String args[]) {
int x = 2 ;
System.out.println(x << 2) ; // 向左边移动2位"<<"就是2的3次方
System.out.println(x) ;
}
}
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
8
2
2的二进制：00000000 00000000 00000000 00000010；从右向左的1248的原则
向左移2位：00000000 00000000 00000000 00001000；——> 8（根据从右向左的1248的原则，8的位置是1，结果就是8）
最初提高计算的性能可以通过位来完成。
现在很多程序帮助准备好类库了，自己可以简单完成。
还有就是内存很大，就是你写的再不怎么样，性能也不会查到哪去。
那为什么还有位操作呢？
面试题：请解释&和&&、|和||的区别？（这个答案知道就可以了）
& 和 | 两个运算符可以进行位运算与逻辑运算；
在进行“逻辑运算”的时候，所有的判断条件都要执行；
在进行“位运算”的时候，只是针对于当前的数据进行“与”和“或”处理；
在逻辑运算上还可以使用&&（短路与）、||（短路或）；
&&：在若干个条件判断的时候，如果前面的条件返回了false，后续所有的条件都不再判断，最终的结果就是false；
||：在若干个条件判断的时候，如果前面的条件返回了ture，后续的条件不再执行，最终结果就是true；
