大部分编程语言的基本运算符与二进制运算符详解

编程语言基本支持如下运算符

重点掌握的运算符

1. 算数运算符：+、-、*、/、%、++、--

   • %(取余、模运算)：例如 11 / 5 = 2 .. 1（余1）

   • +、-、*、/运算代码举例

     public class Demo01 {
         public static void main(String[] args) {
             int a = 10;
             int b = 20;
             int c = 25;
             int d = 25;
     
             System.out.println(a+b); //30
             System.out.println(a-b); //-10
             System.out.println(a*b); //200
             System.out.println(a/(double)b); //0.5  这里需要重点注意其中一个int类型值的类型转换，否则会返回0
         }
     }
     

     public class Demo02 {
         public static void main(String[] args) {
             long a = 123456789012345L;
             int b = 123;
             short c = 10;
             byte d = 8;
     
             System.out.println(a+b+c+d); //1234567890123486 返回long类型值
             System.out.println(b+c+d); //141 返回int类型值
             System.out.println(c+d); //18 返回int类型值
     
             //当运算时运算的数值内含有long类型时，优先返回long类型。反之默认返回int类型，需要返回浮点数时需要在运算时进行其中一位数值转换类型！
         }
     }
     

   • %运算(模运算)代码举例

     public class Demo04 {
         public static void main(String[] args) {
             
             //模运算取余用法
             
             int a = 10;
             int c = 21;
     
             System.out.println(c%a); //1    21 / 10 = 2 .. 1
             
         }
     }
     

   • ++、--运算代码举例

     public class Demo05 {
         public static void main(String[] args) {
             //++    --    自增    自减     一元运算符
     
             int a = 3;
     
             int b = a++; //执行完这行代码后，先给b赋值，b等于a时，再自增
             //a = a + 1
             System.out.println(a); //4
             //a = a + 1
             int c = ++a; //执行完这行代码后，先自增，再把结果给c赋值
     
             System.out.println(a); //5
             System.out.println(b); //3
             System.out.println(c); //5
     
             //a-- --a 同理
             
             //注意点举例
             int e = 5;
             boolean f = e++==5;
             
             System.out.println(e); //5 ++不会在布尔值类型变量中执行运算
         }
     }
     

2. 赋值运算符：=

   • =：例如 int a = 10

3. 关系运算符：>、<、>=、<=、==、!=

   • ==：判断(if)语法中等于使用’==‘运算

   • !=：判断(if)语法中不等于使用'=='运算

   • true与false运算代码举例

     public class Demo03 {
         public static void main(String[] args) {
             //关系运算符返回的结果：正确、错误 (布尔值)
             //通过if运算返回true或者false
             
             int a = 10;
             int b = 20;
     
             System.out.println(a>b); //false
             System.out.println(a<b); //true
             System.out.println(a==b); //false
             System.out.println(a!=b); //true
         }
     }
     

4. 逻辑运算符：&&、||、!

   • &&：与、and、且

   • ||：或、or

   • !：非、取反

   • &&、||、!运算代码举例

     //逻辑运算符
     public class Demo07 {
         public static void main(String[] args) {
             //  与(and、且)  或(or)   非(取反)
             boolean a = true;
             boolean b = false;
     
             System.out.println("a && b:" + (a&&b)); //false 逻辑与运算：两个变量都为真，结果才返回true
             System.out.println("a || b:" + (a||b)); //true 逻辑或运算：两个变量有一个为真，结果才返回true
             System.out.println("! (a && b):" + !(a&&b)); //true 逻辑非运算：通过与、或运算，结果为真则返回false，反之返回true
     
             //短路运算
             int c = 5;
             boolean d = (c<4)&&(c>4);
     
             System.out.println(d); //false 在布尔值类型变量的与运算中，若出现2个逻辑运算时第一个逻辑返回false后面的逻辑运算则终止
         }
     }
     

用于效率的运算符

