基本运算符

Java语言支持如下运算符

  • 重点掌握的运算符

    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
            }
        }
        
posted @ 2024-03-05 16:08  阿俊学JAVA  阅读(2)  评论(0编辑  收藏  举报