• Tags
  •         
  • www.breakyizhan.com
  •    

    Java提供了许多可根据需要使用的运算符类型。他们根据他们提供的功能进行分类。有些类型是 -

    1. 算术运算符
    2. 一元运算符
    3. 赋值运算符
    4. 关系运算符
    5. 逻辑运算符
    6. 三元运算符
    7. 按位运算符
    8. 移位操作符
    9. 操作符实例
    10. 优先和相关性
    11. 有趣的问题

    让我们仔细看看它们。

    算术运算符:

    它们用于对原始数据类型执行简单的算术运算。

    • *:乘法
    • /:分区
    • %:模数
    • +:加法
    • - :减法
    // Java program to illustrate
    // arithmetic operators
    public class operators 
    {
        public static void main(String[] args) 
        {
            int a = 20, b = 10, c = 0, d = 20, e = 40, f = 30;
            String x = "Thank", y = "You";
    
            // + and - operator
            System.out.println("a + b = "+(a + b));
            System.out.println("a - b = "+(a - b));
    
            // + operator if used with strings
            // concatenates the given strings.
            System.out.println("x + y = "+x + y);
    
            // * and / operator
            System.out.println("a * b = "+(a * b));
            System.out.println("a / b = "+(a / b));
    
            // modulo operator gives remainder
            // on dividing first operand with second
            System.out.println("a % b = "+(a % b));
    
            // if denominator is 0 in division
            // then Arithmetic exception is thrown.
            // uncommenting below line would throw
            // an exception
            // System.out.println(a/c);
        }
    }
    
    

    输出:

    a + b = 30 ab = 10 x + y = ThankYou a * b = 200 a / b = 2 a%b = 0

    一元运算符

    一元运算符只需要一个操作数。它们用于增加,减少或取消一个值。

    • - :一元减号,用于否定值。
    • +:一元加号,用于给出正值。仅在故意将负值转换为正值时才使用。
    • ++:增量运算符,用于将值递增1.有两种增量运算符。
      • 后增量:值首先用于计算结果,然后递增。
      • 预增量:首先增加值,然后计算结果。
    • - :递减运算符,用于将值递减1.有两种增量运算符。
      • 后递减:值首先用于计算结果,然后递减。
      • 预先减量:首先减值,然后计算结果。
    • !:逻辑非运算符,用于反转布尔值。
    // Java program to illustrate
    // unary operators
    public class operators 
    {
        public static void main(String[] args) 
        {
            int a = 20, b = 10, c = 0, d = 20, e = 40, f = 30;
            boolean condition = true;
    
            // pre-increment operator
            // a = a+1 and then c = a;
            c = ++a;
            System.out.println("Value of c (++a) = " + c);
    
            // post increment operator
            // c=b then b=b+1
            c = b++;
            System.out.println("Value of c (b++) = " + c);
    
            // pre-decrement operator
            // d=d-1 then c=d
            c = --d;
            System.out.println("Value of c (--d) = " + c);
    
            // post-decrement operator
            // c=e then e=e-1
            c = --e;
            System.out.println("Value of c (--e) = " + c);
    
            // Logical not operator
            System.out.println("Value of !condition =" + !condition);
    
        }
    }
    

    输出:

    Value of c (++a) = 21
    Value of c (b++) = 10
    Value of c (--d) = 19
    Value of c (--e) = 39
    Value of !condition =false

    赋值运算符

    '='赋值运算符用于为任何变量赋值。它具有从左到右的结合性,即在操作符右侧给出的值被分配给左侧的变量,因此右侧的值必须在使用前声明或者应该是常量。
    赋值运算符的一般格式是,

    variable = value;

    在许多情况下,赋值运算符可以与其他运算符结合使用以构建称为复合语句的简短版本的语句。例如,而不是a = a + 5,我们可以写一个+ = 5。

    • + =,用于向右操作数添加左操作数,然后将其分配给左侧的变量。
    • - =,用右操作数减去左操作数,然后将其分配给左侧的变量。
    • * =,用于将左操作数与右操作数相乘,然后将其分配给左侧的变量。
    • / =,用左操作数除以右操作数,然后将其分配给左侧的变量。
    • ^ =,用于将左操作数的功率提高到右操作数并将其分配给左侧的变量。
    • %=,用左操作数分配左操作数模数,然后将其分配给左侧的变量。
    int a = 5;
    a + = 5; // a = a + 5;
    
    // Java program to illustrate
    // assignment operators
    public class operators 
    {
        public static void main(String[] args) 
        {
            int a = 20, b = 10, c, d, e = 10, f = 4, g = 9;
    
            // simple assignment operator
            c = b;
            System.out.println("Value of c = " + c);
    
            // This following statement would throw an exception
            // as value of right operand must be initialised
            // before assignment, and the program would not
            // compile.
            // c = d;
    
            // instead of below statements,shorthand
            // assignment operators can be used to
            // provide same functionality.
            a = a + 1;
            b = b - 1;
            e = e * 2;
            f = f / 2;
            System.out.println("a,b,e,f = " + a + "," 
                               + b + "," + e + "," + f);
            a = a - 1;
            b = b + 1;
            e = e / 2;
            f = f * 2;
    
            // shorthand assignment operator
            a += 1;
            b -= 1;
            e *= 2;
            f /= 2;
            System.out.println("a,b,e,f (using shorthand operators)= " + 
                                a + "," + b + "," + e + "," + f);
        }
    }
    

    输出:

    Value of c =10
    a,b,e,f = 21,9,20,2
    a,b,e,f (using shorthand operators)= 21,9,20,2

    关系运算符:

    这些运算符用于检查关系,如大于等于,小于等于。它们在比较之后返回布尔结果,并广泛用于循环语句以及有条件的else语句。一般格式是,

    variable relation_operator value

    一些关系运营商是 -

    • ==,等于:返回左侧的真值等于右侧。
    • !=,不等于:左侧的返回值不等于右侧。
    • <,小于:左侧的返回值小于右侧。
    • <=,小于等于:返回左侧的真值小于或等于右侧。
    • >,大于:返回左侧的真值大于右侧。
    • > =,大于或等于:返回左侧的真值大于或等于右侧。
    // Java program to illustrate
    // relational operators
    public class operators 
    {
        public static void main(String[] args) 
        {
            int a = 20, b = 10;
            String x = "Thank", y = "Thank";
            int ar[] = { 1, 2, 3 };
            int br[] = { 1, 2, 3 };
            boolean condition = true;
    
            //various conditional operators
            System.out.println("a == b :" + (a == b));
            System.out.println("a < b :" + (a < b));
            System.out.println("a <= b :" + (a <= b));
            System.out.println("a > b :" + (a > b));
            System.out.println("a >= b :" + (a >= b));
            System.out.println("a != b :" + (a != b));
    
            // Arrays cannot be compared with
            // relational operators because objects
            // store references not the value
            System.out.println("x == y : " + (ar == br));
    
            System.out.println("condition==true :" + (condition == true));
        }
    }
    

    输出:

    a == b:false
    a = b:true
    a!= b:true
    x == y:false
    condition== true:true

    逻辑运算符:

    这些运算符用于执行“逻辑与”和“逻辑或”运算,即与数字电子中的与门和或门类似的功能。有一点需要注意的是,如果第一个条件是错误的,那么第二个条件就不会被评估,即它具有短路效应。广泛用于测试几种作出决定的条件。
    有条件的运营商是 -

    • &&,逻辑AND:当两个条件都为真时返回true。
    • || ,逻辑或:如果至少有一个条件为真,则返回true。
    // Java program to illustrate
    // logical operators
    public class operators 
    {
        public static void main(String[] args) 
        {
            String x = "Sher";
            String y = "Locked";
    
            Scanner s = new Scanner(System.in);
            System.out.print("Enter username:");
            String uuid = s.next();
            System.out.print("Enter password:");
            String upwd = s.next();
    
            // Check if user-name and password match or not.
            if ((uuid.equals(x) && upwd.equals(y)) || 
                    (uuid.equals(y) && upwd.equals(x))) {
                System.out.println("Welcome user.");
            } else {
                System.out.println("Wrong uid or password");
            }
    
        }
    }
    

    输出:

    Enter username:Sher
    Enter password:Locked
    Welcome user.

    三元运算符

    三元运算符是if-else语句的简写形式。它有三个操作数,因此名称是三元的。一般格式是

    condition ? if true : if false

    上述声明意味着如果条件评估为真,那么在'?'之后执行语句。否则在':'之后执行语句。

    // Java program to illustrate
    // max of three numbers using 
    // ternary operator.
    public class operators 
    {
        public static void main(String[] args) 
        {
            int a = 20, b = 10, c = 30, result;
    
            //result holds max of three
            //numbers
            result = ((a > b) ? (a > c) ? a : 
                       c : (b > c) ? b : c);
            System.out.println("Max of three numbers = "+result);
        }
    }
    

    输出:

      • Max of three numbers = 30

    按位运算符:

    这些运算符用于执行数字的各个位的操作。它们可以与任何整数类型一起使用。它们用于执行二进制索引树的更新和查询操作。

      • &,按位AND运算符:返回输入值的AND。
      • | ,按位OR运算符:返回输入值的OR位。
      • ^,按位XOR运算符:逐位返回输入值的XOR位。
      • 〜,按位补数运算符:这是一个一元运算符,它返回输入值的补码表示,即所有位反转。
    // Java program to illustrate
    // bitwise operators
    public class operators 
    {
        public static void main(String[] args) 
        {
    
            int a = 0x0005;
            int b = 0x0007;
    
            // bitwise and
            // 0101 & 0111=0101
            System.out.println("a&b = " + (a & b));
    
            // bitwise and
            // 0101 | 0111=0111
            System.out.println("a|b = " + (a | b));
    
            // bitwise xor
            // 0101 ^ 0111=0010
            System.out.println("a^b = " + (a ^ b));
    
            // bitwise and
            // ~0101=1010
            System.out.println("~a = " + ~a);
    
            // can also be combined with
            // assignment operator to provide shorthand
            // assignment
            // a=a&b
            a &= b;
            System.out.println("a= " + a);
        }
    }
    

    输出:

    a&b = 5
    a | b = 7
    a ^ b = 2
    〜a = -6
    a = 5
    

    移位运算符

    这些运算符用于向左或向右移位数字的位,从而分别将数字乘以或除以2。当我们必须将数字乘以或除以二时,可以使用它们。一般格式 -

    • number shift_op number_of_places_to_shift;
      • <<,左移运算符:将数字的位向左移位,并在剩余的空位上填充0。将数字乘以2的幂的相似效果。
      • >>,带符号的右移运算符:将数字的位向右移位,并在剩余的空位上填充0。最左边的位取决于初始数字的符号。与用2的幂数除数类似的效果。
      • >>>,无符号右移运算符:将数字的位向右移位,并在剩余的空位上填充0。最左边的位设置为0。
    • // Java program to illustrate
      // shift operators
      public class operators 
      {
          public static void main(String[] args) 
          {
      
              int a = 0x0005;
              int b = -10;
      
              // left shift operator
              // 0000 0101<<2 =0001 0100(20)
              // similar to 5*(2^2)
              System.out.println("a<<2 = " + (a << 2));
      
              // right shift operator
              // 0000 0101 >> 2 =0000 0001(1)
              // similar to 5/(2^2)
              System.out.println("a>>2 = " + (a >> 2));
              
              // unsigned right shift operator
              System.out.println("b>>>2 = "+ (b >>> 2));
      
          }
      }
      

      输出:

      a2 = 1
      b >>> 2 = 1073741821
      

    操作实例

    运营商的实例是用来进行类型检查。它可用于测试对象是否是类,子类或接口的实例。一般格式 -

    • object instance of class/subclass/interface

     

    // Java program to illustrate
    // instance of operator
    class operators 
    {
        public static void main(String[] args) 
        {
     
            Person obj1 = new Person();
            Person obj2 = new Boy();
     
            // As obj is of type person, it is not an
            // instance of Boy or interface
            System.out.println("obj1 instanceof Person: " + 
                               (obj1 instanceof Person));
            System.out.println("obj1 instanceof Boy: " + 
                               (obj1 instanceof Boy));
            System.out.println("obj1 instanceof MyInterface: " + 
                               (obj1 instanceof MyInterface));
     
            // Since obj2 is of type boy, whose parent class is
            // person and it implements the interface Myinterface
            // it is instance of all of these classes
            System.out.println("obj2 instanceof Person: " + 
                               (obj2 instanceof Person));
            System.out.println("obj2 instanceof Boy: " + 
                               (obj2 instanceof Boy));
            System.out.println("obj2 instanceof MyInterface: " + 
                               (obj2 instanceof MyInterface));
        }
    }
     
    class Person 
    {
     
    }
     
    class Boy extends Person implements MyInterface 
    {
     
    }
     
    interface MyInterface 
    {
     
    }
    

    输出:

    obj1 instanceof Person:true
    obj1 instanceof Boy:false
    obj1 instanceof MyInterface:false
    obj2 instanceof Person:true
    obj2 instanceof Boy:true
    obj2 instanceof MyInterface:true

    运算符的优先顺序和关联性

    处理涉及多种类型算子的混合方程时,使用优先和关联规则。在这种情况下,这些规则决定首先考虑的方程的哪一部分,因为对于相同的方程可能有许多不同的估值。下表描述了运算符按降序排列的优先级,其中top表示最高优先级,bottom表示最低优先级。

    Java中的运算符

    有关运算符的有趣问题

    1. 优先级和关联性当涉及到具有多个运算符的方程的混合方程时,经常会出现混淆。问题是首先要解决哪个部分。在这些情况下有一条金科玉律。如果运营商具有不同的优先级,则首先解决更高的优先级。如果它们具有相同的优先级,则根据关联性来解决,即从右到左或从左到右。以下程序的解释完全在程序本身的注释中编写。
      public class operators 
      {
          public static void main(String[] args) 
          {
              int a = 20, b = 10, c = 0, d = 20, e = 40, f = 30;
              
              // precedence rules for arithmetic operators.
              // (* = / = %) > (+ = -)
              // prints a+(b/d)
              System.out.println("a+b/d = "+(a + b / d));
      
              // if same precendence then associative
              // rules are followed.
              // e/f -> b*d -> a+(b*d) -> a+(b*d)-(e/f)
              System.out.println("a+b*d-e/f = "+(a + b * d - e / f));
          }
      }
      

      输出:

      a + b / d = 20
      a + b * de / f = 219
      
    2. 成为编译器:我们系统中的编译器使用lex工具来匹配生成令牌时的最大匹配。这会造成一些问题,如果忽略。例如,考虑语句a = b +++ c; ,对许多读者来说,这似乎会造成编译器错误。但是这个陈述是绝对正确的,因为由lex创建的标记是a,=,b,++,+,c。因此,这种说法具有类似的效果,首先将b + c分配给a,然后将b递增。同样,a = b +++++ c; 当生成的令牌是a,=,b,++,++,+,c时会产生错误。这实际上是一个错误,因为在第二个一元操作数之后没有操作数。
      public class operators 
      {
          public static void main(String[] args) 
          {
              int a = 20, b = 10, c = 0;
      
              // a=b+++c is compiled as
              // b++ +c
              // a=b+c then b=b+1
              a = b+++c;
              System.out.println("Value of a(b+c),b(b+1),c = " + a + "," + b + "," + c);
      
              // a=b+++++c is compiled as
              // b++ ++ +c
              // which gives error.
              // a=b+++++c;
              // System.out.println(b+++++c);
          }
      }
      

      输出:

      Value of a(b+c),b(b+1),c = 10,11,0

    3. 使用+ over():在system.out.println()中使用+运算符时,请确保添加括号。如果我们在添加之前编写了一些东西,那么会发生字符串添加,即添加的相关性从左到右,因此整数会先添加到字符串中以产生字符串,而字符串对象会在使用+时连接,因此可能会产生不需要的结果。
      public class operators 
      {
          public static void main(String[] args) 
          {
      
              int x = 5, y = 8;
      
              // concatenates x and y
              // as first x is added to "concatenation (x+y) = "
              // producing "concatenation (x+y) = 5" and then 8 is
              // further concatenated.
              System.out.println("Concatenation (x+y)= " + x + y);
      
              // addition of x and y
              System.out.println("Addition (x+y) = " + (x + y));
      
          }
      }
      

      输出:

      Concatenation (x+y)= 58
      Addition (x+y) = 13
      
      Addition (x+y) = 13

     
    转载请保留页面地址:https://www.breakyizhan.com/java/3909.html