1. 位运算符：&、|、^、~、>>、<<

   • ^(幂运算)：2 ^ 3 = 2 * 2 * 2 = 8

   • ^运算代码举例

     public class Demo06 {
         public static void main(String[] args) {
             //很多运算，我们会使用一些工具类来操作
             double pow = Math.pow(2,3); //2的3次方
             System.out.println(pow); //8.0      2 * 2 * 2
         }
     }
     

   • &、|、^、~位运算

     • 位运算：专门用于二进制逻辑判断(非0即1)

     • &：与、and、且

     • |：或、or

     • ^：取异位

     • ~：取反

     • 代码运算举例

       public class Demo08 {
           public static void main(String[] args) {
               /*
               二进制位运算符应用
               真为1反之为0 (1优先级大于0，取异位符运算时0优先级大于1)
               A = 0011 1100;
               	↓↓↓↓ ↓↓↓↓
               B = 0000 1101;
               ↓二进制数位对位运算↓
               A&B 0000 1100; //与运算时都为1才返回1，反之返回0
               A|B 0011 1101; //或运算时有一位数为1即返回1，否则返回0
               A^B 0011 0001; //取异位运算时数值相同为0，反之为1
               ~B  1111 0010; //取反运算时数值0则返回1，反之返回0
               */
           }
       }
       

     • 通常面试时会被提问，2 * 8 怎么运算？

       • 我们都知道 2 * 8 = 16，但是计算机不知道，我们可以把它拆分为 2 * 2 * 2 * 2 ，在数值运算时每次运算都在变大，而在二进制位运算中，它会运算的非常快，在位运算中，它只需要换一个灯亮改变高低电路即可(0变为1)；而计算机正常运算这个的话，由于它底下都是电路的原因，它会在底层做非常多的事情。

   • <<、>>位运算

     • <<：左移、增大一倍

     • >>：右移、减小一倍

     • 代码运算举例

       /*
       在很多底层算法里面会用到位计算来做一些精巧的运算，在位运算当中有一个好处：效率高。因为它是跟底层(二进制)打交道的
       
       <<：左移、增大一倍
       >>：右移、减小一倍
       
       0000 0000 = 0
       0000 0001 = 1
       0000 0010 = 2 //1 + 1 = 2 进1
       0000 0011 = 3
       0000 0100 = 4 //2 + 2 = 4 进1
       0000 1000 = 8 //4 + 4 = 8 进1
       0001 0000 = 16 //8 + 8 = 16 进1
       
       二进制数数字1每右移一位，十进制数值即增大一倍
       我们只需要只要相同的数+相同的数即为逢二进一即可
       */
       
       System.out.println(2<<3); //16   2 (0000 0010) 右移3位即为 0001 0000
       

2. 条件运算符：?、: (三元运算符)

   • 代码运算举例

     public class Demo10 {
         public static void main(String[] args) {
             // 三元运算符
             // x ? y : z
             //如果x==true，返回y，反之返回z
     
             int score = 80;
             String type = score <60 ?"不及格":"及格";
             
             System.out.println(type); //及格
         }
     }
     

3. 扩展赋值运算符：+=、-=、*=、/=

   • 代码运算举例

     public class Demo09 {
         public static void main(String[] args) {
             int a = 10;
             int b = 10;
     
             a += b; //a = a + b
     
             System.out.println(a); //20
     
             a -= b; //a = a - b
     
             System.out.println(a); //10
     
             a *= b; //a = a * b
     
             System.out.println(a); //100
     
             a /= b; //a = a / b
     
             System.out.println(a); //10
         }
     }
     

4. 扩展字符串连接符：+

   • 代码运算举例

     public class Demo09 {
         public static void main(String[] args) {
             int a = 10;
             int b = 10;
             
             System.out.println(a+b); //20 ‘+’执行正常int代码运算
             System.out.println(""+a+b); //1010 在运算代码前面加入string时，‘+’会转变为字符串链接符
             System.out.println(a+b+""); //20 在运算代码后面加入string时，‘+’会先执行正常int代码运算，最后得出的int结果通过后面的string整体变为string
         }
     }