JAVA操作符(运算符)

算术操作符

 

操作符	名称	描述
+	加	加法运算
-	减	加法运算
*	乘	乘法运算
/	除	除法运算
%	模	模运算(取余数)
++	自增	自身+1  (例如 B++(后自增) 或 ++B (前自增))
--	自减	自身减1 (B--  (后自减)  或  --B (前自减))

public class Test {
 
  public static void main(String[] args) {
     int a = 10;
     int b = 20;
     int c = 25;
     int d = 25;
     System.out.println("a + b = " + (a + b) );
     System.out.println("a - b = " + (a - b) );
     System.out.println("a * b = " + (a * b) );
     System.out.println("b / a = " + (b / a) );
     System.out.println("b % a = " + (b % a) );
     System.out.println("c % a = " + (c % a) );
     System.out.println("a++   = " +  (a++) );
     System.out.println("a--   = " +  (a--) );
     System.out.println("d++   = " +  (d++) );
     System.out.println("++d   = " +  (++d) );
  }
}


运行结果:
a + b = 30
a - b = -10
a * b = 200
b / a = 2
b % a = 0
c % a = 5
a++   = 10
a--   = 11
d++   = 25
++d   = 27

关系操作符

 

操作符	名称	描述
==	等于	左右两个操作数的值是否相等，如果相等，那么条件为真，否则为假。
!=	不等于	左右两个操作数的值是否不相等，如果不相等，那么条件为真，否则为假。
>	大于	左操作数是否大于右操作数的值，如果大于，那么条件为真，否则为假。
<	小于	左操作数是否小于右操作数的值，如果小于，那条件么为真，否则为假。
>=	大于等于	左操作数是否大于或等于右操作数的值，如果大于或等于，那条件么为真，否则为假。
<=	小于等于	左操作数是否小于或等于右操作数的值，如果小于或等于，那条件么为真，否则为假。

public class TestClass {
 
  public static void main(String[] args) {
     int a = 10;
     int b = 20;
     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("b >= a = " + (b >= a) );
     System.out.println("b <= a = " + (b <= a) );
  }
}

运行结果：
a == b = false
a != b = true
a > b = false
a < b = true
b >= a = true
b <= a = false

位操作符

     

 

操作符	名称	描述
＆	与	两个操作数相对应的位都是1，则结果为1，否则为0
|	或	两个操作数相对应的位都是 0，则结果为 0，否则为 1
^	异或	两个操作数相对应的位值相同，则结果为0，否则为1
~	非	反转操作数的64位值,如果位值为0，则反转为1，如果位值为1，则反转为0.
<<	左移	操作数的所有位值向左移动两位
>>	右移	操作数的所有位值向右移动两位
>>>	无符号右移	操作数按右移来操作,空白位以0来填补

 

public class TestClass {
  public static void main(String[] args) {
     int a = 60; /* 60 = 0011 1100 */ 
     int b = 13; /* 13 = 0000 1101 */
     int c = 0;
     c = a & b;       /* 12 = 0000 1100 */
     System.out.println("a & b = " + c );
 
     c = a | b;       /* 61 = 0011 1101 */
     System.out.println("a | b = " + c );
 
     c = a ^ b;       /* 49 = 0011 0001 */
     System.out.println("a ^ b = " + c );
 
     c = ~a;          /*-61 = 1100 0011 */
     System.out.println("~a = " + c );
 
     c = a << 2;     /* 240 = 1111 0000 */
     System.out.println("a << 2 = " + c );
 
     c = a >> 2;     /* 15 = 1111 */
     System.out.println("a >> 2  = " + c );
  
     c = a >>> 2;     /* 15 = 0000 1111 */
     System.out.println("a >>> 2 = " + c );
  }
} 

＆(与)纯手工计算如下:

a=60;//使用计算器转换成二进制如下:

b=13;//使用计算器转换成二进制如下:

根据&位运算的描述计算如下:

为什么结果为12呢?看图就明白了:

|(或)位运算手工计算如下:

^(异或)纯手工计算如下:

~(非)纯手工计算如下:

对比一下就明白它的原理了.所以~60之后的值为-61.

 

剩下的左移以及右移跟无符号右移都差不多是这样来计算.大家多动手练习一下.

 

逻辑操作符

 

