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；