操作符	名称	描述
&&	逻辑且	比较左右操作数,如果两个操作数都为真,那么条件为真,否则为假.
| |	逻辑或	比较左右操作数,如果两个操作数有一个为真,那么条件为真,如果两个操作数都为假,那么条件为假.
！	逻辑非	如果操作数为真,那么条件为假,如果操作数为假,那么条件为真.

public class TestClass {

	public static void main(String[] args) {

	     boolean a = true;
	     boolean b = false;
	     System.out.println("a && b = " + (a&&b));
	     System.out.println("a || b = " + (a||b) );
	     System.out.println("!(a) = " + !(a));
		
	}

}




运行结果:

a && b = false
a || b = true
!(a) = false

 

 

赋值操作符

 

操作符	名称	描述
=	等于	将右操作数的值赋给左侧操作数
+=	加等于	将左操作数和右操作数相加得到的值,赋值给左操作数
-=	减等于	将左操作数和右操作数相减得到的值,赋值给左操作数
*=	乘等于	将左操作数和右操作数相乘得到的值,赋值给左操作数
/=	除等于	将左操作数和右操作数相除得到的值,赋值给左操作数
(％)=	模等于	将左操作数和右操作数取模后得到的值,赋值给左操作数
<<=	左移等于	右操作数左移位运算之后,赋值给左操作数
>>=	右移等于	右操作数右移位运算之后,赋值给左操作数
＆=	位与等于	右操作数位与运算之后,赋值给左操作数
^=	位异或等于	右操作数位异或运算之后,赋值给左操作数
|=	位或等于	右操作数位或运算之后,赋值给左操作数

public class TestClass {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 0;
        c = a + b;
        System.out.println("c = a + b = " + c ); //C = A + B
        c += a ;
        System.out.println("c += a  = " + c );   //	C + = A   等同于 C = C + A
        c -= a ;
        System.out.println("c -= a = " + c );    //C - = A    等同于 C = C - A
        c *= a ;
        System.out.println("c *= a = " + c );    //C * = A    等同于 C = C * A
        a = 10;
        c = 15;
        c /= a ;
        System.out.println("c /= a = " + c );    //C / = A    等同于 C = C / A    (同类型情况下)
        a = 10;
        c = 15;
        c %= a ;
        System.out.println("c %= a  = " + c );   //C％= A     等同于 C = C％A
        c <<= 2 ;
        System.out.println("c <<= 2 = " + c );   //C << = 2   等同于 C = C << 2
        c >>= 2 ;
        System.out.println("c >>= 2 = " + c );   //C >> = 2   等同于 C = C >> 2
        c &= a ;
        System.out.println("c &= a  = " + c );   //C＆= 2     等同于 C = C＆2
        c ^= a ;
        System.out.println("c ^= a   = " + c );  //C ^ = 2    等同于 C = C ^ 2
        c |= a ;
        System.out.println("c |= a   = " + c );  //C | = 2    等同于C = C | 2
    }
}







运行结果:


c = a + b = 30
c += a  = 40
c -= a = 30
c *= a = 300
c /= a = 1
c %= a  = 5
c <<= 2 = 20
c >>= 2 = 5
c &= a  = 0
c ^= a   = 10
c |= a   = 10

 

条件操作符    ?:

语法格式: (条件表达式)?值1:值2

描述:如果条件表达式为真,则取值1,否则取值2.

public class TestClass {
   public static void main(String[] args){
      
      int a , b;
      a = 10;
      

      
      b = (a == 1) ? 20 : 30;   // 如果 a 等于 1 成立，则把b 赋值为 20，否则为 30
      System.out.println( "Value of b is : " +  b );
 
      
      

      
      b = (a == 10) ? 20 : 30;   // 如果 a 等于 10 成立，则把 b 赋值为 20，否则为 30
      System.out.println( "Value of b is : " + b );


   }
}

instanceof操作符

检查某个对象实例是否为指定的类型,如果是指定的类型则为真,否则为假.

例如:

 

最后说说操作符的优先级,这么多操作符,不同的优先级运算的结果是不一样的.我们可没有那么多时间以及精力去完完全全掌握他们的优先级,

所以这里有一个最简单的办法,就是使用"()"括号来表达他们的优先级,开发者想先运算哪里就用()括起来就行了,就是这么简单.